Add an ncl tasks resource so operators can stop runaway tasks

Adds a host-side `ncl tasks` CLI resource (list/get/cancel/pause/resume)
backed by per-session inbound.db rows rather than the central DB, giving
operators a way to stop a runaway scheduled task without asking the agent
that owns it.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

.claude/skills/add-audit/REMOVE.md

@@ -1,52 +0,0 @@
-# Remove /add-audit
-
-Reverses every change the skill made. Safe to re-run even if some pieces are
-already gone. Run from the NanoClaw project root.
-
-## 1. Delete the copied files
-
-```bash
-rm -rf src/audit
-rm -f src/cli/dispatch.audit.ts src/cli/dispatch.audit.test.ts
-rm -f src/cli/resources/audit.ts
-rm -f src/audit-wiring.test.ts
-```
-
-## 2. Revert the dispatch composition
-
-In `src/cli/dispatch.ts`, delete (not comment out) the three edits the skill
-made:
-
-1. The import line: `import { withAudit } from './dispatch.audit.js';`
-2. The composition block (comment + `export const dispatch = withAudit(dispatchInner);`)
-3. Rename the dispatcher back — change `async function dispatchInner(` to
-   `export async function dispatch(`
-
-## 3. Unregister the resource
-
-Delete the `import './audit.js';` line from `src/cli/resources/index.ts`.
-
-## 4. Remove the settings
-
-Delete the `AUDIT_ENABLED` and `AUDIT_RETENTION_DAYS` lines from `.env`.
-
-## 5. Rebuild and restart
-
-```bash
-pnpm run build
-source setup/lib/install-slug.sh
-launchctl kickstart -k gui/$(id -u)/$(launchd_label)   # macOS
-# systemctl --user restart $(systemd_unit)             # Linux
-```
-
-## Day-files
-
-`data/audit/*.ndjson` are the operator's records and are deliberately left in
-place. To purge them too:
-
-```bash
-rm -rf data/audit
-```
-
-No dependency was added, nothing under `container/` was touched, and no DB
-schema changed — there is nothing else to undo.

.claude/skills/add-audit/SKILL.md

@@ -1,211 +0,0 @@
----
-name: add-audit
-description: Add an opt-in local audit log for the ncl command surface — every dispatch outcome on both transports (host socket and container), including scope denials, approval holds, and approved replays, written as SIEM-shaped append-only NDJSON day-files under data/audit/. Read back with `ncl audit list`; plug exporters in via registerAuditHook. Off until AUDIT_ENABLED=true.
----
-
-# /add-audit — Local Audit Log (ncl surface)
-
-Records one canonical audit event for every command that reaches the `ncl`
-dispatcher — human over the host socket or agent over the container transport
-— including denials. Both transports converge on the exported `dispatch`, so
-one composition covers the whole surface: there is no second door.
-
-```
-ncl (host socket) ──┐
-                    ├─→ dispatch = withAudit(dispatchInner) ─→ one NDJSON line
-container cli_request ┘        │                               data/audit/<UTC-day>.ndjson
-approved replay (grant) ───────┘
-```
-
-What one event carries: `actor` (`host:<os-user>` or the agent group),
-`origin` (transport, session, channel), dotted `action` from the guard
-catalog (e.g. `groups.config.add-mcp-server`), touched/attempted `resources`,
-`outcome` (`success · failure · denied · pending`), `correlation_id` (the
-approval id on gated chains — the pending event and the approved replay share
-it, so `--correlation <id>` returns the whole chain), and redacted `details`.
-
-Scope of this increment: the ncl dispatch surface only. Approval-lifecycle
-events (request/decision as their own events), OneCLI credential holds, and
-channel/sender events are later increments — they attach to `src/audit/` as
-pure adds (new `*.audit.ts` adapters and observer subscriptions).
-
-## Steps
-
-### 0. Pre-flight (idempotency)
-
-The apply is safe to re-run; every step below is guarded. Skip to
-**Enable** if all of these already hold:
-
-- `src/audit/` exists
-- `src/cli/resources/index.ts` contains `import './audit.js';`
-- `src/cli/dispatch.ts` contains `export const dispatch = withAudit(dispatchInner);`
-
-Before editing, verify the reach-in targets still exist: `src/cli/dispatch.ts`
-must contain `export async function dispatch(` (or the already-applied
-composition), and `src/cli/resources/index.ts` must be the resource barrel (a
-list of `import './<resource>.js';` lines). If either has moved, stop and
-adapt rather than guessing.
-
-### 1. Copy the payload
-
-From the NanoClaw project root:
-
-```bash
-cp -R "${CLAUDE_SKILL_DIR}/add/src/." src/
-```
-
-What lands (mirrors of the destination paths):
-
-- `src/audit/` — the domain-free leaf: event schema (`types.ts`), env config
-  (`config.ts`), redactor, NDJSON day-file store, emit seam, post-write hooks,
-  reader, boot/maintenance wiring, vocabulary — plus its tests.
-- `src/cli/dispatch.audit.ts` — the CLI adapter: `withAudit` middleware and
-  the actor/origin/resource mapping (+ `dispatch.audit.test.ts`).
-- `src/cli/resources/audit.ts` — the read-only `ncl audit` resource.
-- `src/audit-wiring.test.ts` — goes red if either core edit below is deleted
-  or drifts.
-
-### 2. Register the resource
-
-Append to `src/cli/resources/index.ts` (skip if the line is already present):
-
-```typescript
-import './audit.js';
-```
-
-### 3. Compose the dispatch middleware
-
-This is the skill's one functional reach-in, in `src/cli/dispatch.ts`. Three
-small edits:
-
-1. Add the import (next to the other `./` imports):
-
-   ```typescript
-   import { withAudit } from './dispatch.audit.js';
-   ```
-
-2. Rename the dispatcher declaration — change
-
-   ```typescript
-   export async function dispatch(
-   ```
-
-   to
-
-   ```typescript
-   async function dispatchInner(
-   ```
-
-3. Directly after that function's closing brace (before the
-   `registerApprovalHandler('cli_command', …)` block), add:
-
-   ```typescript
-   // Audit middleware (installed by /add-audit): the exported dispatch is the
-   // wrapped function, so both transports and the approved replay below all
-   // pass the one composition.
-   export const dispatch = withAudit(dispatchInner);
-   ```
-
-The composition must live at the definition site (not at the import sites):
-the approved-replay handler in the same file calls `dispatch(...)` too, and
-only the wrapped export covers it. `src/audit-wiring.test.ts` asserts exactly
-this shape via the TypeScript AST.
-
-Loading `dispatch.audit.ts` also boots the audit log: on an enabled box it
-asserts `data/audit/` is writable (refusing to start beats a silent audit
-gap), runs the boot retention prune, and arms an unref'd maintenance timer.
-Nothing else in core changes — no `index.ts` or `host-sweep.ts` edits.
-
-### 4. Enable
-
-Add the two settings to `.env` (idempotent — overwrite or append):
-
-```bash
-grep -q '^AUDIT_ENABLED=' .env && sed -i.bak 's/^AUDIT_ENABLED=.*/AUDIT_ENABLED=true/' .env && rm -f .env.bak || echo 'AUDIT_ENABLED=true' >> .env
-grep -q '^AUDIT_RETENTION_DAYS=' .env || echo 'AUDIT_RETENTION_DAYS=90' >> .env
-```
-
-`AUDIT_ENABLED` is the master switch — off (or absent) means `emitAuditEvent`
-is a no-op and `data/audit/` is never created. `AUDIT_RETENTION_DAYS`: day
-files strictly older than the horizon are hard-deleted (unlinked) at boot and
-once per UTC day; `0` = keep forever; unset = 90.
-
-### 5. Build and test
-
-Run `build` before the tests — it's what catches a missed copy or a drifted
-import path across the whole composed tree:
-
-```bash
-pnpm run build
-pnpm exec vitest run src/audit src/cli/dispatch.audit.test.ts src/audit-wiring.test.ts
-pnpm test
-```
-
-### 6. Restart the service
-
-```bash
-source setup/lib/install-slug.sh
-launchctl kickstart -k gui/$(id -u)/$(launchd_label)   # macOS
-# systemctl --user restart $(systemd_unit)             # Linux
-```
-
-### 7. Verify (runtime smoke)
-
-```bash
-ncl groups list                     # any command — this one is now an audit event
-cat data/audit/$(date -u +%F).ndjson | tail -1
-ncl audit list --limit 5
-```
-
-The last line of the day-file is the `groups.list` event you just caused.
-
-## Reading it back
-
-```
-ncl audit list [--actor <id>] [--action <name-or-prefix>] [--resource <id-or-type>]
-               [--outcome success|failure|denied|pending|approved|rejected]
-               [--since 7d|24h|30m|ISO] [--until …] [--correlation <approval-id>]
-               [--limit N] [--format ndjson]
-```
-
-Newest first, default limit 100. `--action groups.config` matches the whole
-dotted subtree. `--format ndjson` streams the stored lines verbatim — pipe to
-a file for SIEM import. On a disabled box the command errors with
-`audit log is disabled — set AUDIT_ENABLED=true` rather than returning an
-empty list that would read as "no actions happened".
-
-The resource is deliberately **not** on the group-scope allowlist: audit
-spans agent groups, so group-scoped agents are refused before the handler
-(fails closed). Host callers and `cli_scope: global` agents only.
-
-## Redaction, failure posture, exporters
-
-- Every event's `details` passes a recursive key-pattern redactor
-  (`/(token|secret|key|password|credential|auth|bearer)/i` → `[REDACTED]`,
-  ~2 KB per-value cap) at the single emit seam.
-- Fail-open + loud: a failed append is `log.error`'d and the audited action
-  proceeds. At boot, an enabled box refuses to start if `data/audit/` isn't
-  writable.
-- In-process exporters register via `registerAuditHook` (from
-  `src/audit/index.js`) — post-write hooks that fire only after the local
-  append succeeds, so an external system can never be ahead of the source of
-  truth. Ship one as its own `/add-*` skill; declare `/add-audit` as its
-  dependency.
-
-## Troubleshooting
-
-- **Host won't start, banner names the audit directory** — `AUDIT_ENABLED=true`
-  but `data/audit/` isn't writable. Fix permissions or disable audit.
-- **`audit log is disabled — set AUDIT_ENABLED=true`** — the read-back guard;
-  enable in `.env` and restart.
-- **An agent gets "CLI access is scoped to this agent group" for `ncl audit`**
-  — by design; grant the group `cli_scope: global` only if it should read
-  cross-group history.
-- **`pnpm test` on an enabled box adds a few events to today's day-file** —
-  expected: the base dispatch tests drive real dispatches. Harmless noise;
-  the audit test suites themselves write only to temp dirs or capture buffers.
-
-## Removal
-
-See [REMOVE.md](REMOVE.md) — reverses every change; existing day-files are
-left in place (they're the operator's records).

.claude/skills/add-audit/add/src/audit-wiring.test.ts

@@ -1,143 +0,0 @@
-/**
- * Wiring tests for the /add-audit skill's two core edits — they go red if
- * either edit is deleted or drifts:
- *
- *  1. src/cli/dispatch.ts — the exported dispatch must be the composed
- *     `withAudit(dispatchInner)` (AST check: only the definition-site
- *     composition covers both transports AND the in-module approved replay).
- *  2. src/cli/resources/index.ts — the audit resource must register through
- *     the real barrel (behavior check), stay OFF the group-scope allowlist,
- *     and leave guard conformance clean.
- *
- * Plus the emit invariant the module's discipline rests on: emitAuditEvent
- * appears only in src/audit/ and *.audit.ts adapter files.
- */
-import fs from 'fs';
-import path from 'path';
-import ts from 'typescript';
-import { describe, expect, it } from 'vitest';
-
-// Same production barrels the guard conformance test loads (mirrors
-// src/guard/conformance.test.ts).
-import './cli/commands/index.js';
-import './modules/index.js';
-import './cli/delivery-action.js';
-import './cli/dispatch.js';
-
-import { commandGuard, GROUP_SCOPE_RESOURCES, lookup } from './cli/registry.js';
-import { getApprovalHandler } from './modules/approvals/primitive.js';
-import { listGuardedActions } from './guard/index.js';
-
-describe('audit resource registration (barrel wiring)', () => {
-  it('registers audit-list through the real resource barrel', () => {
-    const cmd = lookup('audit-list');
-    expect(cmd).toBeDefined();
-    expect(cmd?.action).toBe('audit.list');
-    expect(cmd?.access).toBe('open');
-  });
-
-  it('derives a guard-catalog entry for the audit command', () => {
-    const guard = commandGuard('audit-list');
-    expect(guard.action).toBe('audit.list');
-  });
-
-  it('is NOT on the group-scope allowlist — group-scoped agents fail closed', () => {
-    expect(GROUP_SCOPE_RESOURCES.has('audit')).toBe(false);
-  });
-
-  it('leaves guard conformance clean with the audit resource registered', () => {
-    // The invariant guard conformance checks: every holding action pairs with a
-    // registered approve continuation. audit.list is `open` (never holds), so
-    // registering the resource can't introduce a gap — this pins that.
-    const dangling = listGuardedActions()
-      .filter((spec) => spec.grantActionName)
-      .filter((spec) => !getApprovalHandler(spec.grantActionName as string));
-    expect(dangling.map((s) => s.action)).toEqual([]);
-  });
-});
-
-describe('dispatch composition (AST wiring)', () => {
-  const source = fs.readFileSync(path.resolve('src/cli/dispatch.ts'), 'utf8');
-  const sf = ts.createSourceFile('dispatch.ts', source, ts.ScriptTarget.Latest, true);
-
-  const hasExportModifier = (node: ts.HasModifiers): boolean =>
-    (ts.getModifiers(node) ?? []).some((m) => m.kind === ts.SyntaxKind.ExportKeyword);
-
-  let importsWithAudit = false;
-  let innerDeclaredUnexported = false;
-  let exportsWrappedDispatch = false;
-  let exportsUnwrappedDispatchFn = false;
-
-  sf.forEachChild((node) => {
-    if (
-      ts.isImportDeclaration(node) &&
-      ts.isStringLiteral(node.moduleSpecifier) &&
-      node.moduleSpecifier.text === './dispatch.audit.js'
-    ) {
-      const named = node.importClause?.namedBindings;
-      if (named && ts.isNamedImports(named) && named.elements.some((e) => e.name.text === 'withAudit')) {
-        importsWithAudit = true;
-      }
-    }
-    if (ts.isFunctionDeclaration(node) && node.name?.text === 'dispatchInner') {
-      innerDeclaredUnexported = !hasExportModifier(node);
-    }
-    if (ts.isFunctionDeclaration(node) && node.name?.text === 'dispatch' && hasExportModifier(node)) {
-      exportsUnwrappedDispatchFn = true;
-    }
-    if (ts.isVariableStatement(node) && hasExportModifier(node)) {
-      for (const decl of node.declarationList.declarations) {
-        if (
-          ts.isIdentifier(decl.name) &&
-          decl.name.text === 'dispatch' &&
-          decl.initializer &&
-          ts.isCallExpression(decl.initializer) &&
-          ts.isIdentifier(decl.initializer.expression) &&
-          decl.initializer.expression.text === 'withAudit' &&
-          decl.initializer.arguments.length === 1 &&
-          ts.isIdentifier(decl.initializer.arguments[0]) &&
-          decl.initializer.arguments[0].text === 'dispatchInner'
-        ) {
-          exportsWrappedDispatch = true;
-        }
-      }
-    }
-  });
-
-  it('imports withAudit from the audit adapter', () => {
-    expect(importsWithAudit).toBe(true);
-  });
-
-  it('keeps the inner dispatcher unexported (the guarded path is the only path)', () => {
-    expect(innerDeclaredUnexported).toBe(true);
-  });
-
-  it('exports dispatch as withAudit(dispatchInner)', () => {
-    expect(exportsWrappedDispatch).toBe(true);
-    expect(exportsUnwrappedDispatchFn).toBe(false);
-  });
-});
-
-describe('emit invariant', () => {
-  it('emitAuditEvent appears only in src/audit/ and *.audit.ts files', () => {
-    const srcRoot = path.resolve('src');
-    const offenders: string[] = [];
-    const walk = (dir: string): void => {
-      for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
-        const full = path.join(dir, entry.name);
-        if (entry.isDirectory()) {
-          walk(full);
-          continue;
-        }
-        if (!entry.name.endsWith('.ts')) continue;
-        const rel = path.relative(srcRoot, full).split(path.sep).join('/');
-        if (rel === 'audit-wiring.test.ts') continue; // this file names the symbol
-        if (rel.startsWith('audit/')) continue;
-        if (/\.audit(\.test)?\.ts$/.test(rel)) continue;
-        if (fs.readFileSync(full, 'utf8').includes('emitAuditEvent')) offenders.push(rel);
-      }
-    };
-    walk(srcRoot);
-    expect(offenders).toEqual([]);
-  });
-});

.claude/skills/add-audit/add/src/audit/config.ts

@@ -1,30 +0,0 @@
-/**
- * Audit env config (installed by /add-audit) — the two audit vars, read the
- * same way src/config.ts reads every host setting (readEnvFile from .env,
- * with process.env taking precedence). Kept audit-owned so installing the
- * skill never edits core config.ts: the feature's whole footprint in core is
- * the dispatch composition in dispatch.ts and the resource-barrel import.
- */
-import { readEnvFile } from '../env.js';
-
-const envConfig = readEnvFile(['AUDIT_ENABLED', 'AUDIT_RETENTION_DAYS']);
-
-/**
- * Master switch. Off by default — nothing is persisted (and data/audit/ is
- * never created) until an operator sets AUDIT_ENABLED=true.
- */
-export const AUDIT_ENABLED = (process.env.AUDIT_ENABLED || envConfig.AUDIT_ENABLED) === 'true';
-
-/**
- * Day-file retention horizon in days; consulted only when audit is enabled.
- * Unset or unparseable → 90. An explicit 0 (or negative) = keep forever.
- */
-function parseRetentionDays(raw: string | undefined): number {
-  if (raw === undefined || raw.trim() === '') return 90;
-  const n = Number.parseInt(raw, 10);
-  return Number.isNaN(n) ? 90 : n;
-}
-
-export const AUDIT_RETENTION_DAYS = parseRetentionDays(
-  process.env.AUDIT_RETENTION_DAYS || envConfig.AUDIT_RETENTION_DAYS,
-);

.claude/skills/add-audit/add/src/audit/emit.ts

@@ -1,43 +0,0 @@
-/**
- * The single emit seam. Adapters import emitAuditEvent from here directly
- * (it is deliberately not re-exported by the barrel): only src/audit/ and
- * `*.audit.ts` adapter files may call it — grep holds the invariant.
- *
- * The opt-in check lives here, so the whole feature switches at one point.
- * Fail-open + loud: a failed append (or a throwing input thunk) is
- * log.error'd and the audited action proceeds.
- */
-import { randomUUID } from 'crypto';
-
-import { log } from '../log.js';
-import { AUDIT_ENABLED } from './config.js';
-import { notifyAuditHooks } from './hooks.js';
-import { redactDetails } from './redact.js';
-import { appendAuditLine } from './store.js';
-import type { AuditEvent, AuditEventInput } from './types.js';
-
-export function emitAuditEvent(input: AuditEventInput | (() => AuditEventInput)): void {
-  if (!AUDIT_ENABLED) return; // The one opt-in check — the whole feature switches here.
-  try {
-    if (typeof input === 'function') input = input();
-    const event: AuditEvent = {
-      event_id: randomUUID(),
-      time: new Date().toISOString(),
-      schema_version: 1,
-      actor: { ...input.actor, email: null, user_id: null, group_ids: null },
-      origin: input.origin,
-      action: input.action,
-      resources: input.resources,
-      outcome: input.outcome,
-      correlation_id: input.correlationId ?? null,
-      details: redactDetails(input.details ?? {}),
-    };
-    const line = JSON.stringify(event);
-    appendAuditLine(line);
-    notifyAuditHooks(event, line);
-    // eslint-disable-next-line no-catch-all/no-catch-all -- fail-open is the posture: an audit failure must never take down the audited action
-  } catch (err) {
-    const action = typeof input === 'function' ? undefined : input.action;
-    log.error('Audit append failed — action proceeding (fail-open)', { action, err });
-  }
-}

.claude/skills/add-audit/add/src/audit/hooks.test.ts

@@ -1,203 +0,0 @@
-/**
- * Post-write hook contract: hooks observe the LOG (fire only after a
- * successful append, exported ⊆ written), failures are isolated everywhere,
- * and the lifecycle (init/maintain/shutdown) behaves.
- */
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-
-const state = vi.hoisted(() => ({ enabled: true, appendThrows: false, appended: [] as string[] }));
-
-vi.mock('../config.js', async (importOriginal) => {
-  const actual = await importOriginal<typeof import('../config.js')>();
-  return {
-    ...actual,
-    DATA_DIR: '/tmp/nanoclaw-test-hooks-unused',
-  };
-});
-
-vi.mock('./config.js', () => ({
-  get AUDIT_ENABLED() {
-    return state.enabled;
-  },
-  AUDIT_RETENTION_DAYS: 90,
-}));
-
-vi.mock('./store.js', async (importOriginal) => {
-  const actual = await importOriginal<typeof import('./store.js')>();
-  return {
-    ...actual,
-    appendAuditLine: (line: string) => {
-      if (state.appendThrows) throw new Error('disk full');
-      state.appended.push(line);
-    },
-  };
-});
-
-vi.mock('../log.js', () => ({
-  log: { debug: vi.fn(), info: vi.fn(), warn: vi.fn(), error: vi.fn(), fatal: vi.fn() },
-}));
-
-let hooks: typeof import('./hooks.js');
-let emit: typeof import('./emit.js');
-let log: (typeof import('../log.js'))['log'];
-
-beforeEach(async () => {
-  state.enabled = true;
-  state.appendThrows = false;
-  state.appended.length = 0;
-  vi.resetModules(); // fresh hook registry per test
-  hooks = await import('./hooks.js');
-  emit = await import('./emit.js');
-  log = (await import('../log.js')).log;
-  vi.clearAllMocks();
-});
-
-afterEach(() => {
-  vi.clearAllMocks();
-});
-
-const EVENT_INPUT = {
-  actor: { type: 'human' as const, id: 'host:test' },
-  origin: { transport: 'socket' as const },
-  action: 'groups.list',
-  resources: [{ type: 'agent_group' }],
-  outcome: 'success' as const,
-  details: { limit: 5 },
-};
-
-describe('post-write notification', () => {
-  it('calls a registered hook with the parsed event and the exact stored line', () => {
-    const seen: Array<{ event: import('./types.js').AuditEvent; line: string }> = [];
-    hooks.registerAuditHook({ name: 'demo', onEvent: (event, line) => seen.push({ event, line }) });
-
-    emit.emitAuditEvent(EVENT_INPUT);
-
-    expect(state.appended).toHaveLength(1);
-    expect(seen).toHaveLength(1);
-    expect(seen[0].line).toBe(state.appended[0]);
-    expect(JSON.parse(seen[0].line)).toEqual(seen[0].event);
-    expect(seen[0].event.action).toBe('groups.list');
-  });
-
-  it('does NOT call hooks when the local append fails — exported ⊆ written', () => {
-    const onEvent = vi.fn();
-    hooks.registerAuditHook({ name: 'demo', onEvent });
-    state.appendThrows = true;
-
-    expect(() => emit.emitAuditEvent(EVENT_INPUT)).not.toThrow(); // action still proceeds
-    expect(onEvent).not.toHaveBeenCalled();
-    expect(log.error).toHaveBeenCalledWith(expect.stringContaining('Audit append failed'), expect.anything());
-  });
-
-  it('does NOT call hooks when audit is disabled', () => {
-    const onEvent = vi.fn();
-    hooks.registerAuditHook({ name: 'demo', onEvent });
-    state.enabled = false;
-
-    emit.emitAuditEvent(EVENT_INPUT);
-
-    expect(state.appended).toHaveLength(0);
-    expect(onEvent).not.toHaveBeenCalled();
-  });
-
-  it('isolates a throwing hook: the write survives, later hooks still run, the action proceeds', () => {
-    const second = vi.fn();
-    hooks.registerAuditHook({
-      name: 'broken',
-      onEvent: () => {
-        throw new Error('exporter exploded');
-      },
-    });
-    hooks.registerAuditHook({ name: 'healthy', onEvent: second });
-
-    expect(() => emit.emitAuditEvent(EVENT_INPUT)).not.toThrow();
-
-    expect(state.appended).toHaveLength(1); // the log has the event regardless
-    expect(second).toHaveBeenCalledTimes(1);
-    expect(log.error).toHaveBeenCalledWith(
-      expect.stringContaining('Audit hook threw'),
-      expect.objectContaining({ hook: 'broken', action: 'groups.list' }),
-    );
-  });
-});
-
-describe('lifecycle', () => {
-  it('initAuditHooks surfaces a failing init as a fatal error naming the hook', () => {
-    hooks.registerAuditHook({ name: 'ok', onEvent: () => {}, init: vi.fn() });
-    hooks.registerAuditHook({
-      name: 'bad-boot',
-      onEvent: () => {},
-      init: () => {
-        throw new Error('no route to collector');
-      },
-    });
-
-    expect(() => hooks.initAuditHooks()).toThrow(/audit hook "bad-boot" failed to initialize.*no route/);
-  });
-
-  it('maintainAuditHooks calls every maintain and isolates throws', () => {
-    const m1 = vi.fn(() => {
-      throw new Error('flush failed');
-    });
-    const m2 = vi.fn();
-    hooks.registerAuditHook({ name: 'a', onEvent: () => {}, maintain: m1 });
-    hooks.registerAuditHook({ name: 'b', onEvent: () => {}, maintain: m2 });
-    hooks.registerAuditHook({ name: 'c', onEvent: () => {} }); // no maintain — fine
-
-    expect(() => hooks.maintainAuditHooks()).not.toThrow();
-    expect(m1).toHaveBeenCalledTimes(1);
-    expect(m2).toHaveBeenCalledTimes(1);
-    expect(log.error).toHaveBeenCalledWith(
-      expect.stringContaining('maintenance failed'),
-      expect.objectContaining({ hook: 'a' }),
-    );
-  });
-
-  it('shutdownAuditHooks awaits async shutdowns and isolates throws', async () => {
-    const order: string[] = [];
-    hooks.registerAuditHook({
-      name: 'a',
-      onEvent: () => {},
-      shutdown: async () => {
-        await Promise.resolve();
-        order.push('a');
-      },
-    });
-    hooks.registerAuditHook({
-      name: 'b',
-      onEvent: () => {},
-      shutdown: () => {
-        throw new Error('handle already closed');
-      },
-    });
-    hooks.registerAuditHook({
-      name: 'c',
-      onEvent: () => {},
-      shutdown: () => {
-        order.push('c');
-      },
-    });
-
-    await hooks.shutdownAuditHooks();
-
-    expect(order).toEqual(['a', 'c']);
-    expect(log.error).toHaveBeenCalledWith(
-      expect.stringContaining('shutdown failed'),
-      expect.objectContaining({ hook: 'b' }),
-    );
-  });
-
-  it('maintainAudit skips hook maintenance when audit is disabled', async () => {
-    const init = await import('./init.js');
-    const maintain = vi.fn();
-    hooks.registerAuditHook({ name: 'a', onEvent: () => {}, maintain });
-
-    state.enabled = false;
-    init.maintainAudit();
-    expect(maintain).not.toHaveBeenCalled();
-
-    state.enabled = true;
-    init.maintainAudit();
-    expect(maintain).toHaveBeenCalledTimes(1);
-  });
-});

.claude/skills/add-audit/add/src/audit/hooks.ts

@@ -1,92 +0,0 @@
-/**
- * Post-write audit hooks — the in-process extension seam.
- *
- * A hook observes the audit LOG, not the event stream: `onEvent` fires only
- * after an event has been durably appended to the local day-file, so anything
- * a hook exports is guaranteed to exist in the source of truth
- * (exported ⊆ written). If the local append fails, hooks are not called —
- * and a hook that misses events (crash, restart) catches up by reading the
- * day-files, which is the at-least-once story.
- *
- * Registration follows the tree's observer idiom (registerApprovalResolvedHandler,
- * registerResponseHandler, …): an in-tree or skill-installed module calls
- * `registerAuditHook(...)` at import time — no core edits, and credentials or
- * transport for an external system live in that module, never here.
- */
-import { log } from '../log.js';
-import type { AuditEvent } from './types.js';
-
-export interface AuditHook {
-  /** Short identifier used in logs and lifecycle errors. */
-  name: string;
-  /**
-   * Called after a successful local append. `line` is the exact stored bytes
-   * (one NDJSON line, no trailing newline); `event` is the parsed record.
-   * MUST be fast and non-blocking — this runs on the audited action's call
-   * path. A real exporter buffers here and does its IO from `maintain`/its own
-   * timers. Throwing is tolerated: isolated and logged, never propagated.
-   */
-  onEvent(event: AuditEvent, line: string): void;
-  /** Boot hook, called only when audit is enabled. Throw = host refuses to start. */
-  init?(): void;
-  /** Periodic maintenance — called from the audit maintenance timer (enabled boxes only). */
-  maintain?(): void;
-  /** Graceful-shutdown hook (flush buffers, close handles). */
-  shutdown?(): void | Promise<void>;
-}
-
-const hooks: AuditHook[] = [];
-
-export function registerAuditHook(hook: AuditHook): void {
-  hooks.push(hook);
-}
-
-/** Fan out one written event to every hook, isolating failures per hook. */
-export function notifyAuditHooks(event: AuditEvent, line: string): void {
-  for (const hook of hooks) {
-    try {
-      hook.onEvent(event, line);
-      // eslint-disable-next-line no-catch-all/no-catch-all -- isolation is the contract: one bad hook must not affect the log, other hooks, or the audited action
-    } catch (err) {
-      log.error('Audit hook threw — event is safely in the log', { hook: hook.name, action: event.action, err });
-    }
-  }
-}
-
-/** Boot lifecycle. A hook that can't start is a silent-export-gap risk — fatal. */
-export function initAuditHooks(): void {
-  for (const hook of hooks) {
-    try {
-      hook.init?.();
-    } catch (err) {
-      throw new Error(
-        `audit hook "${hook.name}" failed to initialize: ${err instanceof Error ? err.message : String(err)}`,
-        { cause: err },
-      );
-    }
-  }
-}
-
-/** Periodic lifecycle — maintenance, isolated per hook. */
-export function maintainAuditHooks(): void {
-  for (const hook of hooks) {
-    try {
-      hook.maintain?.();
-      // eslint-disable-next-line no-catch-all/no-catch-all -- one hook's maintenance failure must not stop the others (or the timer)
-    } catch (err) {
-      log.error('Audit hook maintenance failed', { hook: hook.name, err });
-    }
-  }
-}
-
-/** Shutdown lifecycle — awaited by the host's graceful shutdown. */
-export async function shutdownAuditHooks(): Promise<void> {
-  for (const hook of hooks) {
-    try {
-      await hook.shutdown?.();
-      // eslint-disable-next-line no-catch-all/no-catch-all -- shutdown must drain every hook even when one throws
-    } catch (err) {
-      log.error('Audit hook shutdown failed', { hook: hook.name, err });
-    }
-  }
-}

.claude/skills/add-audit/add/src/audit/index.ts

@@ -1,18 +0,0 @@
-/**
- * Opt-in local audit log — installed by /add-audit.
- *
- * This directory is a domain-free leaf: the event schema, the emit seam, the
- * store, the reader, post-write hooks, and shared vocabulary. What gets
- * audited — and how each domain describes itself — lives in the domain-owned
- * `*.audit.ts` adapter files next to the code they observe. Business logic
- * contains zero audit calls.
- *
- * emitAuditEvent is deliberately NOT re-exported here: adapters import it
- * from './emit.js' directly, and only src/audit/ + `*.audit.ts` may call it.
- */
-export * from './types.js';
-export { redactDetails } from './redact.js';
-export { AUDIT_DIR } from './store.js';
-export { AUDIT_ENABLED, AUDIT_RETENTION_DAYS } from './config.js';
-export { initAuditLog, maintainAudit } from './init.js';
-export { type AuditHook, registerAuditHook } from './hooks.js';

.claude/skills/add-audit/add/src/audit/init.ts

@@ -1,54 +0,0 @@
-/**
- * Boot-time audit wiring, self-contained (installed by /add-audit).
- *
- * initAuditLog() runs at module load of the CLI audit adapter
- * (cli/dispatch.audit.ts) — i.e. during the host's barrel phase, before the
- * CLI server or any delivery poll accepts work — because dispatch.ts, which
- * both transports import, composes withAudit at module scope. When enabled:
- * assert data/audit/ is writable (refusing to start beats running with a
- * silent audit gap), run the boot prune, start the registered post-write
- * hooks, and arm the maintenance timer.
- *
- * The timer owns the daily cadence in-module (checked hourly; the prune
- * itself fires at most once per UTC day) so installing the skill touches
- * dispatch.ts and the resource barrel only — no host-sweep edit. It is
- * unref'd: it never keeps the process alive.
- */
-import { log } from '../log.js';
-import { onShutdown } from '../response-registry.js';
-import { AUDIT_ENABLED, AUDIT_RETENTION_DAYS } from './config.js';
-import { initAuditHooks, maintainAuditHooks, shutdownAuditHooks } from './hooks.js';
-import { assertAuditWritable, AUDIT_DIR, markPrunedToday, pruneAuditLog, pruneAuditLogIfDue } from './store.js';
-
-const MAINTENANCE_INTERVAL_MS = 60 * 60 * 1000;
-
-let initialized = false;
-
-export function initAuditLog(): void {
-  if (!AUDIT_ENABLED || initialized) return;
-  initialized = true;
-  try {
-    assertAuditWritable();
-  } catch (err) {
-    throw new Error(
-      `AUDIT_ENABLED=true but the audit directory is not writable: ${AUDIT_DIR} (${err instanceof Error ? err.message : String(err)})`,
-      { cause: err },
-    );
-  }
-  pruneAuditLog();
-  markPrunedToday();
-  initAuditHooks(); // throw → boot fails, same posture as the writability assert
-  onShutdown(() => shutdownAuditHooks());
-  setInterval(maintainAudit, MAINTENANCE_INTERVAL_MS).unref();
-  log.info('Audit log enabled', { dir: AUDIT_DIR, retentionDays: AUDIT_RETENTION_DAYS });
-}
-
-/**
- * One maintenance tick: retention prune (throttled to once per UTC day
- * internally) plus every hook's periodic maintenance. No-op when audit is
- * disabled. Exported so a future scheduler can drive it too.
- */
-export function maintainAudit(): void {
-  pruneAuditLogIfDue();
-  if (AUDIT_ENABLED) maintainAuditHooks();
-}

.claude/skills/add-audit/add/src/audit/reader.test.ts

@@ -1,153 +0,0 @@
-import fs from 'fs';
-import os from 'os';
-import path from 'path';
-
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-
-const state = vi.hoisted(() => ({ dataDir: '', enabled: true }));
-
-vi.mock('../config.js', () => ({
-  get DATA_DIR() {
-    return state.dataDir;
-  },
-}));
-
-vi.mock('./config.js', () => ({
-  get AUDIT_ENABLED() {
-    return state.enabled;
-  },
-  AUDIT_RETENTION_DAYS: 90,
-}));
-
-vi.mock('../log.js', () => ({
-  log: { debug: vi.fn(), info: vi.fn(), warn: vi.fn(), error: vi.fn(), fatal: vi.fn() },
-}));
-
-let reader: typeof import('./reader.js');
-let store: typeof import('./store.js');
-
-beforeEach(async () => {
-  state.dataDir = fs.mkdtempSync(path.join(os.tmpdir(), 'audit-reader-'));
-  state.enabled = true;
-  vi.resetModules();
-  store = await import('./store.js');
-  reader = await import('./reader.js');
-});
-
-afterEach(() => {
-  fs.rmSync(state.dataDir, { recursive: true, force: true });
-});
-
-function dayString(daysAgo: number): string {
-  return store.utcDay(new Date(Date.now() - daysAgo * 24 * 60 * 60 * 1000));
-}
-
-function isoAt(daysAgo: number, tag: number): string {
-  const base = new Date(Date.now() - daysAgo * 24 * 60 * 60 * 1000);
-  return `${base.toISOString().slice(0, 10)}T10:00:0${tag}.000Z`;
-}
-
-let seq = 0;
-function seedEvent(daysAgo: number, overrides: Record<string, unknown> = {}): Record<string, unknown> {
-  seq += 1;
-  const event = {
-    event_id: `e-${seq}`,
-    time: isoAt(daysAgo, seq % 10),
-    schema_version: 1,
-    actor: { type: 'human', id: 'host:moshe', email: null, user_id: null, group_ids: null },
-    origin: { transport: 'socket' },
-    action: 'groups.list',
-    resources: [{ type: 'agent_group', id: 'ag-1' }],
-    outcome: 'success',
-    correlation_id: null,
-    details: {},
-    ...overrides,
-  };
-  const dir = path.join(state.dataDir, 'audit');
-  fs.mkdirSync(dir, { recursive: true });
-  fs.appendFileSync(path.join(dir, `${dayString(daysAgo)}.ndjson`), JSON.stringify(event) + '\n');
-  return event;
-}
-
-describe('listAuditEvents', () => {
-  it('throws the disabled error rather than returning an empty list', () => {
-    state.enabled = false;
-    expect(() => reader.listAuditEvents({})).toThrow('audit log is disabled — set AUDIT_ENABLED=true');
-  });
-
-  it('returns flat rows newest-first across day-files, honoring --limit', () => {
-    seedEvent(2, { event_id: 'old' });
-    seedEvent(1, { event_id: 'mid-a' });
-    seedEvent(1, { event_id: 'mid-b' });
-    seedEvent(0, { event_id: 'new' });
-
-    const rows = reader.listAuditEvents({}) as Array<Record<string, unknown>>;
-    expect(rows.map((r) => r.event_id)).toEqual(['new', 'mid-b', 'mid-a', 'old']);
-    expect(rows[0]).toMatchObject({ actor: 'host:moshe', action: 'groups.list', outcome: 'success' });
-    expect(rows[0].resources).toBe('agent_group:ag-1');
-
-    const limited = reader.listAuditEvents({ limit: 2 }) as Array<Record<string, unknown>>;
-    expect(limited.map((r) => r.event_id)).toEqual(['new', 'mid-b']);
-  });
-
-  it('filters by actor, outcome, correlation, and resource (id or type)', () => {
-    seedEvent(0, { event_id: 'a', actor: { type: 'agent', id: 'ag-1' }, outcome: 'denied' });
-    seedEvent(0, { event_id: 'b', correlation_id: 'appr-9', resources: [{ type: 'approval', id: 'appr-9' }] });
-    seedEvent(0, { event_id: 'c', resources: [{ type: 'user', id: 'slack:U1' }] });
-
-    expect((reader.listAuditEvents({ actor: 'ag-1' }) as unknown[]).length).toBe(1);
-    expect((reader.listAuditEvents({ outcome: 'denied' }) as unknown[]).length).toBe(1);
-    expect((reader.listAuditEvents({ correlation: 'appr-9' }) as unknown[]).length).toBe(1);
-    expect((reader.listAuditEvents({ resource: 'slack:U1' }) as unknown[]).length).toBe(1);
-    expect((reader.listAuditEvents({ resource: 'approval' }) as unknown[]).length).toBe(1);
-  });
-
-  it('matches actions exactly or by dotted prefix', () => {
-    seedEvent(0, { event_id: 'cfg', action: 'groups.config.add-mcp-server' });
-    seedEvent(0, { event_id: 'list', action: 'groups.list' });
-    seedEvent(0, { event_id: 'other', action: 'sessions.list' });
-
-    expect((reader.listAuditEvents({ action: 'groups' }) as unknown[]).length).toBe(2);
-    expect((reader.listAuditEvents({ action: 'groups.config' }) as unknown[]).length).toBe(1);
-    expect((reader.listAuditEvents({ action: 'groups.list' }) as unknown[]).length).toBe(1);
-    // Prefix means dotted segments, not substrings.
-    expect((reader.listAuditEvents({ action: 'group' }) as unknown[]).length).toBe(0);
-  });
-
-  it('applies --since/--until with relative and ISO forms', () => {
-    seedEvent(5, { event_id: 'old' });
-    seedEvent(0, { event_id: 'recent' });
-
-    const relative = reader.listAuditEvents({ since: '2d' }) as Array<Record<string, unknown>>;
-    expect(relative.map((r) => r.event_id)).toEqual(['recent']);
-
-    const iso = reader.listAuditEvents({ until: dayString(2) }) as Array<Record<string, unknown>>;
-    expect(iso.map((r) => r.event_id)).toEqual(['old']);
-
-    expect(() => reader.listAuditEvents({ since: 'yesterdayish' })).toThrow('invalid --since');
-  });
-
-  it('--format ndjson returns the stored lines verbatim', () => {
-    const seeded = seedEvent(0, { event_id: 'x1' });
-    const out = reader.listAuditEvents({ format: 'ndjson' });
-    expect(typeof out).toBe('string');
-    expect(JSON.parse(out as string)).toEqual(seeded);
-    expect(() => reader.listAuditEvents({ format: 'csv' })).toThrow('invalid --format');
-  });
-
-  it('skips malformed stored lines and still returns the rest', () => {
-    seedEvent(0, { event_id: 'good' });
-    fs.appendFileSync(path.join(state.dataDir, 'audit', `${dayString(0)}.ndjson`), 'not-json\n');
-
-    const rows = reader.listAuditEvents({}) as Array<Record<string, unknown>>;
-    expect(rows.map((r) => r.event_id)).toEqual(['good']);
-  });
-
-  it('rejects an unknown --outcome value', () => {
-    expect(() => reader.listAuditEvents({ outcome: 'meh' })).toThrow('invalid --outcome');
-  });
-
-  it('returns empty when nothing has been recorded yet', () => {
-    expect(reader.listAuditEvents({})).toEqual([]);
-  });
-});

.claude/skills/add-audit/add/src/audit/reader.ts

@@ -1,160 +0,0 @@
-/**
- * Read-back for `ncl audit list` — a newest-first stream-scan over the
- * day-files. No index: fine at v1 volume, and adding one later doesn't change
- * the store. NDJSON export returns the stored lines verbatim.
- */
-import fs from 'fs';
-import path from 'path';
-
-import { log } from '../log.js';
-import { AUDIT_ENABLED } from './config.js';
-import { AUDIT_DIR, utcDay } from './store.js';
-import type { AuditEvent, AuditOutcome } from './types.js';
-
-const OUTCOMES: ReadonlySet<string> = new Set(['success', 'failure', 'denied', 'pending', 'approved', 'rejected']);
-const DAY_FILE_RE = /^(\d{4}-\d{2}-\d{2})\.ndjson$/;
-const DEFAULT_LIMIT = 100;
-
-export interface AuditQuery {
-  actor?: string;
-  /** Exact action or dotted prefix (`groups` matches `groups.config.update`). */
-  action?: string;
-  /** Matches any resources[] entry by id or by type. */
-  resource?: string;
-  outcome?: AuditOutcome;
-  sinceMs?: number;
-  untilMs?: number;
-  correlation?: string;
-  limit: number;
-}
-
-/** `7d` / `24h` / `30m` relative to now, or an ISO date/datetime (UTC). */
-export function parseTimeFlag(value: string, flag: string): number {
-  const rel = /^(\d+)([dhm])$/.exec(value);
-  if (rel) {
-    const n = Number(rel[1]);
-    const unitMs = rel[2] === 'd' ? 86_400_000 : rel[2] === 'h' ? 3_600_000 : 60_000;
-    return Date.now() - n * unitMs;
-  }
-  const abs = Date.parse(value);
-  if (!Number.isNaN(abs)) return abs;
-  throw new Error(`invalid ${flag} value "${value}" — use e.g. 7d, 24h, 30m, or an ISO date`);
-}
-
-/** Newest first across files and within each file, up to q.limit. */
-export function queryAuditEvents(q: AuditQuery): { events: AuditEvent[]; lines: string[] } {
-  const events: AuditEvent[] = [];
-  const lines: string[] = [];
-  let malformed = 0;
-
-  for (const { day, file } of dayFilesNewestFirst()) {
-    if (events.length >= q.limit) break;
-    // Whole-day skip: a file can't match a window its day lies outside.
-    if (q.sinceMs !== undefined && day < utcDay(new Date(q.sinceMs))) continue;
-    if (q.untilMs !== undefined && day > utcDay(new Date(q.untilMs))) continue;
-
-    let content: string;
-    try {
-      content = fs.readFileSync(file, 'utf8');
-      // eslint-disable-next-line no-catch-all/no-catch-all -- a torn/pruned day-file must not fail the whole query
-    } catch (err) {
-      log.warn('Audit reader failed to read day-file', { file, err });
-      continue;
-    }
-    const fileLines = content.split('\n').filter((l) => l.trim() !== '');
-    // Lines within a file are chronological — walk backwards for newest-first.
-    for (let i = fileLines.length - 1; i >= 0 && events.length < q.limit; i--) {
-      let event: AuditEvent;
-      try {
-        event = JSON.parse(fileLines[i]) as AuditEvent;
-        // eslint-disable-next-line no-catch-all/no-catch-all -- malformed stored lines are skipped (counted + warned below)
-      } catch {
-        malformed++;
-        continue;
-      }
-      if (!matches(event, q)) continue;
-      events.push(event);
-      lines.push(fileLines[i]);
-    }
-  }
-
-  if (malformed > 0) {
-    log.warn('Audit reader skipped malformed lines', { malformed });
-  }
-  return { events, lines };
-}
-
-function dayFilesNewestFirst(): Array<{ day: string; file: string }> {
-  let entries: string[];
-  try {
-    entries = fs.readdirSync(AUDIT_DIR);
-    // eslint-disable-next-line no-catch-all/no-catch-all -- no audit dir yet means no events, not an error
-  } catch {
-    return [];
-  }
-  return entries
-    .map((e) => DAY_FILE_RE.exec(e))
-    .filter((m): m is RegExpExecArray => m !== null)
-    .map((m) => ({ day: m[1], file: path.join(AUDIT_DIR, m[0]) }))
-    .sort((a, b) => (a.day < b.day ? 1 : -1));
-}
-
-function matches(event: AuditEvent, q: AuditQuery): boolean {
-  if (q.actor !== undefined && event.actor?.id !== q.actor) return false;
-  if (q.action !== undefined && event.action !== q.action && !event.action?.startsWith(q.action + '.')) return false;
-  if (q.outcome !== undefined && event.outcome !== q.outcome) return false;
-  if (q.correlation !== undefined && event.correlation_id !== q.correlation) return false;
-  if (q.resource !== undefined) {
-    const hit = (event.resources ?? []).some((r) => r.id === q.resource || r.type === q.resource);
-    if (!hit) return false;
-  }
-  const t = Date.parse(event.time ?? '');
-  if (q.sinceMs !== undefined && !(t >= q.sinceMs)) return false;
-  if (q.untilMs !== undefined && !(t <= q.untilMs)) return false;
-  return true;
-}
-
-/**
- * `ncl audit list` handler. Disabled → an explicit error: an empty list would
- * read as "no actions happened", which is a different truth than "not
- * recording". `--format ndjson` returns the stored lines verbatim (the human
- * formatter passes strings through); default returns flat rows for the table.
- */
-export function listAuditEvents(args: Record<string, unknown>): string | Array<Record<string, unknown>> {
-  if (!AUDIT_ENABLED) {
-    throw new Error('audit log is disabled — set AUDIT_ENABLED=true');
-  }
-
-  const format = args.format !== undefined ? String(args.format) : '';
-  if (format && format !== 'ndjson') {
-    throw new Error(`invalid --format "${format}" — only "ndjson" is supported`);
-  }
-  const outcome = args.outcome !== undefined ? String(args.outcome) : undefined;
-  if (outcome !== undefined && !OUTCOMES.has(outcome)) {
-    throw new Error(`invalid --outcome "${outcome}" — one of: ${[...OUTCOMES].join(', ')}`);
-  }
-
-  const q: AuditQuery = {
-    actor: args.actor !== undefined ? String(args.actor) : undefined,
-    action: args.action !== undefined ? String(args.action) : undefined,
-    resource: args.resource !== undefined ? String(args.resource) : undefined,
-    outcome: outcome as AuditOutcome | undefined,
-    correlation: args.correlation !== undefined ? String(args.correlation) : undefined,
-    sinceMs: args.since !== undefined ? parseTimeFlag(String(args.since), '--since') : undefined,
-    untilMs: args.until !== undefined ? parseTimeFlag(String(args.until), '--until') : undefined,
-    limit: args.limit !== undefined ? Math.max(1, Number(args.limit) || DEFAULT_LIMIT) : DEFAULT_LIMIT,
-  };
-
-  const { events, lines } = queryAuditEvents(q);
-  if (format === 'ndjson') return lines.join('\n');
-
-  return events.map((e) => ({
-    time: e.time,
-    actor: e.actor?.id ?? '',
-    action: e.action,
-    resources: (e.resources ?? []).map((r) => (r.id ? `${r.type}:${r.id}` : r.type)).join(' '),
-    outcome: e.outcome,
-    correlation: e.correlation_id ?? '',
-    event_id: e.event_id,
-  }));
-}

.claude/skills/add-audit/add/src/audit/redact.test.ts

@@ -1,69 +0,0 @@
-import { describe, expect, it } from 'vitest';
-
-import { redactDetails } from './redact.js';
-
-describe('redactDetails', () => {
-  it('masks sensitive keys at any depth, case-insensitively', () => {
-    const out = redactDetails({
-      name: 'notion',
-      env: { NOTION_TOKEN: 'secret-value', SAFE_VALUE: 'ok' },
-      nested: { Authorization: 'Bearer abc', list: [{ 'api-key': 'k' }, { plain: 'p' }] },
-      password: 'hunter2',
-    });
-    expect(out).toEqual({
-      name: 'notion',
-      env: { NOTION_TOKEN: '[REDACTED]', SAFE_VALUE: 'ok' },
-      nested: { Authorization: '[REDACTED]', list: [{ 'api-key': '[REDACTED]' }, { plain: 'p' }] },
-      password: '[REDACTED]',
-    });
-  });
-
-  it('matches the documented key pattern (token|secret|key|password|credential|auth|bearer)', () => {
-    const out = redactDetails({
-      access_token: 'x',
-      clientSecret: 'x',
-      ssh_key: 'x',
-      credentials: 'x',
-      oauth_flow: 'x',
-      bearerValue: 'x',
-      username: 'moshe',
-    });
-    expect(Object.entries(out).filter(([, v]) => v === '[REDACTED]')).toHaveLength(6);
-    expect(out.username).toBe('moshe');
-  });
-
-  it('never recurses into a masked key — the whole value is replaced', () => {
-    const out = redactDetails({ auth: { inner: 'visible?' } });
-    expect(out.auth).toBe('[REDACTED]');
-  });
-
-  it('truncates strings over 2 KB post-redaction', () => {
-    const long = 'a'.repeat(5000);
-    const out = redactDetails({ blob: long, short: 'b' });
-    expect(out.blob).toBe('a'.repeat(2048) + '…[truncated]');
-    expect(out.short).toBe('b');
-  });
-
-  it('passes non-string scalars through untouched', () => {
-    const out = redactDetails({ n: 42, b: true, z: null, u: undefined });
-    expect(out).toEqual({ n: 42, b: true, z: null, u: undefined });
-  });
-
-  it('caps depth (cycle guard) without throwing', () => {
-    const cyclic: Record<string, unknown> = { a: 1 };
-    cyclic.self = cyclic;
-    const out = redactDetails(cyclic);
-    let cursor: unknown = out;
-    for (let i = 0; i < 20 && typeof cursor === 'object' && cursor !== null; i++) {
-      cursor = (cursor as Record<string, unknown>).self;
-    }
-    expect(cursor).toBe('[MAX_DEPTH]');
-  });
-
-  it('does not mutate the input', () => {
-    const input = { token: 'x', nested: { list: ['a'.repeat(3000)] } };
-    const snapshot = JSON.parse(JSON.stringify(input));
-    redactDetails(input);
-    expect(input).toEqual(snapshot);
-  });
-});

.claude/skills/add-audit/add/src/audit/redact.ts

@@ -1,32 +0,0 @@
-/**
- * The one redactor, applied to every event's `details` at the emit seam —
- * guarding current and future surfaces by default. Key-pattern mask plus a
- * per-value size cap; message bodies are never passed in (emit sites record
- * shape only — the audit log is a governance record, not a chat archive).
- */
-
-const SENSITIVE_KEY = /(token|secret|key|password|credential|auth|bearer)/i;
-const MAX_VALUE_CHARS = 2048;
-const MAX_DEPTH = 8;
-
-export function redactDetails(details: Record<string, unknown>): Record<string, unknown> {
-  return redactObject(details, 0);
-}
-
-function redactObject(obj: Record<string, unknown>, depth: number): Record<string, unknown> {
-  const out: Record<string, unknown> = {};
-  for (const [k, v] of Object.entries(obj)) {
-    out[k] = SENSITIVE_KEY.test(k) ? '[REDACTED]' : redactValue(v, depth + 1);
-  }
-  return out;
-}
-
-function redactValue(value: unknown, depth: number): unknown {
-  if (typeof value === 'string') {
-    return value.length > MAX_VALUE_CHARS ? `${value.slice(0, MAX_VALUE_CHARS)}…[truncated]` : value;
-  }
-  if (value === null || typeof value !== 'object') return value;
-  if (depth > MAX_DEPTH) return '[MAX_DEPTH]';
-  if (Array.isArray(value)) return value.map((v) => redactValue(v, depth + 1));
-  return redactObject(value as Record<string, unknown>, depth);
-}

.claude/skills/add-audit/add/src/audit/store.test.ts

@@ -1,187 +0,0 @@
-import fs from 'fs';
-import os from 'os';
-import path from 'path';
-
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-
-// Core config (DATA_DIR) and the audit config (toggles) are mocked so
-// store/emit resolve a per-test temp DATA_DIR and audit switches. Getters
-// keep the values live across vi.resetModules().
-const state = vi.hoisted(() => ({ dataDir: '', enabled: true, retention: 90 }));
-
-vi.mock('../config.js', () => ({
-  get DATA_DIR() {
-    return state.dataDir;
-  },
-}));
-
-vi.mock('./config.js', () => ({
-  get AUDIT_ENABLED() {
-    return state.enabled;
-  },
-  get AUDIT_RETENTION_DAYS() {
-    return state.retention;
-  },
-}));
-
-vi.mock('../log.js', () => ({
-  log: { debug: vi.fn(), info: vi.fn(), warn: vi.fn(), error: vi.fn(), fatal: vi.fn() },
-}));
-
-let store: typeof import('./store.js');
-let emit: typeof import('./emit.js');
-let log: (typeof import('../log.js'))['log'];
-
-beforeEach(async () => {
-  state.dataDir = fs.mkdtempSync(path.join(os.tmpdir(), 'audit-store-'));
-  state.enabled = true;
-  state.retention = 90;
-  vi.resetModules();
-  store = await import('./store.js');
-  emit = await import('./emit.js');
-  log = (await import('../log.js')).log;
-  vi.clearAllMocks();
-});
-
-afterEach(() => {
-  fs.chmodSync(path.join(state.dataDir), 0o700);
-  const auditDir = path.join(state.dataDir, 'audit');
-  if (fs.existsSync(auditDir)) fs.chmodSync(auditDir, 0o700);
-  fs.rmSync(state.dataDir, { recursive: true, force: true });
-});
-
-function auditDir(): string {
-  return path.join(state.dataDir, 'audit');
-}
-
-function writeDayFile(day: string, lines = 1): void {
-  fs.mkdirSync(auditDir(), { recursive: true });
-  fs.writeFileSync(path.join(auditDir(), `${day}.ndjson`), '{"x":1}\n'.repeat(lines));
-}
-
-function dayString(daysAgo: number): string {
-  return store.utcDay(new Date(Date.now() - daysAgo * 24 * 60 * 60 * 1000));
-}
-
-const EVENT_INPUT = {
-  actor: { type: 'human' as const, id: 'host:test' },
-  origin: { transport: 'socket' as const },
-  action: 'groups.list',
-  resources: [{ type: 'agent_group' }],
-  outcome: 'success' as const,
-};
-
-describe('appendAuditLine', () => {
-  it("appends one line to today's UTC day-file, creating the directory lazily", () => {
-    expect(fs.existsSync(auditDir())).toBe(false);
-    store.appendAuditLine('{"a":1}');
-    store.appendAuditLine('{"b":2}');
-    const file = path.join(auditDir(), `${store.utcDay()}.ndjson`);
-    expect(fs.readFileSync(file, 'utf8')).toBe('{"a":1}\n{"b":2}\n');
-  });
-});
-
-describe('emitAuditEvent', () => {
-  it('writes a schema_version-1 record with envelope fields and null enrichment', () => {
-    emit.emitAuditEvent({ ...EVENT_INPUT, details: { limit: 100 } });
-    const file = path.join(auditDir(), `${store.utcDay()}.ndjson`);
-    const record = JSON.parse(fs.readFileSync(file, 'utf8').trim());
-    expect(record).toMatchObject({
-      schema_version: 1,
-      actor: { type: 'human', id: 'host:test', email: null, user_id: null, group_ids: null },
-      origin: { transport: 'socket' },
-      action: 'groups.list',
-      outcome: 'success',
-      correlation_id: null,
-      details: { limit: 100 },
-    });
-    expect(record.event_id).toMatch(/^[0-9a-f-]{36}$/);
-    expect(new Date(record.time).toISOString()).toBe(record.time);
-  });
-
-  it('redacts details at the emit seam', () => {
-    emit.emitAuditEvent({ ...EVENT_INPUT, details: { env: { API_TOKEN: 'x' } } });
-    const file = path.join(auditDir(), `${store.utcDay()}.ndjson`);
-    expect(fs.readFileSync(file, 'utf8')).toContain('"API_TOKEN":"[REDACTED]"');
-  });
-
-  it('is a no-op when audit is disabled — the directory is never created', () => {
-    state.enabled = false;
-    emit.emitAuditEvent(EVENT_INPUT);
-    expect(fs.existsSync(auditDir())).toBe(false);
-  });
-
-  it('fails open and loud when the append fails', () => {
-    fs.mkdirSync(auditDir(), { recursive: true });
-    fs.chmodSync(auditDir(), 0o500);
-    expect(() => emit.emitAuditEvent(EVENT_INPUT)).not.toThrow();
-    expect(log.error).toHaveBeenCalledWith(
-      expect.stringContaining('Audit append failed'),
-      expect.objectContaining({ action: 'groups.list' }),
-    );
-  });
-});
-
-describe('assertAuditWritable', () => {
-  it('creates the directory and probes it with a zero-byte append', () => {
-    store.assertAuditWritable();
-    expect(fs.existsSync(path.join(auditDir(), `${store.utcDay()}.ndjson`))).toBe(true);
-  });
-
-  it('throws when the directory is not writable', () => {
-    fs.mkdirSync(auditDir(), { recursive: true });
-    fs.chmodSync(auditDir(), 0o500);
-    expect(() => store.assertAuditWritable()).toThrow();
-  });
-});
-
-describe('pruneAuditLog', () => {
-  it('unlinks only day-files strictly older than the horizon', () => {
-    writeDayFile(dayString(100));
-    writeDayFile(dayString(91));
-    writeDayFile(dayString(90));
-    writeDayFile(dayString(1));
-    fs.writeFileSync(path.join(auditDir(), 'not-a-day-file.txt'), 'keep');
-    fs.writeFileSync(path.join(auditDir(), '2026-01-01.ndjson.bak'), 'keep');
-    store.pruneAuditLog(90);
-    const left = fs.readdirSync(auditDir()).sort();
-    expect(left).toEqual(
-      [`${dayString(90)}.ndjson`, `${dayString(1)}.ndjson`, '2026-01-01.ndjson.bak', 'not-a-day-file.txt'].sort(),
-    );
-  });
-
-  it('keeps forever when retention is 0', () => {
-    writeDayFile(dayString(400));
-    store.pruneAuditLog(0);
-    expect(fs.existsSync(path.join(auditDir(), `${dayString(400)}.ndjson`))).toBe(true);
-  });
-
-  it('is a no-op when the audit directory does not exist', () => {
-    expect(() => store.pruneAuditLog(90)).not.toThrow();
-  });
-});
-
-describe('pruneAuditLogIfDue', () => {
-  it('prunes at most once per UTC day', () => {
-    writeDayFile(dayString(100));
-    store.pruneAuditLogIfDue();
-    expect(fs.existsSync(path.join(auditDir(), `${dayString(100)}.ndjson`))).toBe(false);
-    writeDayFile(dayString(100));
-    store.pruneAuditLogIfDue();
-    expect(fs.existsSync(path.join(auditDir(), `${dayString(100)}.ndjson`))).toBe(true);
-  });
-
-  it('does nothing when audit is disabled', () => {
-    state.enabled = false;
-    writeDayFile(dayString(100));
-    store.pruneAuditLogIfDue();
-    expect(fs.existsSync(path.join(auditDir(), `${dayString(100)}.ndjson`))).toBe(true);
-  });
-
-  it('does nothing after markPrunedToday until the day rolls over', () => {
-    store.markPrunedToday();
-    writeDayFile(dayString(100));
-    store.pruneAuditLogIfDue();
-    expect(fs.existsSync(path.join(auditDir(), `${dayString(100)}.ndjson`))).toBe(true);
-  });
-});

.claude/skills/add-audit/add/src/audit/store.ts

@@ -1,81 +0,0 @@
-/**
- * Day-file store — daily NDJSON files under data/audit/, host process is the
- * single writer. Append-only is structural: nothing here can update a line,
- * and retention is unlinking whole files (a literal hard delete). Both
- * transports converge host-side, so single-writer holds by construction.
- *
- * This module throws on fs failure; the fail-open posture (log.error, action
- * proceeds) lives in emit.ts, and the boot-time strictness (refuse to start)
- * lives in init.ts.
- */
-import fs from 'fs';
-import path from 'path';
-
-import { DATA_DIR } from '../config.js';
-import { log } from '../log.js';
-import { AUDIT_ENABLED, AUDIT_RETENTION_DAYS } from './config.js';
-
-export const AUDIT_DIR = path.join(DATA_DIR, 'audit');
-const DAY_FILE_RE = /^(\d{4}-\d{2}-\d{2})\.ndjson$/;
-const DAY_MS = 24 * 60 * 60 * 1000;
-
-export function utcDay(d: Date = new Date()): string {
-  return d.toISOString().slice(0, 10);
-}
-
-export function dayFilePath(day: string): string {
-  return path.join(AUDIT_DIR, `${day}.ndjson`);
-}
-
-/** The single append point. Throws on fs failure — emitAuditEvent catches. */
-export function appendAuditLine(line: string): void {
-  fs.mkdirSync(AUDIT_DIR, { recursive: true });
-  fs.appendFileSync(dayFilePath(utcDay()), line + '\n');
-}
-
-/** Boot-time writability assert — a zero-byte append is a true write probe. */
-export function assertAuditWritable(): void {
-  fs.mkdirSync(AUDIT_DIR, { recursive: true });
-  fs.appendFileSync(dayFilePath(utcDay()), '');
-}
-
-/** Unlink day-files strictly older than (today UTC − retentionDays). 0 or negative = keep forever. */
-export function pruneAuditLog(retentionDays: number = AUDIT_RETENTION_DAYS): void {
-  if (retentionDays <= 0) return;
-  let entries: string[];
-  try {
-    entries = fs.readdirSync(AUDIT_DIR);
-    // eslint-disable-next-line no-catch-all/no-catch-all -- no audit dir yet means nothing to prune, not an error
-  } catch {
-    return;
-  }
-  const horizon = utcDay(new Date(Date.now() - retentionDays * DAY_MS));
-  let pruned = 0;
-  for (const entry of entries) {
-    const m = DAY_FILE_RE.exec(entry);
-    if (!m || m[1] >= horizon) continue;
-    try {
-      fs.unlinkSync(path.join(AUDIT_DIR, entry));
-      pruned++;
-      // eslint-disable-next-line no-catch-all/no-catch-all -- one stuck file must not stop the prune of the others
-    } catch (err) {
-      log.error('Audit prune failed to unlink day-file', { file: entry, err });
-    }
-  }
-  if (pruned > 0) log.info('Audit retention pruned day-files', { pruned, retentionDays });
-}
-
-let lastPruneDay: string | null = null;
-
-/** Retention prune, throttled to once per UTC day — safe to call every tick. */
-export function pruneAuditLogIfDue(): void {
-  if (!AUDIT_ENABLED || AUDIT_RETENTION_DAYS <= 0) return;
-  const today = utcDay();
-  if (lastPruneDay === today) return;
-  lastPruneDay = today;
-  pruneAuditLog();
-}
-
-export function markPrunedToday(): void {
-  lastPruneDay = utcDay();
-}

.claude/skills/add-audit/add/src/audit/types.ts

@@ -1,60 +0,0 @@
-/**
- * Canonical audit event — one flat, SIEM-shaped record per action.
- *
- * Fields are chosen so they project losslessly onto OCSF and Elastic ECS
- * (the two schemas SIEMs converge on); the store keeps the neutral shape and
- * a future forwarder pays the translation once, at the edge. `schema_version`
- * covers evolution — additive changes only within a version.
- */
-
-export type AuditActorType = 'human' | 'agent' | 'system';
-
-export interface AuditActor {
-  type: AuditActorType;
-  /** `host:<os-user>` | `<channel>:<handle>` | agent group id | `host` (system). */
-  id: string;
-}
-
-export interface AuditOrigin {
-  transport: 'socket' | 'container' | 'channel';
-  session_id?: string;
-  messaging_group_id?: string;
-  channel?: string;
-}
-
-export interface AuditResource {
-  type: string;
-  /** Omitted when only the attempted type is known (e.g. a denied list). */
-  id?: string;
-}
-
-export type AuditOutcome = 'success' | 'failure' | 'denied' | 'pending' | 'approved' | 'rejected';
-
-/** What emit sites provide. Envelope fields are stamped by emitAuditEvent. */
-export interface AuditEventInput {
-  actor: AuditActor;
-  origin: AuditOrigin;
-  /** Dotted namespaced verb, e.g. `groups.config.add-mcp-server`. */
-  action: string;
-  resources: AuditResource[];
-  outcome: AuditOutcome;
-  /** The approval id on gated chains; null/omitted otherwise. */
-  correlationId?: string | null;
-  details?: Record<string, unknown>;
-}
-
-export interface AuditEvent {
-  event_id: string;
-  time: string;
-  schema_version: 1;
-  actor: AuditActor & { email: null; user_id: null; group_ids: null };
-  origin: AuditOrigin;
-  action: string;
-  resources: AuditResource[];
-  outcome: AuditOutcome;
-  correlation_id: string | null;
-  details: Record<string, unknown>;
-}
-
-/** Actor for timer/sweep-driven outcomes (expiries, startup sweeps). */
-export const SYSTEM_ACTOR: AuditActor = { type: 'system', id: 'host' };

.claude/skills/add-audit/add/src/audit/vocab.ts

@@ -1,39 +0,0 @@
-/**
- * Domain-free event vocabulary — actor and origin constructors shared by the
- * domain-owned `*.audit.ts` adapters (the CLI adapter today; approval and
- * channel adapters attach here in later increments). Pure derivation; nothing
- * here writes the log.
- *
- * Leaf rule: this module (like the rest of src/audit/) may depend on node,
- * config/log, shared types, and the db read layer — never on src/cli/* or
- * src/modules/*. Domain-specific mapping (CLI resources, approval payloads)
- * lives in the adapter file of the domain that owns it.
- */
-import os from 'os';
-
-import { getMessagingGroup } from '../db/messaging-groups.js';
-import type { AuditOrigin } from './types.js';
-
-/**
- * Host callers stamp `host:<install user>` daemon-side: the ncl socket is
- * 0600 and owned by the install user, so the identity is accurate by
- * construction without peer credentials.
- */
-export function hostUser(): string {
-  try {
-    return os.userInfo().username;
-    // eslint-disable-next-line no-catch-all/no-catch-all -- os.userInfo throws on exotic hosts; a fallback actor id beats no audit event
-  } catch {
-    return process.env.USER || 'unknown';
-  }
-}
-
-export function containerOrigin(sessionId: string, messagingGroupId: string | null): AuditOrigin {
-  const origin: AuditOrigin = { transport: 'container', session_id: sessionId };
-  if (messagingGroupId) {
-    origin.messaging_group_id = messagingGroupId;
-    const channel = getMessagingGroup(messagingGroupId)?.channel_type;
-    if (channel) origin.channel = channel;
-  }
-  return origin;
-}

.claude/skills/add-audit/add/src/cli/dispatch.audit.test.ts

@@ -1,297 +0,0 @@
-/**
- * Audit middleware behavior of the exported dispatch — what gets recorded,
- * for whom, and how gated chains correlate. Drives the real wrapped dispatch
- * (real registry, real guard); audit is force-enabled and the store's append
- * is captured. DB reads and approval delivery are mocked.
- */
-import os from 'os';
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-
-import type { PendingApproval } from '../types.js';
-
-const appended = vi.hoisted(() => ({ lines: [] as string[] }));
-const pendingRows = vi.hoisted(() => ({ rows: [] as unknown[] }));
-
-vi.mock('../audit/config.js', () => ({
-  AUDIT_ENABLED: true,
-  AUDIT_RETENTION_DAYS: 90,
-}));
-
-// Neutralize the adapter's module-scope boot (writability assert, prune,
-// maintenance timer) — the middleware is the unit under test here.
-vi.mock('../audit/init.js', () => ({
-  initAuditLog: vi.fn(),
-  maintainAudit: vi.fn(),
-}));
-
-vi.mock('../audit/store.js', async (importOriginal) => {
-  const actual = await importOriginal<typeof import('../audit/store.js')>();
-  return {
-    ...actual,
-    appendAuditLine: (line: string) => {
-      appended.lines.push(line);
-    },
-  };
-});
-
-vi.mock('../log.js', () => ({
-  log: { debug: vi.fn(), info: vi.fn(), warn: vi.fn(), error: vi.fn(), fatal: vi.fn() },
-}));
-
-const mockGetContainerConfig = vi.fn();
-vi.mock('../db/container-configs.js', () => ({
-  getContainerConfig: (...args: unknown[]) => mockGetContainerConfig(...args),
-}));
-
-vi.mock('../db/agent-groups.js', () => ({
-  getAgentGroup: vi.fn(() => ({ id: 'g1', name: 'Group One' })),
-}));
-
-const mockGetPendingApproval = vi.fn();
-vi.mock('../db/sessions.js', () => ({
-  getSession: vi.fn(() => ({ id: 's1', agent_group_id: 'g1', messaging_group_id: 'mg1' })),
-  getPendingApproval: (...args: unknown[]) => mockGetPendingApproval(...args),
-  getPendingApprovalsByAction: () => pendingRows.rows,
-}));
-
-vi.mock('../db/messaging-groups.js', () => ({
-  getMessagingGroup: vi.fn(() => ({ channel_type: 'slack' })),
-}));
-
-const mockGetResource = vi.fn();
-vi.mock('./crud.js', () => ({
-  getResource: (...args: unknown[]) => mockGetResource(...args),
-}));
-
-vi.mock('../modules/approvals/index.js', () => ({
-  registerApprovalHandler: vi.fn(),
-  requestApproval: vi.fn(async () => undefined),
-}));
-
-import { register } from './registry.js';
-
-register({
-  name: 'groups-test',
-  description: 'echo command on the groups resource',
-  action: 'groups.test',
-  resource: 'groups',
-  access: 'open',
-  parseArgs: (raw) => raw,
-  handler: async (args) => ({ echo: args }),
-});
-
-register({
-  name: 'groups-get',
-  description: 'echo command for dash-joined id resolution',
-  action: 'groups.get',
-  resource: 'groups',
-  access: 'open',
-  parseArgs: (raw) => raw,
-  handler: async (args) => ({ echo: args }),
-});
-
-register({
-  name: 'wirings-list',
-  description: 'not on the group-scope allowlist',
-  action: 'wirings.list',
-  resource: 'wirings',
-  access: 'open',
-  parseArgs: (raw) => raw,
-  handler: async () => [],
-});
-
-register({
-  name: 'groups-fail',
-  description: 'handler that throws',
-  action: 'groups.fail',
-  resource: 'groups',
-  access: 'open',
-  parseArgs: (raw) => raw,
-  handler: async () => {
-    throw new Error('boom');
-  },
-});
-
-register({
-  name: 'groups-gated',
-  description: 'approval-gated command',
-  action: 'groups.gated',
-  resource: 'groups',
-  access: 'approval',
-  parseArgs: (raw) => raw,
-  handler: async () => 'ran',
-});
-
-import { dispatch } from './dispatch.js';
-import type { CallerContext } from './frame.js';
-
-const AGENT_CTX: CallerContext = { caller: 'agent', sessionId: 's1', agentGroupId: 'g1', messagingGroupId: 'mg1' };
-
-function grantRow(frameId: string, command: string): PendingApproval {
-  return {
-    approval_id: 'appr-123-abc',
-    session_id: 's1',
-    request_id: 'appr-123-abc',
-    action: 'cli_command',
-    payload: JSON.stringify({ frame: { id: frameId, command, args: {} }, callerContext: AGENT_CTX }),
-    created_at: new Date().toISOString(),
-    agent_group_id: 'g1',
-    channel_type: null,
-    platform_id: null,
-    platform_message_id: null,
-    expires_at: null,
-    status: 'pending',
-    title: 'CLI: groups-gated',
-    options_json: '[]',
-    approver_user_id: null,
-  };
-}
-
-function events(): Array<Record<string, any>> {
-  return appended.lines.map((l) => JSON.parse(l));
-}
-
-beforeEach(() => {
-  vi.clearAllMocks();
-  appended.lines.length = 0;
-  pendingRows.rows = [];
-  mockGetContainerConfig.mockReturnValue({ cli_scope: 'group' });
-  mockGetResource.mockImplementation((plural: string) => (plural === 'groups' ? { scopeField: 'id' } : undefined));
-});
-
-describe('withAudit(dispatch)', () => {
-  it('records a success event for a host caller with socket origin and host actor', async () => {
-    const resp = await dispatch({ id: '1', command: 'groups-test', args: { foo: 'bar' } }, { caller: 'host' });
-
-    expect(resp.ok).toBe(true);
-    const [event] = events();
-    expect(event).toMatchObject({
-      schema_version: 1,
-      actor: { type: 'human', id: `host:${os.userInfo().username}`, email: null },
-      origin: { transport: 'socket' },
-      action: 'groups.test',
-      outcome: 'success',
-      correlation_id: null,
-      details: { foo: 'bar' },
-    });
-  });
-
-  it('records effective args after group auto-fill, with container origin and channel', async () => {
-    await dispatch({ id: '1', command: 'groups-test', args: {} }, AGENT_CTX);
-
-    const [event] = events();
-    expect(event.actor).toMatchObject({ type: 'agent', id: 'g1' });
-    expect(event.origin).toEqual({
-      transport: 'container',
-      session_id: 's1',
-      messaging_group_id: 'mg1',
-      channel: 'slack',
-    });
-    expect(event.details).toMatchObject({ id: 'g1', agent_group_id: 'g1', group: 'g1' });
-    expect(event.resources).toContainEqual({ type: 'agent_group', id: 'g1' });
-  });
-
-  it('records a denied event for a scope denial, naming the attempted resource type', async () => {
-    const resp = await dispatch({ id: '1', command: 'wirings-list', args: {} }, AGENT_CTX);
-
-    expect(resp.ok).toBe(false);
-    const [event] = events();
-    expect(event).toMatchObject({
-      action: 'wirings.list',
-      outcome: 'denied',
-      resources: [{ type: 'wirings' }],
-      details: { error: 'forbidden' },
-    });
-    expect(event.details.reason).toContain('scoped');
-  });
-
-  it('records a failure event when the handler throws', async () => {
-    await dispatch({ id: '1', command: 'groups-fail', args: {} }, { caller: 'host' });
-
-    const [event] = events();
-    expect(event).toMatchObject({ action: 'groups.fail', outcome: 'failure', details: { error: 'handler-error' } });
-    expect(event.details.reason).toContain('boom');
-  });
-
-  it('records a hold as a pending event correlated to the approval row it created', async () => {
-    pendingRows.rows = [grantRow('1', 'groups-gated')];
-
-    const resp = await dispatch({ id: '1', command: 'groups-gated', args: {} }, AGENT_CTX);
-
-    expect(resp.ok).toBe(false);
-    if (!resp.ok) expect(resp.error.code).toBe('approval-pending');
-    const [event] = events();
-    expect(event).toMatchObject({
-      action: 'groups.gated',
-      outcome: 'pending',
-      correlation_id: 'appr-123-abc',
-    });
-    expect(event.resources).toContainEqual({ type: 'approval', id: 'appr-123-abc' });
-    expect(event.details.error).toBeUndefined();
-  });
-
-  it('records an uncorrelated pending event when no approval row was created (no approver)', async () => {
-    pendingRows.rows = [];
-
-    await dispatch({ id: '1', command: 'groups-gated', args: {} }, AGENT_CTX);
-
-    const [event] = events();
-    expect(event).toMatchObject({ outcome: 'pending', correlation_id: null });
-  });
-
-  it('records an approved replay as success with the grant approval id as correlation_id', async () => {
-    const grant = grantRow('9', 'groups-gated');
-    mockGetPendingApproval.mockReturnValue(grant);
-
-    const resp = await dispatch({ id: '9', command: 'groups-gated', args: {} }, AGENT_CTX, { grant });
-
-    expect(resp.ok).toBe(true);
-    const [event] = events();
-    expect(event).toMatchObject({
-      action: 'groups.gated',
-      outcome: 'success',
-      correlation_id: 'appr-123-abc',
-    });
-    expect(event.resources).toContainEqual({ type: 'approval', id: 'appr-123-abc' });
-  });
-
-  it('records unknown commands as cli.unknown-command with the raw name in details', async () => {
-    await dispatch({ id: '1', command: 'nope-nothing', args: {} }, { caller: 'host' });
-
-    const [event] = events();
-    expect(event).toMatchObject({
-      action: 'cli.unknown-command',
-      outcome: 'failure',
-      resources: [],
-      details: { command: 'nope-nothing', error: 'unknown-command' },
-    });
-  });
-
-  it('records the resolved command and id for dash-joined positional ids', async () => {
-    const uuid = '550e8400-e29b-41d4-a716-446655440000';
-    await dispatch({ id: '1', command: `groups-get-${uuid}`, args: {} }, { caller: 'host' });
-
-    const [event] = events();
-    expect(event).toMatchObject({ action: 'groups.get', outcome: 'success' });
-    expect(event.resources).toContainEqual({ type: 'agent_group', id: uuid });
-    expect(event.details.id).toBe(uuid);
-  });
-
-  it('normalizes hyphenated arg keys in details', async () => {
-    await dispatch({ id: '1', command: 'groups-test', args: { 'dry-run': 'true' } }, { caller: 'host' });
-
-    const [event] = events();
-    expect(event.details).toMatchObject({ dry_run: 'true' });
-  });
-
-  it('parses JSON string args so the redactor reaches their inner keys', async () => {
-    await dispatch(
-      { id: '1', command: 'groups-test', args: { env: '{"NOTION_TOKEN":"tok-123","SAFE":"ok"}', note: '{not json' } },
-      { caller: 'host' },
-    );
-
-    const [event] = events();
-    expect(event.details.env).toEqual({ NOTION_TOKEN: '[REDACTED]', SAFE: 'ok' });
-    expect(event.details.note).toBe('{not json');
-  });
-});

.claude/skills/add-audit/add/src/cli/dispatch.audit.ts

@@ -1,238 +0,0 @@
-/**
- * CLI audit adapter (installed by /add-audit) — owns how the dispatcher
- * describes itself to the audit log: the dispatch middleware plus the
- * CLI-specific actor/origin/resource mapping. Composed in dispatch.ts as
- * `export const dispatch = withAudit(dispatchInner)`; business logic there
- * contains zero audit calls.
- *
- * Loading this module also boots the audit log (writability assert, boot
- * prune, hook lifecycle, maintenance timer): dispatch.ts is imported by both
- * transports during the host's barrel phase, so initAuditLog() runs before
- * any command is accepted — and an enabled box with an unwritable
- * data/audit/ refuses to start.
- */
-import { emitAuditEvent } from '../audit/emit.js';
-import { initAuditLog } from '../audit/init.js';
-import { type AuditActor, type AuditOrigin, type AuditOutcome, type AuditResource } from '../audit/types.js';
-import { containerOrigin, hostUser } from '../audit/vocab.js';
-import { getContainerConfig } from '../db/container-configs.js';
-import { getPendingApprovalsByAction } from '../db/sessions.js';
-import type { PendingApproval } from '../types.js';
-import { getResource } from './crud.js';
-import type { CallerContext, RequestFrame, ResponseFrame } from './frame.js';
-import { type CommandDef, lookup } from './registry.js';
-
-initAuditLog();
-
-// ── CLI mapping ──
-
-/**
- * Host callers stamp `host:<install user>` daemon-side (the ncl socket is
- * 0600 and owned by the install user); container callers are their agent group.
- */
-export function actorForCaller(ctx: CallerContext): AuditActor {
-  return ctx.caller === 'host' ? { type: 'human', id: `host:${hostUser()}` } : { type: 'agent', id: ctx.agentGroupId };
-}
-
-export function originForCaller(ctx: CallerContext): AuditOrigin {
-  if (ctx.caller === 'host') return { transport: 'socket' };
-  return containerOrigin(ctx.sessionId, ctx.messagingGroupId || null);
-}
-
-/**
- * Frame-level args use `--hyphen-keys`; recorded details use the same
- * underscore form the parsed handlers see. Mirrors crud's normalizeArgs
- * (kept local so audit doesn't depend on a module tests commonly mock).
- */
-export function normalizeArgKeys(raw: Record<string, unknown>): Record<string, unknown> {
-  const out: Record<string, unknown> = {};
-  for (const [k, v] of Object.entries(raw)) {
-    out[k.replace(/-/g, '_')] = v;
-  }
-  return out;
-}
-
-/** CLI resource plural → audit resource type, where the singular isn't it. */
-const RESOURCE_TYPE_OVERRIDES: Record<string, string> = {
-  groups: 'agent_group',
-  'messaging-groups': 'messaging_group',
-  'dropped-messages': 'dropped_message',
-  'user-dms': 'user_dm',
-};
-
-/**
- * Derive touched/attempted resources from a command's effective args. Generic
- * by design: `id` → the command's own resource, group/user args → their
- * types, and a bare `{type}` entry when nothing else is known (a denied
- * `users list` still names what was attempted).
- */
-export function resourcesForCli(cmd: CommandDef, args: Record<string, unknown>): AuditResource[] {
-  if (!cmd.resource) return [];
-  const type = RESOURCE_TYPE_OVERRIDES[cmd.resource] ?? getResource(cmd.resource)?.name ?? cmd.resource;
-
-  const out: AuditResource[] = [];
-  const push = (t: string, id: unknown): void => {
-    if (typeof id !== 'string' || !id) return;
-    if (!out.some((r) => r.type === t && r.id === id)) out.push({ type: t, id });
-  };
-  push(type, args.id);
-  push('agent_group', args.agent_group_id ?? args.group);
-  push('user', args.user);
-  if (out.length === 0) out.push({ type });
-  return out;
-}
-
-// ── Dispatch mechanics, mirrored for the record ──
-// Dispatch resolves the command and auto-fills args on a local copy of the
-// frame that never leaves it, so the middleware mirrors the two documented
-// mechanics below. The copies are mechanical, and drift only ever degrades a
-// record's detail (a fallback action name, a missing auto-filled arg) — never
-// dispatch behavior, and never an outcome.
-
-/**
- * Mirror of dispatch's command resolution: exact lookup, then the longest
- * registered dash-prefix with the remainder recorded as --id.
- */
-function resolveForRecord(req: RequestFrame): { cmd?: CommandDef; args: Record<string, unknown> } {
-  const direct = lookup(req.command);
-  if (direct) return { cmd: direct, args: req.args };
-  let shortened = req.command;
-  let idx: number;
-  while ((idx = shortened.lastIndexOf('-')) > 0) {
-    shortened = shortened.slice(0, idx);
-    const fallback = lookup(shortened);
-    if (fallback) {
-      const tail = req.command.slice(shortened.length + 1);
-      return { cmd: fallback, args: { ...req.args, id: req.args.id ?? tail } };
-    }
-  }
-  return { args: req.args };
-}
-
-/**
- * Mirror of dispatch's group-scope arg auto-fill, so the record shows the
- * effective args the handler saw (e.g. which agent group a bare
- * `sessions list` actually listed).
- */
-function effectiveArgs(
-  cmd: CommandDef | undefined,
-  args: Record<string, unknown>,
-  ctx: CallerContext,
-): Record<string, unknown> {
-  if (ctx.caller !== 'agent') return args;
-  if ((getContainerConfig(ctx.agentGroupId)?.cli_scope ?? 'group') !== 'group') return args;
-  const fill: Record<string, unknown> = {
-    agent_group_id: args.agent_group_id ?? ctx.agentGroupId,
-    group: args.group ?? ctx.agentGroupId,
-  };
-  if (cmd?.resource === 'groups' || cmd?.resource === 'destinations') {
-    fill.id = args.id ?? ctx.agentGroupId;
-  }
-  return { ...args, ...fill };
-}
-
-/**
- * CLI args arrive as strings, so a JSON-object/array value (e.g.
- * `--env '{"NOTION_TOKEN":"…"}'`) would reach the redactor as one opaque
- * string under an innocent key and its inner secret keys would survive.
- * Recording the parsed form lets the redactor walk inside — the audit log's
- * "secrets never land" property depends on it for exactly this flow.
- */
-function parseJsonishValues(args: Record<string, unknown>): Record<string, unknown> {
-  const out: Record<string, unknown> = {};
-  for (const [k, v] of Object.entries(args)) {
-    if (typeof v === 'string' && (v.startsWith('{') || v.startsWith('['))) {
-      try {
-        out[k] = JSON.parse(v);
-        continue;
-        // eslint-disable-next-line no-catch-all/no-catch-all -- not JSON after all: record the string as-is
-      } catch {
-        /* fall through */
-      }
-    }
-    out[k] = v;
-  }
-  return out;
-}
-
-/**
- * The approval row a hold just created for this frame — it gives the pending
- * event the same correlation_id the approved replay will carry as its guard
- * grant. requestApproval keeps the minted id internal, so the row is
- * recovered by the frame id it stored in its payload; no row (e.g. no
- * configured approver) → the hold is still recorded, uncorrelated.
- */
-function holdApprovalIdFor(frameId: string): string | null {
-  const rows = getPendingApprovalsByAction('cli_command');
-  for (let i = rows.length - 1; i >= 0; i--) {
-    try {
-      const payload = JSON.parse(rows[i].payload) as { frame?: { id?: string } };
-      if (payload.frame?.id === frameId) return rows[i].approval_id;
-      // eslint-disable-next-line no-catch-all/no-catch-all -- a row with an unparseable payload is simply not this frame's hold
-    } catch {
-      continue;
-    }
-  }
-  return null;
-}
-
-// ── The dispatch middleware ──
-
-type DispatchInner = (
-  req: RequestFrame,
-  ctx: CallerContext,
-  opts?: { grant?: PendingApproval },
-) => Promise<ResponseFrame>;
-
-/**
- * Dispatch middleware — the exported `dispatch` is the wrapped function, so
- * the socket server, the container delivery-action, and the in-module
- * approved replay are all covered by the one composition.
- *
- * Outcome derives from the response frame: ok → success, forbidden → denied
- * (captures pre-handler scope denials), approval-pending → pending (the
- * record of a hold), anything else → failure. Correlation is the approval id:
- * an approved replay carries the approval row as its guard grant
- * (opts.grant), and a fresh hold is correlated by recovering the row it just
- * created — so `--correlation <approval-id>` returns the whole gated chain.
- */
-export function withAudit(inner: DispatchInner): DispatchInner {
-  return async (req, ctx, opts = {}) => {
-    const res = await inner(req, ctx, opts);
-    emitAuditEvent(() => {
-      const resolved = resolveForRecord(req);
-      const cmd = resolved.cmd;
-      const pending = !res.ok && res.error.code === 'approval-pending';
-      const outcome: AuditOutcome = res.ok
-        ? 'success'
-        : res.error.code === 'forbidden'
-          ? 'denied'
-          : pending
-            ? 'pending'
-            : 'failure';
-      // A denial records the attempt as asked (raw args): nothing ran, so the
-      // auto-fill never conceptually happened — and a cross-group attempt
-      // must show the foreign id the caller passed, not a filled-in own-group.
-      const args = normalizeArgKeys(outcome === 'denied' ? resolved.args : effectiveArgs(cmd, resolved.args, ctx));
-      const correlationId = opts.grant?.approval_id ?? (pending ? holdApprovalIdFor(req.id) : null);
-      const details: Record<string, unknown> = parseJsonishValues(args);
-      if (!res.ok && !pending) {
-        details.error = res.error.code;
-        details.reason = res.error.message;
-      }
-      if (!cmd) details.command = req.command;
-      const resources = cmd ? resourcesForCli(cmd, args) : [];
-      if (correlationId) resources.push({ type: 'approval', id: correlationId });
-      return {
-        actor: actorForCaller(ctx),
-        origin: originForCaller(ctx),
-        action: cmd ? (cmd.action ?? `cli.${cmd.name}`) : 'cli.unknown-command',
-        resources,
-        outcome,
-        correlationId,
-        details,
-      };
-    });
-    return res;
-  };
-}

.claude/skills/add-audit/add/src/cli/resources/audit.ts

@@ -1,56 +0,0 @@
-import { listAuditEvents } from '../../audit/reader.js';
-import { registerResource } from '../crud.js';
-
-/**
- * Read-only audit resource (installed by /add-audit). The "table" is the
- * NDJSON day-file store — no generic CRUD verbs are declared, so it is never
- * queried as SQL; `list` is a custom operation backed by the audit reader.
- *
- * Deliberately NOT on the group-scope allowlist (GROUP_SCOPE_RESOURCES):
- * audit spans agent groups, so group-scoped agents are refused before the
- * handler — the resource is host + `cli_scope: global` only, by omission
- * (fails closed).
- */
-registerResource({
-  name: 'audit_event',
-  plural: 'audit',
-  table: '(data/audit/*.ndjson)',
-  description: 'Local audit log — one event per ncl command. Newest first. Requires AUDIT_ENABLED=true.',
-  idColumn: 'event_id',
-  columns: [
-    { name: 'actor', type: 'string', description: 'Filter: exact actor id (host:<user>, <channel>:<handle>, agent group id)' },
-    { name: 'action', type: 'string', description: 'Filter: exact action or dotted prefix (e.g. groups.config)' },
-    { name: 'resource', type: 'string', description: 'Filter: matches any event resource by id or type' },
-    {
-      name: 'outcome',
-      type: 'string',
-      description: 'Filter: event outcome',
-      enum: ['success', 'failure', 'denied', 'pending', 'approved', 'rejected'],
-    },
-    { name: 'since', type: 'string', description: 'Window start: 7d / 24h / 30m relative, or ISO date' },
-    { name: 'until', type: 'string', description: 'Window end: same formats as --since' },
-    { name: 'correlation', type: 'string', description: 'Filter: approval id tying a gated chain together' },
-    { name: 'limit', type: 'number', description: 'Max events (default 100, newest first)' },
-    { name: 'format', type: 'string', description: 'Output format', enum: ['ndjson'] },
-  ],
-  operations: {},
-  customOperations: {
-    list: {
-      access: 'open',
-      description: 'Query audit events, newest first. --format ndjson streams the stored lines for SIEM export.',
-      examples: [
-        'ncl audit list --outcome denied --since 7d',
-        'ncl audit list --correlation appr-1751970000000-x1y2z3',
-        'ncl audit list --action groups.config --format ndjson',
-      ],
-      handler: async (args) => listAuditEvents(args),
-      formatHuman: (data) => {
-        // NDJSON export prints the stored lines verbatim; for the table view
-        // this throws so dispatch falls back to the row objects, which every
-        // client already renders.
-        if (typeof data === 'string') return data;
-        throw new Error('render rows client-side');
-      },
-    },
-  },
-});

.claude/skills/add-clidash/REMOVE.md

@@ -1,22 +0,0 @@
-# Remove /add-clidash
-
-clidash is fully self-contained, so removal is a single directory delete. It
-made no edits to NanoClaw `src/`, added no dependency, and wired into nothing.
-
-```bash
-# Stop the service first if you set one up:
-systemctl --user disable --now clidash 2>/dev/null || true
-rm -f ~/.config/systemd/user/clidash.service
-
-# Remove the tool:
-rm -rf tools/clidash
-```
-
-If you added the config to `.gitignore` in step 2 of the install, remove that
-line too:
-
-```
-tools/clidash/clidash.config.json
-```
-
-Nothing else needs reverting.

.claude/skills/add-clidash/SKILL.md

@@ -1,168 +0,0 @@
----
-name: add-clidash
-description: Add clidash — a zero-dependency, read-only web dashboard that derives its tabs and tables at runtime from any CLI that lists resources as JSON. Ships pre-wired for NanoClaw's ncl CLI (agent groups, sessions, channels, users, roles), plus message-activity charts, a log tail, and a read-only file viewer for group skills/CLAUDE.md/profiles.
----
-
-# /add-clidash — CLI-derived read-only dashboard
-
-clidash is a small, read-only web dashboard. You point it at any CLI that can
-list resources as JSON (NanoClaw's `ncl`, `docker`, `kubectl`, …) and it builds
-the dashboard at runtime: one tab per resource, a generic table over whatever
-columns the rows have. A new `ncl` resource becomes a new tab and a new column
-becomes a new table column with **zero code changes**.
-
-It ships pre-wired for NanoClaw's `ncl` CLI and adds three NanoClaw-aware
-panels driven entirely by config:
-
-- **Agents overview** — status cards joining groups + sessions + messaging
-  groups + wirings (green <15m / amber <2h / red older).
-- **Activity** — per-session inbound/outbound message totals and a daily series,
-  read directly from the session DBs (`ncl` has no messages resource).
-- **Logs** — last N lines of allowlisted host log files.
-- **Files** — a read-only viewer for group skills, `CLAUDE.md`, and profiles.
-
-## Why it's safe
-
-clidash is **read-only by construction**: the server can only `execFile` the
-argv templates in its config. `{resource}` is the sole substitution and is
-allowlist-validated against the discovered/static resource set before exec —
-never a shell, no free-form input reaches argv. There is no auth; **the network
-is the auth boundary** — it binds `127.0.0.1` by default. Only ever bind a
-private interface (e.g. a tailnet IP), never a public one.
-
-It's distinct from `/add-dashboard` (which pushes JSON snapshots to a separate
-`@nanoco/nanoclaw-dashboard` npm package): clidash has **zero dependencies**, no
-build step, no push pipeline, and no edits to NanoClaw source — it just reads
-`ncl` and the session DBs.
-
-## Steps
-
-### 1. Copy the tool into place
-
-clidash is fully self-contained — copy the whole directory in:
-
-`tools/` is not a standard NanoClaw directory and `cp -R` won't create it, so
-make it first:
-
-```bash
-mkdir -p tools
-cp -R .claude/skills/add-clidash/add/tools/clidash tools/clidash
-```
-
-That is the only file change this skill makes. Nothing in NanoClaw `src/` is
-touched, no dependency is added.
-
-### 2. Create the config
-
-The example config is pre-wired for NanoClaw with paths relative to the repo
-root, so it works as-is when you run clidash from `tools/clidash/`:
-
-```bash
-cd tools/clidash
-cp clidash.config.example.json clidash.config.json
-```
-
-`clidash.config.json` is your local config — add it to `.gitignore` if you
-don't want to commit install-specific paths:
-
-```bash
-echo 'tools/clidash/clidash.config.json' >> ../../.gitignore
-```
-
-The example assumes `ncl` is built at `bin/ncl`. If `bin/ncl` doesn't exist,
-build it first (`pnpm run build`) or point `clis.ncl.bin` at the right path.
-
-### 3. Test
-
-Tests use a stub CLI — no real `ncl` or `docker` needed:
-
-```bash
-npm test
-```
-
-All tests should pass (Node ≥ 22.5, `node:test`, zero dependencies).
-
-### 4. Run and verify
-
-```bash
-node server.js          # serves http://127.0.0.1:4690
-```
-
-In another shell, confirm it's live and that `ncl` discovery worked:
-
-```bash
-curl -s http://127.0.0.1:4690/api/clis | head -c 400      # CLIs + discovered resources
-curl -s http://127.0.0.1:4690/api/r/ncl/groups | head -c 400   # a real resource table
-```
-
-Then open `http://127.0.0.1:4690/` in a browser. You should see the Agents
-overview plus a tab per `ncl` resource.
-
-### 5. (Optional) Run as a service
-
-clidash binds `127.0.0.1` by default. To reach it from other devices, bind a
-private (e.g. tailnet) IP via the `BIND` env var or `bind` in config — never a
-public interface.
-
-```ini
-# ~/.config/systemd/user/clidash.service   (Linux)
-[Unit]
-Description=clidash read-only CLI dashboard
-
-[Service]
-WorkingDirectory=%h/nanoclaw/tools/clidash
-ExecStart=/usr/bin/node %h/nanoclaw/tools/clidash/server.js
-Environment=BIND=127.0.0.1
-Restart=on-failure
-
-[Install]
-WantedBy=default.target
-```
-
-```bash
-systemctl --user enable --now clidash
-```
-
-On macOS, wrap `node server.js` (with `WorkingDirectory` = `tools/clidash`) in a
-launchd plist the same way the main NanoClaw service is configured.
-
-## Configuration reference
-
-`clidash.config.json` keys (see `tools/clidash/README.md` and
-`clidash.config.example.json` for the full shape):
-
-| Key | Purpose |
-|-----|---------|
-| `port`, `bind`, `refreshSeconds` | server bind + UI auto-refresh cadence |
-| `clis.<name>.bin` / `cwd` / `env` | how to invoke the CLI (`bin` is relative to `cwd`) |
-| `clis.<name>.discover` or `resources` | runtime discovery (`ncl help`) vs a static resource list |
-| `clis.<name>.list` | argv template; `{resource}` is the only substitution |
-| `clis.<name>.output` | `json` or `jsonlines` (docker/kubectl style) |
-| `clis.<name>.unwrap` | dot-path into a response envelope (e.g. `data`) |
-| `clis.<name>.enrich`/`badges`/`summary` | table decorations (ID→name joins, status colors, summary cards) |
-| `activity` | `sessionsRoot` + `days` for the message-activity charts |
-| `logs` | `dir`, `tailLines`, and an allowlist of `files` to tail |
-| `docs` | file viewer: `root`, a `deny` glob list, and `collections` of glob patterns |
-
-Adding a second CLI is config-only — e.g. `docker` is included as a `jsonlines`
-example. View plugins (`views/<cli>-<view>.js`) are the only per-CLI code and
-are optional.
-
-## Troubleshooting
-
-- **`ENOENT` / config not found** — run from `tools/clidash/` and make sure you
-  copied `clidash.config.example.json` to `clidash.config.json` (step 2), or set
-  `CLIDASH_CONFIG=/abs/path.json`.
-- **No `ncl` resources / discovery empty** — `bin/ncl` isn't built or the path
-  is wrong. Build it (`pnpm run build`) or fix `clis.ncl.bin`.
-- **docker tab errors** — the docker daemon isn't running, or remove the
-  `docker` CLI from config if you don't need it.
-- **Can't reach it from another device** — it binds `127.0.0.1`; set
-  `BIND=<private-ip>` (tailnet), never a public interface.
-- **Empty Activity/Logs/Files** — check that `activity.sessionsRoot`,
-  `logs.dir`, and `docs.root` resolve to your NanoClaw root (relative to where
-  you launch `node server.js`).
-
-## Removal
-
-See [REMOVE.md](REMOVE.md).

.claude/skills/add-clidash/add/tools/clidash/README.md

@@ -1,109 +0,0 @@
-# clidash
-
-CLI-agnostic **read-only** web dashboard. Point it at any CLI that can list
-resources as JSON and it derives the dashboard at runtime: one tab per
-resource, a generic table over whatever columns the rows have. New resource →
-new tab; new column → new table column; **zero code changes**.
-
-It ships pre-wired for NanoClaw's `ncl` CLI (agent groups, sessions, messaging
-groups, wirings, users, roles, …) plus `docker`, but the same config shape
-works for any list-as-JSON CLI.
-
-- **Zero dependencies** — Node built-ins only (Node ≥ 22.5, for `node:sqlite`),
-  no build step,
-  vanilla-JS frontend.
-- **Read-only by construction** — the server can only `execFile` the configured
-  argv templates; `{resource}` is the sole substitution and is validated
-  against the discovered/static resource allowlist. Never a shell.
-- **Standalone** — no imports from NanoClaw source; the core is extractable to
-  its own repo. The NanoClaw-specific knowledge lives entirely in the config
-  and in the `views/ncl-overview.js` view plugin.
-
-## Run
-
-```bash
-cp clidash.config.example.json clidash.config.json   # then edit paths if needed
-node server.js                                        # uses ./clidash.config.json
-CLIDASH_CONFIG=/path/to.json node server.js
-PORT=4690 BIND=127.0.0.1 node server.js               # env overrides
-```
-
-Run it from `tools/clidash/`; the example config uses paths relative to the
-NanoClaw root two levels up, so it works out of the box once `ncl` is built.
-
-## Configure (`clidash.config.json`)
-
-```jsonc
-{
-  "port": 4690,
-  "bind": "127.0.0.1",          // never a public interface; a tailnet IP at most
-  "refreshSeconds": 60,
-  "clis": {
-    "ncl": {
-      "bin": "bin/ncl",                                        // relative to cwd below
-      "cwd": "../..",                                           // the NanoClaw root
-      "discover": { "args": ["help"], "parser": "ncl-help" },   // runtime resource discovery
-      "list": ["{resource}", "list", "--json"],                 // argv template
-      "output": "json",          // or "jsonlines" (docker/kubectl style)
-      "unwrap": "data"           // dot-path into a response envelope
-    },
-    "docker": {
-      "bin": "docker",
-      "resources": ["ps", "images"],          // static alternative to discover
-      "list": ["{resource}", "--format", "{{json .}}"],
-      "output": "jsonlines"
-    }
-  }
-}
-```
-
-`{resource}` may appear as a whole argv element or inside one — e.g. a remote
-CLI via ssh: `"list": ["-i", "key.pem", "user@host", "ncl {resource} list --json"]`.
-
-Per-CLI `env` (merged over the server's env) and `cwd` are supported. See
-`clidash.config.example.json` for the full NanoClaw config, including the
-`enrich`/`badges`/`summary` table decorations and the `activity`/`logs`/`docs`
-sections.
-
-## API
-
-| Route | Returns |
-|---|---|
-| `GET /api/clis` | configured CLIs + discovered/static resources (discovery cached 60s) |
-| `GET /api/r/<cli>/<resource>` | `{ok, rows, fetchedAt}` — coalesced, 10s exec timeout |
-| `GET /api/view/<cli>/<view>` | curated view plugin from `views/<cli>-<view>.js` |
-
-View plugins are the only per-CLI *code*, and optional: a default-exported
-async function receiving `{ fetch }` (bound to that CLI) returning JSON.
-`views/ncl-overview.js` joins groups + sessions + messaging-groups + wirings
-into per-agent status cards (green <15m / amber <2h / red older).
-
-## Test
-
-```bash
-npm test            # unit + integration (node:test, stub CLI — no real CLI needed)
-./test/smoke.sh     # against a running instance
-```
-
-## Deploy as a service
-
-clidash binds `127.0.0.1` by default. To reach it from other devices, bind a
-private (e.g. tailnet) IP — **never a public interface**; the network is the
-auth boundary. Example systemd user service:
-
-```ini
-# ~/.config/systemd/user/clidash.service
-[Unit]
-Description=clidash read-only CLI dashboard
-
-[Service]
-WorkingDirectory=%h/nanoclaw/tools/clidash
-ExecStart=/usr/bin/node %h/nanoclaw/tools/clidash/server.js
-Environment=BIND=127.0.0.1
-Restart=on-failure
-
-[Install]
-WantedBy=default.target
-```
-
-Then `systemctl --user enable --now clidash`.

.claude/skills/add-clidash/add/tools/clidash/activity.js

@@ -1,86 +0,0 @@
-// Message-activity reader for clidash.
-//
-// ncl has no `messages` resource — message data lives in the per-session SQLite
-// DBs (`data/v2-sessions/<group>/<session>/{inbound,outbound}.db`). We read them
-// read-only with Node's built-in `node:sqlite` (no new dependency) and aggregate
-// per-session in/out totals + a daily time-series for charting.
-
-import { readdirSync, existsSync } from 'node:fs';
-import { join } from 'node:path';
-import { DatabaseSync } from 'node:sqlite';
-
-// Timestamps come in two shapes across tables: SQLite "YYYY-MM-DD HH:MM:SS" (UTC)
-// and already-ISO "YYYY-MM-DDTHH:MM:SS.sssZ". Normalize to a comparable ISO form
-// so date-bucketing and max("last") work regardless of which a row used.
-function normTs(ts) {
-  if (typeof ts !== 'string' || ts.length < 10) return null;
-  if (ts.includes('T')) return ts; // already ISO
-  return `${ts.replace(' ', 'T')}Z`;
-}
-
-// Local calendar day "YYYY-MM-DD" — chart labels are read by a human, so
-// bucket by the server's local day, not the UTC date prefix.
-function localDay(date) {
-  return date.toLocaleDateString('sv-SE');
-}
-
-function readTable(dbPath, table) {
-  let db;
-  try {
-    db = new DatabaseSync(dbPath, { readOnly: true });
-    const rows = db.prepare(`SELECT timestamp FROM ${table}`).all();
-    const byDay = new Map();
-    let last = null;
-    for (const r of rows) {
-      const ts = normTs(r.timestamp);
-      if (!ts) continue;
-      const day = localDay(new Date(ts));
-      byDay.set(day, (byDay.get(day) ?? 0) + 1);
-      if (last === null || ts > last) last = ts;
-    }
-    return { total: rows.length, byDay, last };
-  } catch {
-    return { total: 0, byDay: new Map(), last: null }; // missing/locked/corrupt → skip
-  } finally {
-    try { db?.close(); } catch { /* already closed */ }
-  }
-}
-
-function listDirs(path) {
-  try {
-    return readdirSync(path, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
-  } catch {
-    return [];
-  }
-}
-
-/**
- * Aggregate message activity across all session DBs under `sessionsRoot`.
- * @returns {{ sessions: Array, series: Array<{date,in,out}> }}
- *   sessions — per session: { agent_group_id, session_id, in, out, lastActivity }
- *   series   — one bucket per day for the last `days` days (local time, newest last)
- */
-export function collectActivity(sessionsRoot, days, now) {
-  const dates = [];
-  for (let i = days - 1; i >= 0; i--) {
-    dates.push(localDay(new Date(now.getTime() - i * 86_400_000)));
-  }
-  const series = new Map(dates.map((d) => [d, { date: d, in: 0, out: 0 }]));
-  const sessions = [];
-
-  for (const group of listDirs(sessionsRoot)) {
-    for (const session of listDirs(join(sessionsRoot, group))) {
-      const base = join(sessionsRoot, group, session);
-      // a real session dir has at least one of the two message DBs; skip shared
-      // scaffolding dirs like `.claude-shared` that don't.
-      if (!existsSync(join(base, 'inbound.db')) && !existsSync(join(base, 'outbound.db'))) continue;
-      const inb = readTable(join(base, 'inbound.db'), 'messages_in');
-      const out = readTable(join(base, 'outbound.db'), 'messages_out');
-      const lastActivity = [inb.last, out.last].filter(Boolean).sort().at(-1) ?? null;
-      sessions.push({ agent_group_id: group, session_id: session, in: inb.total, out: out.total, lastActivity });
-      for (const [day, n] of inb.byDay) series.get(day)?.in !== undefined && (series.get(day).in += n);
-      for (const [day, n] of out.byDay) series.get(day)?.out !== undefined && (series.get(day).out += n);
-    }
-  }
-  return { sessions, series: dates.map((d) => series.get(d)) };
-}

.claude/skills/add-clidash/add/tools/clidash/clidash.config.example.json

@@ -1,106 +0,0 @@
-{
-  "port": 4690,
-  "bind": "127.0.0.1",
-  "refreshSeconds": 60,
-  "clis": {
-    "ncl": {
-      "bin": "bin/ncl",
-      "cwd": "../..",
-      "discover": { "args": ["help"], "parser": "ncl-help" },
-      "list": ["{resource}", "list", "--json"],
-      "output": "json",
-      "unwrap": "data",
-      "commands": {
-        "get": ["{resource}", "get", "--id", "{id}", "--json"],
-        "config-get": ["groups", "config", "get", "--id", "{id}", "--json"]
-      },
-      "help": ["{resource}", "help"],
-      "enrich": {
-        "sessions": {
-          "agent_group_id": { "ref": "groups", "label": "name" },
-          "messaging_group_id": { "ref": "messaging-groups", "label": "name" }
-        },
-        "wirings": {
-          "agent_group_id": { "ref": "groups", "label": "name" },
-          "messaging_group_id": { "ref": "messaging-groups", "label": "name" }
-        },
-        "roles": {
-          "agent_group_id": { "ref": "groups", "label": "name" },
-          "user_id": { "ref": "users", "label": "display_name" },
-          "granted_by": { "ref": "users", "label": "display_name" }
-        },
-        "members": {
-          "agent_group_id": { "ref": "groups", "label": "name" },
-          "user_id": { "ref": "users", "label": "display_name" }
-        },
-        "destinations": {
-          "agent_group_id": { "ref": "groups", "label": "name" }
-        },
-        "user-dms": {
-          "user_id": { "ref": "users", "label": "display_name" },
-          "messaging_group_id": { "ref": "messaging-groups", "label": "name" }
-        }
-      },
-      "badges": {
-        "container_status": { "running": "green", "idle": "green", "starting": "amber", "stopped": "gray", "error": "red" },
-        "status": { "active": "green", "stopped": "gray", "error": "red", "pending": "amber" }
-      },
-      "summary": {
-        "sessions": "container_status",
-        "messaging-groups": "channel_type",
-        "roles": "role",
-        "users": "kind",
-        "destinations": "target_type",
-        "dropped-messages": "reason"
-      }
-    },
-    "docker": {
-      "bin": "docker",
-      "resources": ["ps", "images"],
-      "list": ["{resource}", "--format", "{{json .}}"],
-      "output": "jsonlines"
-    }
-  },
-  "activity": {
-    "sessionsRoot": "../../data/v2-sessions",
-    "days": 14
-  },
-  "logs": {
-    "dir": "../../logs",
-    "tailLines": 500,
-    "files": [
-      { "name": "nanoclaw.log", "label": "host log" },
-      { "name": "nanoclaw.error.log", "label": "errors" }
-    ]
-  },
-  "docs": {
-    "root": "../..",
-    "deny": ["node_modules", ".env", "*token*", "*secret*", "*.pem", "*.key", "*.lock", "pnpm-lock.yaml"],
-    "collections": [
-      {
-        "name": "skills",
-        "label": "Skills",
-        "lang": "markdown",
-        "patterns": ["groups/*/skills/*/SKILL.md", "container/skills/*/SKILL.md"]
-      },
-      {
-        "name": "claude-md",
-        "label": "CLAUDE.md",
-        "lang": "markdown",
-        "patterns": ["groups/*/CLAUDE.md", "groups/*/CLAUDE.local.md"]
-      },
-      {
-        "name": "profiles",
-        "label": "Profiles",
-        "lang": "json",
-        "patterns": ["groups/*/profile.json"]
-      },
-      {
-        "name": "conversations",
-        "label": "Conversations",
-        "lang": "markdown",
-        "patterns": ["groups/*/conversations/*.md"]
-      }
-    ]
-  }
-}

.claude/skills/add-clidash/add/tools/clidash/docs.js

@@ -1,102 +0,0 @@
-// Read-only file viewer for clidash.
-//
-// Surfaces on-disk documents (skills, CLAUDE.md, profile.json, conversations)
-// that are NOT ncl resources. Same security posture as the rest of clidash:
-// only files matching a configured collection's glob patterns are listable or
-// readable; a deny-list blocks secrets; path traversal is impossible because a
-// requested path must be a member of the freshly-globbed allow-set.
-
-import { readdirSync, realpathSync } from 'node:fs';
-import { join, resolve, sep } from 'node:path';
-
-// Convert one glob segment to an anchored regex. `*` matches any run of
-// non-slash chars (so it works both as a whole segment and inside a filename,
-// e.g. `CLAUDE*.md`). All other regex metacharacters are escaped.
-function segToRegExp(seg) {
-  const esc = seg.replace(/[.+^${}()|[\]\\?]/g, '\\$&').replace(/\*/g, '[^/]*');
-  return new RegExp('^' + esc + '$');
-}
-
-// A path is denied if any of its segments matches any deny glob.
-function isDenied(relPath, deny) {
-  const segs = relPath.split('/');
-  return deny.some((d) => {
-    const re = segToRegExp(d);
-    return segs.some((s) => re.test(s));
-  });
-}
-
-// Directed walk: descend only entries matching each successive pattern segment.
-function walk(root, rel, segs, depth, out, deny) {
-  if (depth >= segs.length) return;
-  let entries;
-  try {
-    entries = readdirSync(join(root, rel), { withFileTypes: true });
-  } catch {
-    return;
-  }
-  const re = segToRegExp(segs[depth]);
-  const last = depth === segs.length - 1;
-  for (const e of entries) {
-    if (e.name === '.' || e.name === '..') continue;
-    if (!re.test(e.name)) continue;
-    const childRel = rel ? `${rel}/${e.name}` : e.name;
-    if (isDenied(childRel, deny)) continue;
-    if (last) {
-      if (e.isFile()) out.add(childRel);
-    } else if (e.isDirectory()) {
-      walk(root, childRel, segs, depth + 1, out, deny);
-    }
-  }
-}
-
-/**
- * Relative paths under `root` matching any of `patterns`, minus `deny` matches.
- * Sorted, de-duplicated. Patterns use `*` per the segment rules above; no `**`.
- */
-export function globFiles(root, patterns, deny = []) {
-  const out = new Set();
-  for (const pattern of patterns) {
-    walk(root, '', pattern.split('/'), 0, out, deny);
-  }
-  return [...out].sort();
-}
-
-/**
- * Human-friendly grouping/label for a relative path.
- * `groups/<g>/...` → group `<g>`; `container/...` → group `shared`.
- */
-const CONTAINER_SEGS = new Set(['skills', 'conversations']); // redundant grouping dirs
-export function describeFile(relPath) {
-  const parts = relPath.split('/');
-  if (parts[0] === 'groups' && parts.length > 2) {
-    const rest = parts.slice(2).filter((s) => !CONTAINER_SEGS.has(s)).join('/');
-    return { group: parts[1], label: `${parts[1]} / ${rest}` };
-  }
-  if (parts[0] === 'container') {
-    const rest = parts.slice(2).filter((s) => !CONTAINER_SEGS.has(s)).join('/');
-    return { group: 'shared', label: `shared / ${rest}` };
-  }
-  return { group: '', label: relPath };
-}
-
-/**
- * Validate a requested doc path against a collection and return its absolute
- * path, or throw. A path is allowed only if it is a member of the collection's
- * freshly-globbed allow-set — this single check enforces the patterns, the
- * deny-list, and traversal safety at once.
- */
-export function resolveDoc(root, collection, relPath, deny = []) {
-  const allowed = new Set(globFiles(root, collection.patterns, deny));
-  if (!allowed.has(relPath)) {
-    throw new Error(`Path not allowed: ${relPath}`);
-  }
-  // Defence in depth: the resolved real path must still live under root.
-  const abs = resolve(root, relPath);
-  const rootReal = realpathSync(root);
-  const absReal = realpathSync(abs);
-  if (absReal !== rootReal && !absReal.startsWith(rootReal + sep)) {
-    throw new Error(`Path not allowed: ${relPath}`);
-  }
-  return abs;
-}

.claude/skills/add-clidash/add/tools/clidash/logs.js

@@ -1,18 +0,0 @@
-// Log tailing for clidash — reads the last N lines of an allowlisted log file
-// and strips ANSI color codes (the host logger writes colored output).
-
-import { readFile } from 'node:fs/promises';
-
-const ANSI_RE = /\x1b\[[0-9;]*m/g;
-
-/**
- * Last `maxLines` lines of a log file, ANSI-stripped.
- * @returns {{ lines: string[], text: string }}
- */
-export async function tailFile(path, maxLines) {
-  const raw = (await readFile(path, 'utf8')).replace(ANSI_RE, '');
-  const all = raw.split('\n');
-  if (all.length && all.at(-1) === '') all.pop(); // drop trailing newline's empty field
-  const lines = all.slice(-maxLines);
-  return { lines, text: lines.join('\n') };
-}

.claude/skills/add-clidash/add/tools/clidash/package.json

@@ -1,14 +0,0 @@
-{
-  "name": "clidash",
-  "version": "0.1.0",
-  "description": "CLI-agnostic read-only web dashboard — derives tabs and tables from any CLI that lists resources as JSON",
-  "type": "module",
-  "private": true,
-  "scripts": {
-    "start": "node server.js",
-    "test": "node --test 'test/*.test.js'"
-  },
-  "engines": {
-    "node": ">=22.5"
-  }
-}

.claude/skills/add-clidash/add/tools/clidash/parsers.js

@@ -1,101 +0,0 @@
-// Pluggable parsers for clidash.
-//
-// discoveryParsers — turn a CLI's "help"-style output into a resource list.
-// parseOutput / unwrapPath — turn a CLI's list output into rows.
-// All per-CLI knowledge beyond these small functions lives in clidash.config.json.
-
-/**
- * Discovery parsers, keyed by the `discover.parser` name in config.
- * Each receives the raw discovery output and returns
- * [{ name, description, verbs }] for resources that support `list`.
- * They must throw loudly on unrecognized formats — silent empty results
- * would render as silently-stale tabs.
- */
-export const discoveryParsers = {
-  /**
-   * Parses ncl's two-column help format:
-   *
-   *   Resources:
-   *     sessions             Session — the runtime unit. ...
-   *                          verbs: list, get
-   *   Commands:
-   *     help                 ...
-   */
-  'ncl-help'(text) {
-    const lines = String(text).split('\n');
-    const start = lines.findIndex((l) => l.trim() === 'Resources:');
-    if (start === -1) {
-      throw new Error('ncl-help parser: no "Resources:" section in output — format may have changed');
-    }
-    const resources = [];
-    let current = null;
-    for (let i = start + 1; i < lines.length; i++) {
-      const line = lines[i];
-      if (line.trim() === '') continue;
-      if (/^\S/.test(line)) break; // next top-level section, e.g. "Commands:"
-      const verbsMatch = line.match(/^\s+verbs:\s*(.+)$/);
-      if (verbsMatch && current) {
-        current.verbs = verbsMatch[1].split(',').map((v) => v.trim()).filter(Boolean);
-        continue;
-      }
-      const resMatch = line.match(/^  (\S+)\s{2,}(\S.*)$/);
-      if (resMatch) {
-        current = { name: resMatch[1], description: resMatch[2].trim(), verbs: [] };
-        resources.push(current);
-      }
-    }
-    return resources.filter((r) => r.verbs.includes('list'));
-  },
-};
-
-/**
- * Parses a CLI's list output per the config's `output` field.
- * - 'json'      — one JSON document.
- * - 'jsonlines' — one JSON object per line (docker/kubectl style).
- * Thrown errors carry the raw output on `err.raw` so the UI can show it.
- */
-export function parseOutput(text, format) {
-  if (format === 'json') {
-    try {
-      return JSON.parse(text);
-    } catch (e) {
-      const err = new Error(`Invalid JSON output: ${e.message}`);
-      err.raw = text;
-      throw err;
-    }
-  }
-  if (format === 'jsonlines') {
-    const rows = [];
-    const lines = String(text).split('\n');
-    for (let i = 0; i < lines.length; i++) {
-      const line = lines[i].trim();
-      if (!line) continue;
-      try {
-        rows.push(JSON.parse(line));
-      } catch (e) {
-        const err = new Error(`Invalid JSON on line ${i + 1}: ${e.message}`);
-        err.raw = text;
-        throw err;
-      }
-    }
-    return rows;
-  }
-  throw new Error(`Unknown output format: ${format}`);
-}
-
-/**
- * Follows a dot-path into a response envelope (e.g. 'data' for ncl's
- * {id, ok, data} frame). No path → value passes through unchanged.
- * Missing path throws — a changed envelope must fail loudly.
- */
-export function unwrapPath(value, path) {
-  if (!path) return value;
-  let cur = value;
-  for (const key of path.split('.')) {
-    if (cur === null || typeof cur !== 'object' || !(key in cur)) {
-      throw new Error(`Unwrap path "${path}" not found in CLI output (missing "${key}")`);
-    }
-    cur = cur[key];
-  }
-  return cur;
-}

.claude/skills/add-clidash/add/tools/clidash/public/app.js

@@ -1,723 +0,0 @@
-// clidash frontend — vanilla JS, no build step.
-//
-// Layout: a left sidebar with top-level items (Overview, Activity) and grouped
-// sections (one per CLI — ncl, docker — and a Files section for on-disk docs).
-// Each page shows the exact command that produced it. Tables auto-derive from
-// `ncl <resource> list --json`; rows drill into their `get` detail.
-//
-// Refresh UX: on first load every resource of every CLI is prefetched so nav is
-// instant. 60s auto-refresh + a manual button. Background refreshes diff-and-
-// inject (the data DOM rebuilds only when the data signature changes).
-
-import { mdToHtml } from './md.js';
-
-const $ = (id) => document.getElementById(id);
-
-const state = {
-  clis: [],
-  docCollections: [],
-  activeView: 'overview',   // 'overview' | 'activity' | 'r:<cli>:<resource>' | 'doc:<collection>'
-  paused: false,
-  refreshSeconds: 60,
-  lastUpdated: null,
-  refreshing: false,
-  snapshots: new Map(),     // "cli/resource" -> { rows, fetchedAt, command }
-  errors: new Map(),
-  activity: null,           // { sessions, series }
-  activityConfigured: false,
-  activityCommand: null,
-  logs: [],                 // [{ name, label }]
-  logCache: new Map(),      // name -> { text, command }
-  activeDocPath: null,
-  openDocGroups: new Set(), // which doc groups (e.g. agents) are expanded
-  docCache: new Map(),
-  configCache: new Map(),   // groupId -> container config (for the overview page)
-  helpCache: new Map(),     // "cli/resource" -> help text | null (prefetched each cycle)
-  detail: null,
-  sidebarOpen: false,
-  renderedSig: null,
-};
-
-const SVG_NS = 'http://www.w3.org/2000/svg';
-function svg(tag, attrs = {}, children = []) {
-  const node = document.createElementNS(SVG_NS, tag);
-  for (const [k, v] of Object.entries(attrs)) node.setAttribute(k, v);
-  for (const c of [].concat(children)) if (c != null) node.append(c);
-  return node;
-}
-
-// Lucide-style inline icons (static trusted markup) — crisp, themeable via currentColor.
-const ICONS = {
-  overview: '<rect x="3" y="3" width="7" height="9" rx="1"/><rect x="14" y="3" width="7" height="5" rx="1"/><rect x="14" y="12" width="7" height="9" rx="1"/><rect x="3" y="16" width="7" height="5" rx="1"/>',
-  activity: '<path d="M3 3v18h18"/><path d="M18 17V9"/><path d="M13 17V5"/><path d="M8 17v-3"/>',
-  terminal: '<rect x="2" y="4" width="20" height="16" rx="2"/><path d="m6 9 3 3-3 3"/><path d="M13 15h4"/>',
-  box: '<path d="M21 8a2 2 0 0 0-1-1.73l-7-4a2 2 0 0 0-2 0l-7 4A2 2 0 0 0 3 8v8a2 2 0 0 0 1 1.73l7 4a2 2 0 0 0 2 0l7-4A2 2 0 0 0 21 16Z"/><path d="m3.3 7 8.7 5 8.7-5"/><path d="M12 22V12"/>',
-  folder: '<path d="M4 20h16a2 2 0 0 0 2-2V8a2 2 0 0 0-2-2h-7.9a2 2 0 0 1-1.69-.9L9.6 3.9A2 2 0 0 0 7.93 3H4a2 2 0 0 0-2 2v13c0 1.1.9 2 2 2Z"/>',
-  logs: '<path d="M15 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V7Z"/><path d="M14 2v5h5"/><path d="M8 13h8"/><path d="M8 17h5"/>',
-};
-function icon(name) {
-  const s = document.createElementNS(SVG_NS, 'svg');
-  s.setAttribute('viewBox', '0 0 24 24');
-  s.setAttribute('fill', 'none');
-  s.setAttribute('stroke', 'currentColor');
-  s.setAttribute('stroke-width', '1.8');
-  s.setAttribute('stroke-linecap', 'round');
-  s.setAttribute('stroke-linejoin', 'round');
-  s.innerHTML = ICONS[name] ?? '';
-  return s;
-}
-
-// ---------------------------------------------------------------- helpers
-
-const ISO_RE = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}/;
-
-// Local wall time "YYYY-MM-DD HH:mm" — the raw ISO string is UTC; slicing it
-// would display UTC wall time with no marker, masquerading as local.
-function absTime(iso) {
-  const d = new Date(iso);
-  if (Number.isNaN(d.getTime())) return iso;
-  return d.toLocaleString('sv-SE', { year: 'numeric', month: '2-digit', day: '2-digit', hour: '2-digit', minute: '2-digit', hour12: false });
-}
-
-function relTime(iso) {
-  const ms = Date.now() - new Date(iso).getTime();
-  if (Number.isNaN(ms)) return iso;
-  const s = Math.round(ms / 1000);
-  if (s < 0) return new Date(iso).toLocaleString();
-  if (s < 60) return `${s}s ago`;
-  const m = Math.round(s / 60);
-  if (m < 60) return `${m}m ago`;
-  const h = Math.round(m / 60);
-  if (h < 48) return `${h}h ago`;
-  return `${Math.round(h / 24)}d ago`;
-}
-
-function coarseAgo(date) {
-  const s = (Date.now() - date.getTime()) / 1000;
-  if (s < 60) return 'less than a minute ago';
-  const m = Math.floor(s / 60);
-  if (m < 60) return m === 1 ? '1 minute ago' : `${m} minutes ago`;
-  const h = Math.floor(m / 60);
-  if (h < 24) return h === 1 ? '1 hour ago' : `${h} hours ago`;
-  const d = Math.floor(h / 24);
-  return d === 1 ? '1 day ago' : `${d} days ago`;
-}
-
-function staleness(lastActive) {
-  if (!lastActive) return 'gray';
-  const min = (Date.now() - new Date(lastActive).getTime()) / 60000;
-  if (Number.isNaN(min)) return 'gray';
-  return min < 15 ? 'green' : min < 120 ? 'amber' : 'red';
-}
-
-function el(tag, attrs = {}, children = []) {
-  const node = document.createElement(tag);
-  for (const [k, v] of Object.entries(attrs)) {
-    if (k === 'class') node.className = v;
-    else if (k.startsWith('on')) node.addEventListener(k.slice(2), v);
-    else node.setAttribute(k, v);
-  }
-  for (const child of [].concat(children)) {
-    if (child == null) continue;
-    node.append(child instanceof Node ? child : document.createTextNode(String(child)));
-  }
-  return node;
-}
-
-function fmtValue(value) {
-  if (value === null || value === undefined) return { text: 'null', cls: 'null' };
-  if (typeof value === 'string' && ISO_RE.test(value)) return { iso: value };
-  return { text: typeof value === 'object' ? JSON.stringify(value) : String(value) };
-}
-
-function cellFor(value) {
-  const f = fmtValue(value);
-  if (f.cls === 'null') return el('td', { class: 'null' }, 'null');
-  if (f.iso) {
-    return el('td', {}, el('span', { class: 'reltime', title: f.iso }, [
-      relTime(f.iso), el('span', { class: 'abs' }, absTime(f.iso)),
-    ]));
-  }
-  if (f.text.length > 42) {
-    const span = el('span', { class: 'trunc', title: f.text }, f.text.slice(0, 39) + '…');
-    span.addEventListener('click', (e) => { e.stopPropagation(); span.textContent = f.text; span.classList.remove('trunc'); });
-    return el('td', {}, span);
-  }
-  return el('td', {}, f.text);
-}
-
-function kvRows(obj) {
-  return Object.entries(obj ?? {}).map(([k, v]) => {
-    let valEl;
-    if (v && typeof v === 'object') valEl = el('pre', { class: 'kv-json' }, JSON.stringify(v, null, 2));
-    else if (typeof v === 'string' && ISO_RE.test(v)) valEl = el('span', { class: 'reltime', title: v }, `${relTime(v)}  (${absTime(v)})`);
-    else if (v === null || v === undefined) valEl = el('span', { class: 'null' }, 'null');
-    else valEl = el('span', {}, String(v));
-    return el('div', { class: 'kv-row' }, [el('span', { class: 'kv-key' }, k), valEl]);
-  });
-}
-
-function resolveRef(cliName, ref, id) {
-  const snap = state.snapshots.get(`${cliName}/${ref.ref}`);
-  const row = snap?.rows?.find((r) => String(r.id) === String(id));
-  return row ? (row[ref.label] ?? null) : null;
-}
-
-function badgeChip(value, colorMap) {
-  const color = colorMap[String(value).toLowerCase()] ?? 'gray';
-  return el('span', { class: `badge-status ${color}` }, [el('span', { class: `dot ${color}` }), String(value)]);
-}
-
-function buildCell(value, column, ctx) {
-  if (ctx.badges?.[column] && value != null && typeof value !== 'object') {
-    return el('td', {}, badgeChip(value, ctx.badges[column]));
-  }
-  if (ctx.enrich?.[column] && value != null) {
-    const name = resolveRef(ctx.cliName, ctx.enrich[column], value);
-    if (name != null) {
-      return el('td', { class: 'enriched', title: String(value) }, [
-        el('span', {}, String(name)), el('span', { class: 'raw-id' }, String(value)),
-      ]);
-    }
-  }
-  return cellFor(value);
-}
-
-function summaryBar(resource, rows, col, cli) {
-  let label = resource.replace(/-/g, ' ');
-  if (rows.length === 1 && label.endsWith('s')) label = label.slice(0, -1);
-  const bits = [el('span', { class: 'sum-count' }, `${rows.length} ${label}`)];
-  if (col && rows.some((r) => col in r)) {
-    const counts = new Map();
-    for (const r of rows) { const v = r[col] ?? '—'; counts.set(v, (counts.get(v) ?? 0) + 1); }
-    const colorMap = cli.badges?.[col];
-    for (const [v, n] of [...counts.entries()].sort((a, b) => b[1] - a[1])) {
-      bits.push(el('span', { class: 'sum-sep' }, '·'));
-      const c = colorMap?.[String(v).toLowerCase()] ?? null;
-      bits.push(c
-        ? el('span', { class: `badge-status ${c}` }, [el('span', { class: `dot ${c}` }), `${v} ×${n}`])
-        : el('span', { class: 'sum-chip' }, `${v} ×${n}`));
-    }
-  }
-  return el('div', { class: 'summary-bar' }, bits);
-}
-
-// ---------------------------------------------------------------- views
-
-const nclCli = () => state.clis.find((c) => c.name === 'ncl') ?? state.clis[0];
-function currentView() {
-  const v = state.activeView;
-  if (v === 'overview' || v === 'activity') return { type: v };
-  const m = v.match(/^r:([^:]+):(.+)$/);
-  if (m) return { type: 'resource', cli: m[1], resource: m[2] };
-  if (v.startsWith('doc:')) return { type: 'doc', collection: v.slice(4) };
-  if (v.startsWith('log:')) return { type: 'log', name: v.slice(4) };
-  return { type: 'overview' };
-}
-const activeCollection = () => {
-  const v = currentView();
-  return v.type === 'doc' ? state.docCollections.find((c) => c.name === v.collection) : null;
-};
-
-// ---------------------------------------------------------------- fetching
-
-async function fetchJson(url) {
-  const res = await fetch(url);
-  return res.json().catch(() => ({ ok: false, error: `Bad response from ${url}` }));
-}
-
-async function refresh(force = false) {
-  state.refreshing = true;
-  if (force) renderControls();
-
-  const [cliList, docList, logList] = await Promise.all([
-    fetchJson('/api/clis').catch(() => null),
-    fetchJson('/api/docs').catch(() => null),
-    fetchJson('/api/logs').catch(() => null),
-  ]);
-  if (cliList?.clis) {
-    state.clis = cliList.clis;
-    state.refreshSeconds = cliList.clis[0]?.refreshSeconds ?? state.refreshSeconds;
-  }
-  if (docList?.collections) state.docCollections = docList.collections;
-  if (logList?.files) state.logs = logList.files;
-
-  render(); // paint sidebar + active view's loading state immediately
-
-  const jobs = [];
-  jobs.push(fetchJson('/api/activity').then((body) => {
-    if (body.ok && body.configured) {
-      state.activity = { sessions: body.sessions, series: body.series };
-      state.activityConfigured = true; state.activityCommand = body.command ?? null;
-    } else state.activityConfigured = false;
-    render();
-  }));
-  for (const lg of state.logs) {
-    jobs.push(fetchJson(`/api/log/${encodeURIComponent(lg.name)}`).then((body) => {
-      if (body.ok) state.logCache.set(lg.name, { text: body.text, command: body.command });
-      render();
-    }));
-  }
-  for (const c of state.clis) {
-    for (const r of c.resources ?? []) {
-      const key = `${c.name}/${r.name}`;
-      jobs.push(fetchJson(`/api/r/${c.name}/${encodeURIComponent(r.name)}`).then((body) => {
-        if (body.ok) { state.snapshots.set(key, { rows: body.rows, fetchedAt: body.fetchedAt, command: body.command }); state.errors.set(key, null); }
-        else state.errors.set(key, body.raw ? `${body.error}\n\n${body.raw}` : body.error);
-        render();
-      }));
-      if (c.help) {
-        jobs.push(fetchJson(`/api/help/${c.name}/${encodeURIComponent(r.name)}`).then((body) => {
-          state.helpCache.set(key, body.ok ? body.text : null);
-          render();
-        }));
-      }
-    }
-  }
-  await Promise.all(jobs);
-
-  // per-group container config (for the Overview page) — small, refetched each cycle
-  const groups = state.snapshots.get('ncl/groups')?.rows ?? [];
-  await Promise.all(groups.map(async (g) => {
-    const c = await fetchJson(`/api/cmd/ncl/config-get?id=${encodeURIComponent(g.id)}`);
-    if (c.ok) state.configCache.set(g.id, c.data);
-  }));
-
-  state.lastUpdated = new Date();
-  state.refreshing = false;
-  render();
-}
-
-async function openDoc(collectionName, path) {
-  state.activeDocPath = path;
-  const key = `${collectionName}\0${path}`;
-  if (!state.docCache.has(key)) {
-    const body = await fetchJson(`/api/doc?c=${encodeURIComponent(collectionName)}&p=${encodeURIComponent(path)}`);
-    state.docCache.set(key, body.ok ? { lang: body.lang, content: body.content } : { lang: 'error', content: body.error || 'Failed to load' });
-  }
-  state.renderedSig = null;
-  render();
-}
-
-async function openDetail(cliName, resource, id) {
-  state.detail = { cli: cliName, resource, id, loading: true };
-  state.renderedSig = null;
-  render();
-  const rec = await fetchJson(`/api/cmd/${cliName}/get?resource=${encodeURIComponent(resource)}&id=${encodeURIComponent(id)}`);
-  let config = null;
-  if (resource === 'groups') {
-    const cg = await fetchJson(`/api/cmd/${cliName}/config-get?id=${encodeURIComponent(id)}`);
-    if (cg.ok) config = cg.data;
-  }
-  if (!state.detail || state.detail.id !== id) return;
-  state.detail = { cli: cliName, resource, id, record: rec.ok ? rec.data : null, error: rec.ok ? null : rec.error, config };
-  state.renderedSig = null;
-  render();
-}
-
-function closeDetail() { state.detail = null; state.renderedSig = null; render(); }
-
-// Help panel: the description (first paragraph) is always visible; the verbs +
-// fields (everything after the first blank line) sit behind a collapse.
-function helpPanel(text) {
-  if (text === null) return null; // explicitly no help
-  if (text === undefined) return el('div', { class: 'help-panel' }, el('div', { class: 'help-head dim' }, 'loading help…'));
-  const idx = text.indexOf('\n\n');
-  const head = (idx >= 0 ? text.slice(0, idx) : text).trim();
-  const body = idx >= 0 ? text.slice(idx + 2).trim() : '';
-  return el('div', { class: 'help-panel' }, [
-    el('div', { class: 'help-head' }, head),
-    body ? el('details', { class: 'help-more' }, [
-      el('summary', {}, 'verbs & fields'),
-      el('pre', { class: 'help-text' }, body),
-    ]) : null,
-  ]);
-}
-
-function go(view) {
-  state.activeView = view;
-  state.detail = null;
-  state.sidebarOpen = false;
-  state.renderedSig = null;
-  const v = currentView();
-  if (v.type === 'doc') {
-    const coll = state.docCollections.find((c) => c.name === v.collection);
-    const first = coll && (coll.name === 'conversations' ? coll.files.at(-1) : coll.files[0]); // newest conversation
-    state.activeDocPath = state.activeDocPath && coll?.files.some((f) => f.path === state.activeDocPath)
-      ? state.activeDocPath : (first?.path ?? null);
-    // expand only the group holding the active doc; the user picks the rest
-    const activeFile = coll?.files.find((f) => f.path === state.activeDocPath);
-    state.openDocGroups = new Set(activeFile ? [activeFile.group] : []);
-    render();
-    if (state.activeDocPath) openDoc(coll.name, state.activeDocPath);
-    return;
-  }
-  render();
-}
-
-// ---------------------------------------------------------------- rendering
-
-function dataSignature() {
-  const v = currentView();
-  const key = v.type === 'resource' ? `${v.cli}/${v.resource}` : null;
-  const coll = activeCollection();
-  return JSON.stringify({
-    view: state.activeView, clis: state.clis.map((c) => `${c.name}:${(c.resources || []).length}`),
-    activityConfigured: state.activityConfigured,
-    rows: key ? state.snapshots.get(key)?.rows ?? null : null,
-    rowsError: key ? state.errors.get(key) ?? null : null,
-    command: key ? state.snapshots.get(key)?.command ?? null : null,
-    help: key ? state.helpCache.get(key) ?? null : null,
-    overview: v.type === 'overview' ? {
-      groups: state.snapshots.get('ncl/groups')?.rows ?? null,
-      sessions: state.snapshots.get('ncl/sessions')?.rows ?? null,
-      configs: [...state.configCache.entries()],
-      activity: state.activity?.sessions ?? null,
-    } : null,
-    activity: v.type === 'activity' ? state.activity : null,
-    log: v.type === 'log' ? state.logCache.get(v.name)?.text ?? null : null,
-    docFiles: coll ? coll.files.map((f) => f.path) : null,
-    docPath: state.activeDocPath,
-    docGroupsOpen: coll ? [...state.openDocGroups] : null,
-    docContent: coll ? state.docCache.get(`${coll.name}\0${state.activeDocPath}`)?.content ?? null : null,
-    detail: state.detail, paused: state.paused, sidebarOpen: state.sidebarOpen,
-  });
-}
-
-function renderControls() {
-  $('updated').textContent = state.lastUpdated
-    ? `updated ${coarseAgo(state.lastUpdated)}${state.paused ? ' · paused' : ''}` : '';
-  $('refresh').classList.toggle('spinning', state.refreshing);
-}
-
-function render() {
-  renderControls();
-  const sig = dataSignature();
-  if (sig === state.renderedSig) return;
-  state.renderedSig = sig;
-
-  $('sidebar').classList.toggle('open', state.sidebarOpen);
-  $('scrim').hidden = !state.sidebarOpen;
-
-  renderNav();
-
-  const v = currentView();
-  const banner = $('banner');
-  const tabError = v.type === 'resource' ? state.errors.get(`${v.cli}/${v.resource}`) : null;
-  const cli = v.type === 'resource' ? state.clis.find((c) => c.name === v.cli) : null;
-  const bannerMsg = cli?.error ? `Discovery failed for ${v.cli}: ${cli.error}`
-    : (tabError ? `CLI unreachable — showing last good snapshot. ${tabError.split('\n')[0]}` : null);
-  banner.hidden = !bannerMsg;
-  banner.textContent = bannerMsg ?? '';
-
-  renderCmdline(v);
-  if (v.type === 'overview') renderOverviewPage();
-  else if (v.type === 'activity') renderActivity();
-  else if (v.type === 'doc') renderDocs();
-  else if (v.type === 'log') renderLogPage(v.name);
-  else renderTable(v.cli, v.resource);
-  renderDetail();
-}
-
-function navItem(label, view, cls = '', iconName = null) {
-  return el('button', {
-    class: `nav-item ${cls}` + (state.activeView === view ? ' active' : ''),
-    onclick: () => go(view),
-  }, [iconName ? icon(iconName) : null, el('span', {}, label)]);
-}
-
-function renderNav() {
-  const nav = $('nav');
-  const items = [navItem('Overview', 'overview', '', 'overview')];
-  if (state.activityConfigured) items.push(navItem('Activity', 'activity', '', 'activity'));
-
-  for (const cli of state.clis) {
-    items.push(el('div', { class: 'nav-section' }, [icon(cli.name === 'docker' ? 'box' : 'terminal'), el('span', {}, cli.name)]));
-    for (const r of cli.resources ?? []) {
-      items.push(navItem(r.name, `r:${cli.name}:${r.name}`, 'nav-sub'));
-    }
-  }
-  if (state.docCollections.length) {
-    items.push(el('div', { class: 'nav-section' }, [icon('folder'), el('span', {}, 'Files')]));
-    for (const coll of state.docCollections) {
-      items.push(navItem(coll.label, `doc:${coll.name}`, 'nav-sub'));
-    }
-  }
-  if (state.logs.length) {
-    items.push(el('div', { class: 'nav-section' }, [icon('logs'), el('span', {}, 'Logs')]));
-    for (const lg of state.logs) {
-      items.push(navItem(lg.label, `log:${lg.name}`, 'nav-sub'));
-    }
-  }
-  nav.replaceChildren(...items);
-}
-
-function renderCmdline(v) {
-  const bar = $('cmdline');
-  let cmd = null;
-  if (v.type === 'resource') cmd = state.snapshots.get(`${v.cli}/${v.resource}`)?.command;
-  else if (v.type === 'activity') cmd = state.activityCommand;
-  else if (v.type === 'doc') cmd = state.activeDocPath ? `file · ${state.activeDocPath}` : null;
-  else if (v.type === 'log') cmd = state.logCache.get(v.name)?.command ?? null;
-  else if (v.type === 'overview') cmd = 'derived · ncl groups/sessions/messaging-groups/wirings + config-get + activity';
-  bar.hidden = !cmd;
-  bar.textContent = cmd ? `$ ${cmd}` : '';
-}
-
-// ---- Overview page (rich agent cards) ----
-
-function renderOverviewPage() {
-  const content = $('content');
-  const groups = state.snapshots.get('ncl/groups')?.rows;
-  if (!groups) { content.replaceChildren(el('div', { class: 'empty' }, 'Loading…')); return; }
-  const sessions = state.snapshots.get('ncl/sessions')?.rows ?? [];
-  const wirings = state.snapshots.get('ncl/wirings')?.rows ?? [];
-  const mgs = state.snapshots.get('ncl/messaging-groups')?.rows ?? [];
-  const act = state.activity?.sessions ?? [];
-  const mgName = (id) => mgs.find((m) => m.id === id)?.name ?? mgs.find((m) => m.id === id)?.platform_id ?? id;
-
-  const field = (k, v, cls = '') => el('div', { class: 'ov-field' }, [el('span', { class: 'k' }, k), el('span', { class: `v ${cls}` }, v)]);
-
-  const cards = groups.map((g) => {
-    const gs = sessions.filter((s) => s.agent_group_id === g.id);
-    const lastActive = gs.map((s) => s.last_active).filter(Boolean).sort().at(-1) ?? null;
-    const container = gs.some((s) => s.container_status === 'running') ? 'running' : (gs[0]?.container_status ?? 'none');
-    const ga = act.filter((a) => a.agent_group_id === g.id);
-    const msgIn = ga.reduce((a, s) => a + s.in, 0), msgOut = ga.reduce((a, s) => a + s.out, 0);
-    const cfg = state.configCache.get(g.id);
-    const chans = wirings.filter((w) => w.agent_group_id === g.id).map((w) => `${mgs.find((m) => m.id === w.messaging_group_id)?.channel_type ?? '?'}: ${mgName(w.messaging_group_id)}`);
-    const status = staleness(lastActive);
-    const containerColor = container === 'running' ? 'green' : container === 'idle' ? 'green' : container === 'none' ? 'gray' : 'gray';
-
-    const fields = [
-      el('div', { class: 'ov-field' }, [el('span', { class: 'k' }, 'container'), badgeChip(container, { running: 'green', idle: 'green', stopped: 'gray', none: 'gray' })]),
-      field('sessions', String(gs.length)),
-      field('messages', `${msgIn} in · ${msgOut} out`),
-      field('last active', lastActive ? relTime(lastActive) : '—', lastActive ? '' : 'dim'),
-    ];
-    if (cfg) {
-      fields.push(field('provider / model', `${cfg.provider ?? 'claude'} / ${cfg.model ?? 'default'}`));
-      fields.push(el('div', { class: 'ov-field' }, [el('span', { class: 'k' }, 'cli scope'), badgeChip(cfg.cli_scope ?? 'group', { global: 'amber', group: 'green', disabled: 'gray' })]));
-      const pkgs = (cfg.packages_apt?.length ?? 0) + (cfg.packages_npm?.length ?? 0);
-      const mcp = Object.keys(cfg.mcp_servers ?? {}).length;
-      if (pkgs || mcp) fields.push(field('extras', `${pkgs} pkgs · ${mcp} mcp`));
-    }
-
-    return el('div', { class: 'ov-card' }, [
-      el('div', { class: 'ov-head' }, [
-        el('span', { class: `dot ${status}` }),
-        el('span', { class: 'ov-name' }, g.name),
-        el('span', { class: 'ov-folder' }, g.folder),
-      ]),
-      el('div', { class: 'ov-fields' }, fields),
-      el('div', { class: 'ov-chans' }, chans.map((c) => el('span', { class: 'badge' }, c))),
-    ]);
-  });
-
-  content.replaceChildren(
-    el('h2', { class: 'page-title' }, 'Agents overview'),
-    el('div', { class: 'ov-cards' }, cards),
-  );
-}
-
-// ---- Activity ----
-
-function renderActivity() {
-  const content = $('content');
-  const data = state.activity;
-  if (!data) { content.replaceChildren(el('div', { class: 'empty' }, 'Loading…')); return; }
-  const { series, sessions } = data;
-  const totalIn = series.reduce((a, d) => a + d.in, 0);
-  const totalOut = series.reduce((a, d) => a + d.out, 0);
-
-  const W = 720, H = 220, padL = 34, padB = 28, padT = 10;
-  const max = Math.max(1, ...series.map((d) => Math.max(d.in, d.out)));
-  const slot = (W - padL) / series.length;
-  const bw = Math.max(3, slot / 2 - 2);
-  const yOf = (vv) => padT + (H - padT - padB) * (1 - vv / max);
-  const chart = svg('svg', { viewBox: `0 0 ${W} ${H}`, class: 'activity-chart', preserveAspectRatio: 'none' });
-  for (const frac of [0, 0.5, 1]) {
-    const y = yOf(max * frac);
-    chart.append(svg('line', { x1: padL, y1: y, x2: W, y2: y, class: 'grid' }));
-    chart.append(svg('text', { x: padL - 6, y: y + 3, class: 'axis', 'text-anchor': 'end' }, String(Math.round(max * frac))));
-  }
-  series.forEach((d, i) => {
-    const x = padL + i * slot;
-    chart.append(svg('rect', { x: x + 1, y: yOf(d.in), width: bw, height: yOf(0) - yOf(d.in), class: 'bar-in' }, [svg('title', {}, `${d.date}: ${d.in} in`)]));
-    chart.append(svg('rect', { x: x + 1 + bw, y: yOf(d.out), width: bw, height: yOf(0) - yOf(d.out), class: 'bar-out' }, [svg('title', {}, `${d.date}: ${d.out} out`)]));
-    if (i % 2 === 0) chart.append(svg('text', { x: x + bw, y: H - 8, class: 'axis', 'text-anchor': 'middle' }, d.date.slice(5)));
-  });
-  const legend = el('div', { class: 'activity-legend' }, [
-    el('span', {}, [el('span', { class: 'lg in' }), `inbound (${totalIn})`]),
-    el('span', {}, [el('span', { class: 'lg out' }), `outbound (${totalOut})`]),
-    el('span', { class: 'dim' }, `last ${series.length} days`),
-  ]);
-  const sessRows = [...sessions].sort((a, b) => (b.lastActivity || '').localeCompare(a.lastActivity || '')).map((s) => {
-    const groupName = resolveRef('ncl', { ref: 'groups', label: 'name' }, s.agent_group_id) ?? s.agent_group_id;
-    return el('tr', {}, [
-      el('td', {}, groupName),
-      el('td', {}, el('span', { class: 'trunc', title: s.session_id }, s.session_id.slice(0, 22) + '…')),
-      el('td', { class: 'num' }, String(s.in)),
-      el('td', { class: 'num' }, String(s.out)),
-      el('td', {}, s.lastActivity ? el('span', { class: 'reltime', title: s.lastActivity }, relTime(s.lastActivity)) : el('span', { class: 'null' }, '—')),
-    ]);
-  });
-  content.replaceChildren(
-    el('h2', { class: 'page-title' }, 'Message activity'),
-    el('div', { class: 'activity-wrap' }, [
-      legend,
-      el('div', { class: 'chart-box' }, chart),
-      el('div', { class: 'table-wrap' }, el('table', { class: 'activity-table' }, [
-        el('thead', {}, el('tr', {}, ['agent', 'session', 'in', 'out', 'last activity'].map((h) => el('th', {}, h)))),
-        el('tbody', {}, sessRows),
-      ])),
-    ]),
-  );
-}
-
-// ---- Logs (tail of a log file) ----
-
-function renderLogPage(name) {
-  const content = $('content');
-  const label = state.logs.find((l) => l.name === name)?.label ?? name;
-  const cached = state.logCache.get(name);
-  if (!cached) { content.replaceChildren(el('h2', { class: 'page-title' }, label), el('div', { class: 'empty' }, 'Loading…')); return; }
-  const view = el('div', { class: 'log-view' });
-  for (const line of cached.text.split('\n')) {
-    const lvl = /\bERROR\b/i.test(line) ? 'err' : /\bWARN(ING)?\b/i.test(line) ? 'warn' : '';
-    view.append(el('div', { class: `log-line ${lvl}` }, line || ' '));
-  }
-  content.replaceChildren(el('h2', { class: 'page-title' }, label), el('div', { class: 'log-box' }, view));
-  // follow the tail — scroll to the newest line
-  requestAnimationFrame(() => { const b = content.querySelector('.log-box'); if (b) b.scrollTop = b.scrollHeight; });
-}
-
-// ---- Files (doc viewer) ----
-
-function renderDocs() {
-  const coll = activeCollection();
-  const content = $('content');
-  if (!coll) { content.replaceChildren(el('div', { class: 'empty' }, 'No documents.')); return; }
-  if (!coll.files.length) { content.replaceChildren(el('div', { class: 'empty' }, `No ${coll.label.toLowerCase()}.`)); return; }
-  // display name: drop the group prefix, the `/SKILL.md` tail (show the skill
-  // dir), and the .md extension — leaving e.g. "meeting-tagger" or "2026-06-13-…"
-  const itemName = (label) => {
-    let n = label.includes('/') ? label.split('/').slice(1).join('/').trim() : label;
-    return n.replace(/\/SKILL\.md$/, '').replace(/\.md$/, '') || label;
-  };
-  const newestFirst = coll.name === 'conversations';
-  const groups = new Map();
-  for (const f of coll.files) { if (!groups.has(f.group)) groups.set(f.group, []); groups.get(f.group).push(f); }
-  const toggleGroup = (g) => {
-    state.openDocGroups.has(g) ? state.openDocGroups.delete(g) : state.openDocGroups.add(g);
-    state.renderedSig = null; render();
-  };
-  const list = el('div', { class: 'doc-list' });
-  for (const [group, files] of groups) {
-    const open = state.openDocGroups.has(group);
-    list.append(el('button', { class: 'doc-group-toggle' + (open ? ' open' : ''), onclick: () => toggleGroup(group) }, [
-      el('span', { class: 'chev' }, open ? '▾' : '▸'),
-      el('span', { class: 'g-name' }, group || '—'),
-      el('span', { class: 'g-count' }, String(files.length)),
-    ]));
-    if (open) {
-      const ordered = newestFirst ? [...files].reverse() : files;
-      for (const f of ordered) {
-        list.append(el('button', { class: 'doc-item' + (f.path === state.activeDocPath ? ' active' : ''), title: f.path, onclick: () => openDoc(coll.name, f.path) }, itemName(f.label) || f.path));
-      }
-    }
-  }
-  const pane = el('div', { class: 'doc-content' });
-  const cached = state.activeDocPath ? state.docCache.get(`${coll.name}\0${state.activeDocPath}`) : null;
-  if (!state.activeDocPath) pane.append(el('div', { class: 'empty' }, 'Select a document.'));
-  else if (!cached) pane.append(el('div', { class: 'empty' }, 'Loading…'));
-  else if (cached.lang === 'error') pane.append(el('div', { class: 'tab-error' }, cached.content));
-  else if (cached.lang === 'json') {
-    let pretty = cached.content;
-    try { pretty = JSON.stringify(JSON.parse(cached.content), null, 2); } catch { /* keep raw */ }
-    pane.append(el('pre', { class: 'code json' }, pretty));
-  } else if (cached.lang === 'markdown') {
-    const md = el('div', { class: 'markdown' }); md.innerHTML = mdToHtml(cached.content); pane.append(md);
-  } else pane.append(el('pre', { class: 'code' }, cached.content));
-  content.replaceChildren(el('h2', { class: 'page-title' }, coll.label), el('div', { class: 'doc-viewer' }, [list, pane]));
-}
-
-// ---- resource table ----
-
-function renderTable(cliName, resource) {
-  const content = $('content');
-  const cli = state.clis.find((c) => c.name === cliName);
-  if (!cli) { content.replaceChildren(el('div', { class: 'empty' }, 'No such CLI.')); return; }
-  const key = `${cliName}/${resource}`;
-  const snapshot = state.snapshots.get(key);
-  const error = state.errors.get(key);
-  const canDrill = (cli.commands || []).includes('get');
-  const parts = [el('h2', { class: 'page-title' }, resource)];
-  if (cli.help) parts.push(helpPanel(state.helpCache.get(key)));
-  if (error && snapshot) parts.push(el('div', { class: 'stale-note' }, `⚠ live fetch failing — snapshot from ${new Date(snapshot.fetchedAt).toLocaleTimeString()}`));
-  if (!snapshot) {
-    parts.push(error ? el('div', { class: 'tab-error' }, [`Failed to load ${resource}.`, el('pre', {}, error)]) : el('div', { class: 'empty' }, 'Loading…'));
-    content.replaceChildren(...parts); return;
-  }
-  const rows = snapshot.rows;
-  parts.push(summaryBar(resource, rows, cli.summary?.[resource], cli));
-  if (rows.length === 0) { parts.push(el('div', { class: 'empty' }, `No ${resource}.`)); content.replaceChildren(...parts); return; }
-  const columns = [];
-  for (const row of rows) for (const k of Object.keys(row)) if (!columns.includes(k)) columns.push(k);
-  const ctx = { cliName, enrich: cli.enrich?.[resource], badges: cli.badges };
-  const body = rows.map((row) => {
-    const id = row.id; const canRow = canDrill && id != null;
-    return el('tr', { class: canRow ? 'drillable' : '', ...(canRow ? { onclick: () => openDetail(cliName, resource, String(id)) } : {}) },
-      columns.map((c) => buildCell(row[c], c, ctx)));
-  });
-  parts.push(el('div', { class: 'table-wrap' }, el('table', {}, [
-    el('thead', {}, el('tr', {}, columns.map((c) => el('th', {}, c)))),
-    el('tbody', {}, body),
-  ])));
-  content.replaceChildren(...parts);
-}
-
-// ---- drill-down detail overlay ----
-
-function renderDetail() {
-  const overlay = $('detail');
-  if (!state.detail) { overlay.hidden = true; overlay.replaceChildren(); return; }
-  overlay.hidden = false;
-  const d = state.detail;
-  const panel = el('div', { class: 'detail-panel' });
-  panel.append(el('div', { class: 'detail-head' }, [
-    el('div', {}, [el('span', { class: 'detail-res' }, d.resource), ' ', el('span', { class: 'detail-id' }, d.id)]),
-    el('button', { class: 'detail-close', onclick: closeDetail, title: 'Close' }, '✕'),
-  ]));
-  const sub = el('div', { class: 'detail-body' });
-  if (d.loading) sub.append(el('div', { class: 'empty' }, 'Loading…'));
-  else if (d.error) sub.append(el('div', { class: 'tab-error' }, d.error));
-  else if (d.record) sub.append(el('div', { class: 'kv' }, kvRows(d.record)));
-  if (d.config) {
-    sub.append(el('div', { class: 'detail-section' }, 'Container config'));
-    sub.append(el('div', { class: 'kv' }, kvRows(d.config)));
-  }
-  panel.append(sub);
-  overlay.replaceChildren(panel);
-}
-
-// ---------------------------------------------------------------- boot
-
-$('pause').addEventListener('click', () => {
-  state.paused = !state.paused;
-  $('pause').textContent = state.paused ? '▶ resume' : '⏸ pause';
-  $('pause').classList.toggle('paused', state.paused);
-  state.renderedSig = null; render();
-});
-$('refresh').addEventListener('click', () => { if (!state.refreshing) refresh(true); });
-$('hamburger').addEventListener('click', () => { state.sidebarOpen = !state.sidebarOpen; state.renderedSig = null; render(); });
-$('scrim').addEventListener('click', () => { state.sidebarOpen = false; state.renderedSig = null; render(); });
-$('detail').addEventListener('click', (e) => { if (e.target === $('detail')) closeDetail(); });
-document.addEventListener('keydown', (e) => { if (e.key === 'Escape') { if (state.detail) closeDetail(); else if (state.sidebarOpen) { state.sidebarOpen = false; state.renderedSig = null; render(); } } });
-
-async function tick() {
-  if (!state.paused) { try { await refresh(); } catch { /* keep snapshots; retry next tick */ } }
-  else renderControls();
-  setTimeout(tick, state.refreshSeconds * 1000);
-}
-tick();

.claude/skills/add-clidash/add/tools/clidash/public/favicon.svg

@@ -1,11 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 32 32">
-  <defs>
-    <linearGradient id="bg" x1="0" y1="0" x2="0" y2="1">
-      <stop offset="0" stop-color="#141a24"/>
-      <stop offset="1" stop-color="#0b0e14"/>
-    </linearGradient>
-  </defs>
-  <rect width="32" height="32" rx="7.5" fill="url(#bg)"/>
-  <rect x="0.5" y="0.5" width="31" height="31" rx="7" fill="none" stroke="#2b3342" stroke-width="1"/>
-  <text x="16.2" y="20.8" font-family="monospace" font-size="15" font-weight="700" letter-spacing="-0.5" text-anchor="middle" fill="#5b9dff">ncl</text>
-</svg>

.claude/skills/add-clidash/add/tools/clidash/public/index.html

@@ -1,45 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-<head>
-  <meta charset="UTF-8">
-  <meta name="viewport" content="width=device-width, initial-scale=1.0">
-  <title>clidash</title>
-  <link rel="icon" type="image/svg+xml" href="/favicon.svg">
-  <link rel="icon" type="image/x-icon" href="/favicon.ico">
-  <link rel="apple-touch-icon" sizes="180x180" href="/apple-touch-icon.png">
-  <link rel="manifest" href="/site.webmanifest">
-  <meta name="theme-color" content="#0a0c11">
-  <link rel="preconnect" href="https://fonts.googleapis.com">
-  <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
-  <link href="https://fonts.googleapis.com/css2?family=IBM+Plex+Mono:wght@400;500;600&family=IBM+Plex+Sans:wght@400;500;600;700&display=swap" rel="stylesheet">
-  <link rel="stylesheet" href="style.css">
-</head>
-<body>
-  <button id="hamburger" class="hamburger" title="Menu" aria-label="Toggle menu">
-    <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round"><line x1="4" x2="20" y1="6" y2="6"/><line x1="4" x2="20" y1="12" y2="12"/><line x1="4" x2="20" y1="18" y2="18"/></svg>
-  </button>
-  <div id="scrim" class="scrim" hidden></div>
-
-  <div class="app">
-    <aside id="sidebar" class="sidebar">
-      <div class="brand"><h1>clidash</h1></div>
-      <div class="controls">
-        <button id="refresh" class="refresh" title="Refresh now">↻ refresh</button>
-        <button id="pause" class="pause" title="Pause auto-refresh">⏸ pause</button>
-      </div>
-      <div id="updated" class="updated"></div>
-      <nav id="nav" class="nav"></nav>
-    </aside>
-
-    <main class="main">
-      <div id="banner" class="banner" hidden></div>
-      <div id="cmdline" class="cmdline" hidden></div>
-      <section id="content" class="content"></section>
-    </main>
-  </div>
-
-  <div id="detail" class="detail-overlay" hidden></div>
-
-  <script type="module" src="app.js"></script>
-</body>
-</html>

.claude/skills/add-clidash/add/tools/clidash/public/md.js

@@ -1,68 +0,0 @@
-// Minimal, dependency-free, XSS-safe markdown → HTML for clidash's file viewer
-// (SKILL.md / CLAUDE.md). Pure string functions, no DOM — importable in both the
-// browser (app.js) and node tests.
-//
-// Safety model: the ENTIRE source is HTML-escaped first, so no raw markup from a
-// file can reach innerHTML. Markdown transforms then emit only tags this module
-// generates. Link hrefs are taken from the URL capture group and gated to an
-// http(s) scheme, so a `javascript:`/`data:` URL (or one smuggled via link text)
-// can never become an executable href.
-
-export function escapeHtml(s) {
-  return String(s).replace(/[&<>"']/g, (c) => (
-    { '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' }[c]
-  ));
-}
-
-export function mdToHtml(src) {
-  const lines = escapeHtml(src).split('\n');
-  const out = [];
-  let i = 0;
-  const inline = (t) => t
-    .replace(/`([^`]+)`/g, '<code>$1</code>')
-    .replace(/\*\*([^*]+)\*\*/g, '<strong>$1</strong>')
-    .replace(/\*([^*]+)\*/g, '<em>$1</em>')
-    .replace(/\[([^\]]+)\]\((https?:[^)\s]+)\)/g, (m, text, url) =>
-      /^https?:\/\//i.test(url) ? `<a href="${url}" target="_blank" rel="noopener noreferrer">${text}</a>` : m);
-  while (i < lines.length) {
-    const line = lines[i];
-    if (/^```/.test(line)) {
-      const buf = [];
-      i++;
-      while (i < lines.length && !/^```/.test(lines[i])) buf.push(lines[i++]);
-      i++;
-      out.push(`<pre class="code"><code>${buf.join('\n')}</code></pre>`);
-      continue;
-    }
-    const h = line.match(/^(#{1,6})\s+(.*)$/);
-    if (h) { out.push(`<h${h[1].length}>${inline(h[2])}</h${h[1].length}>`); i++; continue; }
-    if (/^\s*([-*])\s+/.test(line)) {
-      const items = [];
-      while (i < lines.length && /^\s*([-*])\s+/.test(lines[i])) {
-        items.push(`<li>${inline(lines[i].replace(/^\s*([-*])\s+/, ''))}</li>`);
-        i++;
-      }
-      out.push(`<ul>${items.join('')}</ul>`);
-      continue;
-    }
-    if (/^\s*\d+\.\s+/.test(line)) {
-      const items = [];
-      while (i < lines.length && /^\s*\d+\.\s+/.test(lines[i])) {
-        items.push(`<li>${inline(lines[i].replace(/^\s*\d+\.\s+/, ''))}</li>`);
-        i++;
-      }
-      out.push(`<ol>${items.join('')}</ol>`);
-      continue;
-    }
-    if (/^\s*(---+|\*\*\*+)\s*$/.test(line)) { out.push('<hr>'); i++; continue; }
-    if (/^\s*>\s?/.test(line)) { out.push(`<blockquote>${inline(line.replace(/^\s*>\s?/, ''))}</blockquote>`); i++; continue; }
-    if (line.trim() === '') { i++; continue; }
-    const para = [line];
-    i++;
-    while (i < lines.length && lines[i].trim() !== '' && !/^(#{1,6}\s|```|\s*[-*]\s|\s*\d+\.\s|\s*>)/.test(lines[i])) {
-      para.push(lines[i++]);
-    }
-    out.push(`<p>${inline(para.join(' '))}</p>`);
-  }
-  return out.join('\n');
-}

.claude/skills/add-clidash/add/tools/clidash/public/site.webmanifest

@@ -1,11 +0,0 @@
-{
-  "name": "clidash",
-  "short_name": "ncl",
-  "icons": [
-    { "src": "/icon-192.png", "sizes": "192x192", "type": "image/png" },
-    { "src": "/icon-512.png", "sizes": "512x512", "type": "image/png" }
-  ],
-  "theme_color": "#0a0c11",
-  "background_color": "#0a0c11",
-  "display": "standalone"
-}

.claude/skills/add-clidash/add/tools/clidash/public/style.css

@@ -1,328 +0,0 @@
-/* clidash — refined terminal-ops console.
-   IBM Plex superfamily (Sans for UI, Mono for the CLI identity), a deep layered
-   dark palette, real depth, and precise micro-interactions. */
-
-:root {
-  /* layered surfaces */
-  --bg: #0a0c11;
-  --bg-grad: #10141d;
-  --panel: #13171f;
-  --panel-2: #1a1f2a;
-  --border: #222834;
-  --border-strong: #2e3644;
-  /* text */
-  --text: #e8edf5;
-  --dim: #98a2b3;
-  --faint: #5c6675;
-  /* accent + semantics */
-  --accent: #5b9dff;
-  --accent-soft: rgba(91, 157, 255, 0.14);
-  --green: #4cc97a;
-  --amber: #e0a93a;
-  --red: #f76d6d;
-  --purple: #c08cff;
-  --gray: #6b7585;
-  /* shape + motion */
-  --radius: 11px;
-  --radius-sm: 8px;
-  --shadow-sm: 0 1px 2px rgba(0, 0, 0, 0.35);
-  --shadow: 0 6px 22px -8px rgba(0, 0, 0, 0.5);
-  --shadow-lg: 0 18px 44px -12px rgba(0, 0, 0, 0.6);
-  --ease: 160ms cubic-bezier(0.2, 0.6, 0.2, 1);
-  --font-sans: "IBM Plex Sans", -apple-system, system-ui, Segoe UI, sans-serif;
-  --font-mono: "IBM Plex Mono", ui-monospace, "SF Mono", Menlo, monospace;
-}
-
-* { box-sizing: border-box; margin: 0; padding: 0; }
-[hidden] { display: none !important; }
-
-html { scrollbar-color: var(--border-strong) transparent; }
-body {
-  background:
-    radial-gradient(120% 80% at 50% -10%, var(--bg-grad) 0%, transparent 55%),
-    var(--bg);
-  background-attachment: fixed;
-  color: var(--text);
-  font-family: var(--font-sans);
-  font-size: 14px;
-  line-height: 1.5;
-  -webkit-text-size-adjust: 100%;
-  -webkit-font-smoothing: antialiased;
-}
-
-::selection { background: var(--accent-soft); }
-:focus-visible { outline: 2px solid var(--accent); outline-offset: 2px; border-radius: 4px; }
-
-h1 {
-  font-family: var(--font-mono); font-size: 17px; font-weight: 600;
-  letter-spacing: -0.3px; color: var(--text);
-}
-h1::before { content: "▍"; color: var(--accent); margin-right: 4px; }
-
-/* ---- layout ---- */
-
-.app { display: flex; align-items: stretch; min-height: 100vh; min-height: 100dvh; }
-
-.sidebar {
-  width: 236px; flex-shrink: 0; height: 100vh; height: 100dvh;
-  position: sticky; top: 0; align-self: flex-start; overflow-y: auto;
-  background: linear-gradient(180deg, rgba(255, 255, 255, 0.015), transparent 200px), var(--bg);
-  border-right: 1px solid var(--border);
-  padding: 18px 12px 40px; display: flex; flex-direction: column; gap: 10px;
-}
-.sidebar .brand { padding: 2px 8px 6px; }
-.sidebar .controls { display: flex; gap: 8px; padding: 0 4px; }
-.sidebar .updated { color: var(--faint); font-size: 11.5px; padding: 0 8px; min-height: 16px; font-family: var(--font-mono); }
-
-.pause, .refresh {
-  flex: 1; background: var(--panel); border: 1px solid var(--border); border-radius: var(--radius-sm);
-  color: var(--dim); padding: 6px 10px; font-size: 12.5px; font-family: var(--font-mono);
-  cursor: pointer; transition: color var(--ease), border-color var(--ease), background var(--ease);
-}
-.pause:hover, .refresh:hover { color: var(--text); border-color: var(--border-strong); background: var(--panel-2); }
-.pause.paused { color: var(--amber); border-color: var(--amber); }
-.refresh.spinning { color: var(--accent); border-color: var(--accent); animation: pulse 0.85s ease-in-out infinite; }
-@keyframes pulse { 50% { opacity: 0.5; } }
-
-.nav { display: flex; flex-direction: column; gap: 1px; margin-top: 6px; }
-.nav-section {
-  color: var(--faint); font-size: 10.5px; text-transform: uppercase; letter-spacing: 1px;
-  font-weight: 600; margin: 16px 10px 5px; font-family: var(--font-mono);
-  display: flex; align-items: center; gap: 7px;
-}
-.nav-section svg { width: 13px; height: 13px; opacity: 0.7; }
-.nav-item {
-  display: flex; align-items: center; gap: 9px; text-align: left;
-  background: none; border: none; border-radius: var(--radius-sm);
-  color: var(--dim); padding: 7px 10px; font-size: 13.5px; cursor: pointer; width: 100%;
-  font-family: var(--font-sans); position: relative;
-  transition: color var(--ease), background var(--ease);
-}
-.nav-item svg { width: 16px; height: 16px; flex-shrink: 0; opacity: 0.85; }
-.nav-item:hover { background: var(--panel); color: var(--text); }
-.nav-item.active { background: var(--accent-soft); color: var(--text); }
-.nav-item.active::before {
-  content: ""; position: absolute; left: -12px; top: 50%; transform: translateY(-50%);
-  width: 3px; height: 18px; background: var(--accent); border-radius: 0 3px 3px 0;
-}
-.nav-item.nav-sub { padding-left: 16px; font-size: 13px; }
-.nav-item.nav-sub.active { color: var(--accent); }
-
-.hamburger {
-  display: none; position: fixed; top: 12px; left: 12px; z-index: 60;
-  background: var(--panel); border: 1px solid var(--border); border-radius: var(--radius-sm);
-  color: var(--text); width: 40px; height: 40px; cursor: pointer; align-items: center; justify-content: center;
-}
-.hamburger svg { width: 20px; height: 20px; }
-.scrim { display: none; }
-
-.main { flex: 1; min-width: 0; padding: 26px 28px 64px; max-width: 1500px; }
-.page-title {
-  font-size: 20px; font-weight: 600; letter-spacing: -0.4px; margin-bottom: 16px;
-  animation: fadeUp 0.3s var(--ease) both;
-}
-
-.banner {
-  background: rgba(247, 109, 109, 0.1); border: 1px solid rgba(247, 109, 109, 0.4);
-  border-radius: var(--radius-sm); color: var(--red); padding: 9px 14px; font-size: 13.5px; margin-bottom: 16px;
-}
-.cmdline {
-  font-family: var(--font-mono); font-size: 12px; color: var(--dim);
-  background: var(--panel); border: 1px solid var(--border); border-radius: var(--radius-sm);
-  padding: 9px 14px; margin-bottom: 18px; overflow-x: auto; white-space: nowrap; box-shadow: var(--shadow-sm);
-}
-.cmdline::first-letter { color: var(--green); }
-
-@keyframes fadeUp { from { opacity: 0; transform: translateY(7px); } }
-
-/* ---- overview cards ---- */
-
-.ov-cards { display: grid; grid-template-columns: repeat(auto-fill, minmax(310px, 1fr)); gap: 16px; }
-.ov-card {
-  background: linear-gradient(180deg, rgba(255, 255, 255, 0.018), transparent 40%), var(--panel);
-  border: 1px solid var(--border); border-radius: var(--radius); padding: 17px 19px;
-  box-shadow: var(--shadow); transition: border-color var(--ease), transform var(--ease);
-  animation: fadeUp 0.4s var(--ease) both;
-}
-.ov-card:nth-child(2) { animation-delay: 0.05s; }
-.ov-card:nth-child(3) { animation-delay: 0.1s; }
-.ov-card:nth-child(4) { animation-delay: 0.15s; }
-.ov-card:hover { border-color: var(--border-strong); transform: translateY(-2px); }
-.ov-head { display: flex; align-items: center; gap: 9px; margin-bottom: 14px; }
-.ov-head .ov-name { font-weight: 600; font-size: 15px; }
-.ov-head .ov-folder { color: var(--faint); font-size: 12px; font-family: var(--font-mono); }
-.ov-fields { display: flex; flex-direction: column; gap: 7px; }
-.ov-field { display: flex; justify-content: space-between; align-items: center; font-size: 13px; }
-.ov-field .k { color: var(--dim); }
-.ov-field .v { color: var(--text); font-variant-numeric: tabular-nums; } .ov-field .v.dim { color: var(--faint); }
-.ov-chans { display: flex; flex-wrap: wrap; gap: 6px; margin-top: 14px; }
-
-.dot, .ov-head .dot { width: 9px; height: 9px; border-radius: 50%; flex-shrink: 0; }
-.dot.green { background: var(--green); box-shadow: 0 0 8px -1px var(--green); }
-.dot.amber { background: var(--amber); box-shadow: 0 0 8px -1px var(--amber); }
-.dot.red { background: var(--red); box-shadow: 0 0 8px -1px var(--red); }
-.dot.gray { background: var(--gray); }
-
-.badge {
-  font-size: 11.5px; border: 1px solid var(--border-strong); border-radius: 99px;
-  padding: 2px 10px; color: var(--dim); background: var(--panel-2); font-family: var(--font-mono);
-}
-
-/* ---- status badges + enriched cells ---- */
-.badge-status { display: inline-flex; align-items: center; gap: 6px; font-size: 12.5px; }
-.badge-status .dot { width: 7px; height: 7px; }
-.badge-status.green { color: var(--green); } .badge-status.amber { color: var(--amber); }
-.badge-status.red { color: var(--red); } .badge-status.gray { color: var(--gray); }
-td.enriched span:first-child { color: var(--text); }
-td.enriched .raw-id { display: block; color: var(--faint); font-size: 11px; font-family: var(--font-mono); }
-
-/* ---- summary bar ---- */
-.summary-bar { display: flex; align-items: center; flex-wrap: wrap; gap: 8px; margin: 2px 0 16px; font-size: 13px; }
-.summary-bar .sum-count { color: var(--text); font-weight: 600; }
-.summary-bar .sum-sep { color: var(--border-strong); }
-.summary-bar .sum-chip { color: var(--dim); font-family: var(--font-mono); font-size: 12px; }
-
-/* ---- per-resource help panel ---- */
-.help-panel { margin-bottom: 18px; background: var(--panel); border: 1px solid var(--border); border-radius: var(--radius); padding: 13px 16px; box-shadow: var(--shadow-sm); }
-.help-head { color: var(--dim); font-size: 13px; line-height: 1.6; }
-.help-head.dim { color: var(--faint); }
-.help-more { margin-top: 9px; }
-.help-more > summary { cursor: pointer; color: var(--accent); font-size: 12px; list-style: none; user-select: none; font-family: var(--font-mono); }
-.help-more > summary::-webkit-details-marker { display: none; }
-.help-more > summary::before { content: "▸ "; }
-.help-more[open] > summary::before { content: "▾ "; }
-.help-text {
-  margin: 9px 0 0; background: var(--bg); border: 1px solid var(--border); border-radius: var(--radius-sm);
-  padding: 13px 15px; font-size: 12px; line-height: 1.6; color: var(--dim);
-  white-space: pre-wrap; overflow-x: auto; font-family: var(--font-mono);
-}
-
-/* ---- document viewer ---- */
-.doc-viewer { display: grid; grid-template-columns: 264px 1fr; gap: 20px; align-items: start; }
-.doc-list { display: flex; flex-direction: column; gap: 2px; max-height: 76vh; overflow-y: auto; padding-right: 4px; }
-.doc-group-toggle {
-  flex-shrink: 0; display: flex; align-items: center; gap: 7px; width: 100%;
-  background: none; border: none; cursor: pointer; text-align: left;
-  color: var(--dim); font-size: 11px; text-transform: uppercase; letter-spacing: 1px;
-  font-weight: 600; font-family: var(--font-mono); margin: 12px 0 4px; padding: 5px 8px;
-  border-radius: var(--radius-sm); transition: color var(--ease), background var(--ease);
-}
-.doc-group-toggle:first-child { margin-top: 0; }
-.doc-group-toggle:hover { color: var(--text); background: var(--panel); }
-.doc-group-toggle.open { color: var(--text); }
-.doc-group-toggle .chev { color: var(--accent); width: 10px; }
-.doc-group-toggle .g-name { flex: 1; }
-.doc-group-toggle .g-count {
-  color: var(--faint); background: var(--panel-2); border-radius: 99px;
-  padding: 1px 8px; font-size: 10.5px; letter-spacing: 0;
-}
-.doc-item {
-  flex-shrink: 0; text-align: left; background: none; border: none; border-radius: var(--radius-sm);
-  color: var(--dim); padding: 6px 11px; font-size: 13px; line-height: 1.5; cursor: pointer;
-  white-space: nowrap; overflow: hidden; text-overflow: ellipsis; transition: color var(--ease), background var(--ease);
-}
-.doc-item:hover { background: var(--panel); color: var(--text); }
-.doc-item.active { background: var(--accent-soft); color: var(--accent); }
-.doc-content {
-  background: var(--panel); border: 1px solid var(--border); border-radius: var(--radius);
-  padding: 22px 26px; min-height: 220px; max-height: 78vh; overflow-y: auto; box-shadow: var(--shadow);
-}
-
-.markdown { font-size: 14px; line-height: 1.7; color: var(--text); }
-.markdown h1, .markdown h2, .markdown h3, .markdown h4 { margin: 20px 0 8px; line-height: 1.3; font-family: var(--font-mono); }
-.markdown h1 { font-size: 21px; } .markdown h2 { font-size: 17px; color: var(--accent); } .markdown h3 { font-size: 15px; }
-.markdown h1:first-child, .markdown h2:first-child { margin-top: 0; }
-.markdown p { color: var(--text); margin: 8px 0; }
-.markdown ul, .markdown ol { margin: 8px 0 8px 22px; }
-.markdown li { margin: 3px 0; }
-.markdown a { color: var(--accent); }
-.markdown hr { border: none; border-top: 1px solid var(--border); margin: 18px 0; }
-.markdown blockquote { border-left: 3px solid var(--border-strong); padding-left: 12px; color: var(--dim); margin: 8px 0; }
-.markdown code { background: var(--bg); border: 1px solid var(--border); border-radius: 5px; padding: 1px 6px; font-size: 12.5px; font-family: var(--font-mono); }
-.markdown pre.code, .doc-content pre.code {
-  background: var(--bg); border: 1px solid var(--border); border-radius: var(--radius-sm);
-  padding: 14px; overflow-x: auto; font-size: 12.5px; line-height: 1.6; margin: 12px 0; font-family: var(--font-mono);
-}
-.markdown pre.code code { background: none; border: none; padding: 0; }
-.doc-content pre.json { color: var(--text); white-space: pre; font-family: var(--font-mono); }
-
-/* ---- activity ---- */
-.activity-wrap { max-width: 780px; }
-.activity-legend { display: flex; gap: 18px; align-items: center; margin-bottom: 12px; font-size: 13px; color: var(--dim); }
-.activity-legend .lg { display: inline-block; width: 11px; height: 11px; border-radius: 3px; margin-right: 6px; vertical-align: -1px; }
-.activity-legend .lg.in { background: var(--accent); } .activity-legend .lg.out { background: var(--purple); }
-.chart-box { background: var(--panel); border: 1px solid var(--border); border-radius: var(--radius); padding: 16px; margin-bottom: 20px; box-shadow: var(--shadow); }
-.activity-chart { width: 100%; height: 220px; display: block; }
-.activity-chart .bar-in { fill: var(--accent); } .activity-chart .bar-out { fill: var(--purple); }
-.activity-chart .grid { stroke: var(--border); stroke-width: 1; }
-.activity-chart .axis { fill: var(--faint); font-size: 9px; font-family: var(--font-mono); }
-.activity-table td.num, .activity-table th:nth-child(3), .activity-table th:nth-child(4) { text-align: right; }
-.activity-table td.num { font-variant-numeric: tabular-nums; }
-
-/* ---- log viewer ---- */
-.log-box {
-  background: var(--bg); border: 1px solid var(--border); border-radius: var(--radius);
-  max-height: 78vh; overflow: auto; padding: 12px 0; box-shadow: var(--shadow);
-}
-.log-view { font-family: var(--font-mono); font-size: 12px; line-height: 1.65; min-width: max-content; }
-.log-line { padding: 0 16px; white-space: pre; color: var(--dim); }
-.log-line:hover { background: var(--panel); }
-.log-line.err { color: var(--red); background: rgba(247, 109, 109, 0.06); }
-.log-line.warn { color: var(--amber); }
-
-/* ---- tables ---- */
-.table-wrap { overflow-x: auto; -webkit-overflow-scrolling: touch; border: 1px solid var(--border); border-radius: var(--radius); box-shadow: var(--shadow-sm); }
-table { border-collapse: collapse; width: 100%; font-size: 13px; }
-th, td { text-align: left; padding: 9px 14px; border-bottom: 1px solid var(--border); white-space: nowrap; }
-tbody tr:last-child td { border-bottom: none; }
-th { color: var(--dim); font-weight: 600; font-size: 10.5px; text-transform: uppercase; letter-spacing: 0.6px; position: sticky; top: 0; background: var(--panel-2); font-family: var(--font-mono); }
-td { font-variant-numeric: tabular-nums; }
-td.null { color: var(--faint); font-style: italic; }
-tr.drillable { cursor: pointer; transition: background var(--ease); }
-tr.drillable:hover td { background: var(--panel); }
-.reltime .abs { color: var(--faint); font-size: 11.5px; margin-left: 6px; font-family: var(--font-mono); }
-td .trunc { cursor: pointer; border-bottom: 1px dotted var(--faint); }
-.stale-note { color: var(--amber); font-size: 12.5px; margin-bottom: 8px; }
-.empty, .tab-error { color: var(--dim); padding: 26px 2px; font-size: 14px; }
-.tab-error { color: var(--red); }
-.tab-error pre { margin-top: 10px; background: var(--panel); border: 1px solid var(--border); border-radius: var(--radius-sm); padding: 12px; color: var(--dim); font-size: 12px; overflow-x: auto; white-space: pre-wrap; font-family: var(--font-mono); }
-
-/* ---- drill-down detail overlay ---- */
-.detail-overlay { position: fixed; inset: 0; background: rgba(2, 4, 8, 0.62); display: flex; justify-content: flex-end; z-index: 50; backdrop-filter: blur(2px); animation: fade 0.18s ease; }
-@keyframes fade { from { opacity: 0; } }
-.detail-panel { width: min(580px, 100%); height: 100%; background: var(--bg); border-left: 1px solid var(--border-strong); overflow-y: auto; box-shadow: var(--shadow-lg); animation: slideIn 0.22s var(--ease); }
-@keyframes slideIn { from { transform: translateX(24px); opacity: 0.6; } }
-.detail-head { display: flex; justify-content: space-between; align-items: center; padding: 17px 22px; border-bottom: 1px solid var(--border); position: sticky; top: 0; background: var(--bg); }
-.detail-res { font-weight: 600; font-size: 15px; }
-.detail-id { color: var(--dim); font-family: var(--font-mono); font-size: 13px; }
-.detail-close { background: none; border: 1px solid var(--border); border-radius: var(--radius-sm); color: var(--dim); width: 30px; height: 30px; cursor: pointer; font-size: 14px; transition: color var(--ease), border-color var(--ease); }
-.detail-close:hover { color: var(--text); border-color: var(--accent); }
-.detail-body { padding: 17px 22px 44px; }
-.detail-section { margin: 24px 0 8px; color: var(--faint); font-size: 10.5px; text-transform: uppercase; letter-spacing: 1px; font-weight: 600; border-top: 1px solid var(--border); padding-top: 17px; font-family: var(--font-mono); }
-.kv { display: flex; flex-direction: column; gap: 2px; }
-.kv-row { display: grid; grid-template-columns: 168px 1fr; gap: 12px; padding: 6px 0; border-bottom: 1px solid var(--border); font-size: 13px; }
-.kv-key { color: var(--dim); font-family: var(--font-mono); font-size: 12.5px; }
-.kv-json { background: var(--panel); border: 1px solid var(--border); border-radius: 6px; padding: 8px 10px; font-size: 12px; overflow-x: auto; margin: 0; font-family: var(--font-mono); }
-
-/* ---- mobile ---- */
-@media (max-width: 640px) {
-  .hamburger { display: flex; }
-  .sidebar {
-    position: fixed; top: 0; left: 0; z-index: 70; transform: translateX(-100%);
-    transition: transform 0.22s var(--ease); box-shadow: var(--shadow-lg);
-  }
-  .sidebar.open { transform: translateX(0); }
-  .scrim { display: block; position: fixed; inset: 0; background: rgba(2, 4, 8, 0.55); z-index: 65; backdrop-filter: blur(1px); }
-  .scrim[hidden] { display: none; }
-  .main { padding: 58px 16px 48px; }
-  .ov-cards { grid-template-columns: 1fr; }
-  .doc-viewer { grid-template-columns: 1fr; gap: 12px; }
-  .doc-list { max-height: 220px; flex-direction: row; flex-wrap: wrap; }
-  .doc-content { max-height: none; padding: 18px; }
-  .detail-panel { width: 100%; }
-  .kv-row { grid-template-columns: 1fr; gap: 2px; }
-}
-
-@media (prefers-reduced-motion: reduce) {
-  *, *::before, *::after { animation: none !important; transition: none !important; }
-}

.claude/skills/add-clidash/add/tools/clidash/server.js

@@ -1,437 +0,0 @@
-// clidash — CLI-agnostic read-only web dashboard.
-// Node built-ins only. All per-CLI knowledge lives in clidash.config.json;
-// the only per-CLI code is optional view plugins (views/) and discovery
-// parsers (parsers.js).
-//
-// Security model: the server can only exec the configured argv templates.
-// `{resource}` is the sole substitution and is validated against the
-// discovered/static resource set before exec. execFile, never a shell.
-
-import { createServer } from 'node:http';
-import { execFile } from 'node:child_process';
-import { readFile, readdir } from 'node:fs/promises';
-import { readFileSync } from 'node:fs';
-import { dirname, join, resolve, sep, basename } from 'node:path';
-import { fileURLToPath, pathToFileURL } from 'node:url';
-import { discoveryParsers, parseOutput, unwrapPath } from './parsers.js';
-import { globFiles, describeFile, resolveDoc } from './docs.js';
-import { collectActivity } from './activity.js';
-import { tailFile } from './logs.js';
-
-const MODULE_DIR = dirname(fileURLToPath(import.meta.url));
-const MAX_DOC_BYTES = 2 * 1024 * 1024; // cap a single served document at 2 MB
-
-const DEFAULTS = {
-  bind: '127.0.0.1',
-  port: 4690,
-  refreshSeconds: 60,
-  execTimeoutMs: 10_000,
-  discoveryTtlMs: 60_000,
-};
-
-const CONTENT_TYPES = {
-  '.html': 'text/html; charset=utf-8',
-  '.js': 'text/javascript; charset=utf-8',
-  '.css': 'text/css; charset=utf-8',
-  '.json': 'application/json; charset=utf-8',
-  '.svg': 'image/svg+xml',
-  '.png': 'image/png',
-  '.ico': 'image/x-icon',
-  '.webmanifest': 'application/manifest+json',
-};
-
-export function createApp(userConfig) {
-  const config = { ...DEFAULTS, ...userConfig };
-  const publicDir = resolve(config.publicDir ?? join(MODULE_DIR, 'public'));
-  const viewsDir = resolve(config.viewsDir ?? join(MODULE_DIR, 'views'));
-
-  // Human-readable form of a command, for display in the UI ("the command run").
-  const displayCmd = (bin, args) => `${basename(bin)} ${args.join(' ')}`;
-
-  // ---- exec --------------------------------------------------------------
-
-  function execCli(cliCfg, args, label) {
-    return new Promise((resolvePromise, rejectPromise) => {
-      execFile(cliCfg.bin, args, {
-        cwd: cliCfg.cwd,
-        timeout: config.execTimeoutMs,
-        maxBuffer: 32 * 1024 * 1024,
-        env: { ...process.env, ...cliCfg.env },
-      }, (error, stdout, stderr) => {
-        if (error) {
-          const timedOut = error.killed || error.signal === 'SIGTERM';
-          const detail = stderr.trim() || error.message;
-          const msg = timedOut
-            ? `${label} timed out after ${config.execTimeoutMs}ms`
-            : `${label} failed: ${detail}`;
-          rejectPromise(new Error(msg));
-          return;
-        }
-        resolvePromise(stdout);
-      });
-    });
-  }
-
-  // ---- resource discovery (cached, coalesced, keeps last good) -----------
-
-  const discoveryCache = new Map(); // cli -> { at, resources }
-  const discoveryInflight = new Map(); // cli -> Promise
-
-  async function discoverResources(cliName) {
-    const cliCfg = config.clis[cliName];
-    if (cliCfg.resources) {
-      return cliCfg.resources.map((name) =>
-        typeof name === 'string' ? { name, description: '' } : name,
-      );
-    }
-    const cached = discoveryCache.get(cliName);
-    if (cached && Date.now() - cached.at < config.discoveryTtlMs) return cached.resources;
-    if (discoveryInflight.has(cliName)) return discoveryInflight.get(cliName);
-
-    const parser = discoveryParsers[cliCfg.discover.parser];
-    if (!parser) throw new Error(`Unknown discovery parser: ${cliCfg.discover.parser}`);
-    const promise = execCli(cliCfg, cliCfg.discover.args, `${cliName} discovery`)
-      .then((stdout) => {
-        const resources = parser(stdout);
-        discoveryCache.set(cliName, { at: Date.now(), resources });
-        return resources;
-      })
-      .finally(() => discoveryInflight.delete(cliName));
-    discoveryInflight.set(cliName, promise);
-    return promise;
-  }
-
-  // ---- row fetching (coalesced per cli+resource) --------------------------
-
-  const listInflight = new Map(); // "cli\0resource" -> Promise
-
-  async function fetchRows(cliName, resourceName) {
-    const cliCfg = config.clis[cliName];
-    const resources = await discoverResources(cliName);
-    if (!resources.some((r) => r.name === resourceName)) {
-      const err = new Error(`Unknown resource "${resourceName}" for CLI "${cliName}"`);
-      err.statusCode = 404;
-      throw err;
-    }
-    const key = `${cliName}\0${resourceName}`;
-    if (listInflight.has(key)) return listInflight.get(key);
-
-    // {resource} may appear as a whole arg or inside one (e.g. an ssh remote
-    // command). Safe either way — the value is allowlist-validated above.
-    const args = cliCfg.list.map((a) => a.replaceAll('{resource}', resourceName));
-    const promise = execCli(cliCfg, args, `${cliName} ${resourceName} list`)
-      .then((stdout) => {
-        const parsed = parseOutput(stdout, cliCfg.output ?? 'json');
-        const rows = unwrapPath(parsed, cliCfg.unwrap);
-        if (!Array.isArray(rows)) {
-          const err = new Error(`${cliName} ${resourceName}: expected an array of rows`);
-          err.raw = stdout;
-          throw err;
-        }
-        return rows;
-      })
-      .finally(() => listInflight.delete(key));
-    listInflight.set(key, promise);
-    return promise;
-  }
-
-  // ---- detail commands (drill-down: get, config-get, …) -------------------
-
-  const cmdInflight = new Map();
-  const ID_RE = /^[A-Za-z0-9:_.-]+$/; // ncl ids / uuids; no shell metas (and execFile never shells)
-
-  async function runCommand(cliName, cmdName, resourceName, id) {
-    const cliCfg = config.clis[cliName];
-    const template = cliCfg.commands?.[cmdName];
-    if (!template) {
-      const err = new Error(`Unknown command "${cmdName}"`);
-      err.statusCode = 404;
-      throw err;
-    }
-    const needsResource = template.includes('{resource}');
-    if (needsResource) {
-      const resources = await discoverResources(cliName);
-      if (!resources.some((r) => r.name === resourceName)) {
-        const err = new Error(`Unknown resource "${resourceName}"`);
-        err.statusCode = 404;
-        throw err;
-      }
-    }
-    if (template.includes('{id}') && !ID_RE.test(id ?? '')) {
-      const err = new Error('Invalid id');
-      err.statusCode = 400;
-      throw err;
-    }
-    const key = `${cliName}\0${cmdName}\0${resourceName}\0${id}`;
-    if (cmdInflight.has(key)) return cmdInflight.get(key);
-    const args = template.map((a) => a.replaceAll('{resource}', resourceName ?? '').replaceAll('{id}', id ?? ''));
-    const promise = execCli(cliCfg, args, `${cliName} ${cmdName}`)
-      .then((stdout) => unwrapPath(parseOutput(stdout, cliCfg.output ?? 'json'), cliCfg.unwrap))
-      .finally(() => cmdInflight.delete(key));
-    cmdInflight.set(key, promise);
-    return promise;
-  }
-
-  // ---- per-resource help (raw text from `<cli> <resource> help`) -----------
-
-  const helpInflight = new Map();
-  async function runHelp(cliName, resourceName) {
-    const cliCfg = config.clis[cliName];
-    if (!cliCfg.help) { const e = new Error(`No help for "${cliName}"`); e.statusCode = 404; throw e; }
-    const resources = await discoverResources(cliName);
-    if (!resources.some((r) => r.name === resourceName)) {
-      const e = new Error(`Unknown resource "${resourceName}"`); e.statusCode = 404; throw e;
-    }
-    const key = `${cliName}\0${resourceName}`;
-    if (helpInflight.has(key)) return helpInflight.get(key);
-    const args = cliCfg.help.map((a) => a.replaceAll('{resource}', resourceName));
-    const promise = execCli(cliCfg, args, `${cliName} ${resourceName} help`).finally(() => helpInflight.delete(key));
-    helpInflight.set(key, promise);
-    return promise;
-  }
-
-  // ---- view plugins --------------------------------------------------------
-
-  async function listViews(cliName) {
-    try {
-      const files = await readdir(viewsDir);
-      return files
-        .filter((f) => f.startsWith(`${cliName}-`) && f.endsWith('.js'))
-        .map((f) => f.slice(cliName.length + 1, -3));
-    } catch {
-      return [];
-    }
-  }
-
-  async function runView(cliName, viewName) {
-    if (!/^[a-zA-Z0-9_-]+$/.test(viewName)) {
-      const err = new Error(`Invalid view name`);
-      err.statusCode = 404;
-      throw err;
-    }
-    const file = join(viewsDir, `${cliName}-${viewName}.js`);
-    let mod;
-    try {
-      mod = await import(pathToFileURL(file).href);
-    } catch (e) {
-      if (e.code === 'ERR_MODULE_NOT_FOUND') {
-        const err = new Error(`No view "${viewName}" for CLI "${cliName}"`);
-        err.statusCode = 404;
-        throw err;
-      }
-      throw e;
-    }
-    return mod.default({ fetch: (resource) => fetchRows(cliName, resource) });
-  }
-
-  // ---- http ----------------------------------------------------------------
-
-  function sendJson(res, status, body) {
-    const payload = JSON.stringify(body);
-    res.writeHead(status, { 'Content-Type': 'application/json; charset=utf-8' });
-    res.end(payload);
-  }
-
-  function sendError(res, err) {
-    const status = err.statusCode ?? 502;
-    const body = { ok: false, error: err.message };
-    if (err.raw !== undefined) body.raw = String(err.raw).slice(0, 64 * 1024);
-    sendJson(res, status, body);
-  }
-
-  async function serveStatic(res, urlPath) {
-    const relative = urlPath === '/' ? 'index.html' : decodeURIComponent(urlPath.slice(1));
-    const file = resolve(publicDir, relative);
-    if (file !== publicDir && !file.startsWith(publicDir + sep)) {
-      sendJson(res, 403, { ok: false, error: 'Forbidden' });
-      return;
-    }
-    try {
-      const content = await readFile(file);
-      const ext = file.slice(file.lastIndexOf('.'));
-      // always revalidate so a redeploy is picked up immediately (no stale JS/CSS)
-      res.writeHead(200, { 'Content-Type': CONTENT_TYPES[ext] ?? 'application/octet-stream', 'Cache-Control': 'no-cache' });
-      res.end(content);
-    } catch {
-      sendJson(res, 404, { ok: false, error: 'Not found' });
-    }
-  }
-
-  return createServer(async (req, res) => {
-    try {
-      if (req.method !== 'GET') {
-        sendJson(res, 405, { ok: false, error: 'Read-only dashboard: GET only' });
-        return;
-      }
-      const urlPath = req.url.split('?')[0];
-      const segments = urlPath.split('/').map((s) => decodeURIComponent(s));
-
-      if (urlPath === '/api/clis') {
-        const clis = await Promise.all(Object.keys(config.clis).map(async (name) => {
-          const entry = {
-            name,
-            refreshSeconds: config.refreshSeconds,
-            views: await listViews(name),
-            commands: Object.keys(config.clis[name].commands ?? {}),
-            enrich: config.clis[name].enrich ?? null,
-            badges: config.clis[name].badges ?? null,
-            summary: config.clis[name].summary ?? null,
-            help: !!config.clis[name].help,
-          };
-          try {
-            entry.resources = await discoverResources(name);
-          } catch (e) {
-            // keep last good discovery (≤TTL old) if we have one; always surface the error
-            entry.resources = discoveryCache.get(name)?.resources ?? [];
-            entry.error = e.message;
-          }
-          return entry;
-        }));
-        sendJson(res, 200, { clis });
-        return;
-      }
-
-      if (segments[1] === 'api' && segments[2] === 'r' && segments.length === 5) {
-        const [, , , cliName, resourceName] = segments;
-        if (!config.clis[cliName]) {
-          sendJson(res, 404, { ok: false, error: `Unknown CLI "${cliName}"` });
-          return;
-        }
-        const rows = await fetchRows(cliName, resourceName);
-        const cliCfg = config.clis[cliName];
-        const command = displayCmd(cliCfg.bin, cliCfg.list.map((a) => a.replaceAll('{resource}', resourceName)));
-        sendJson(res, 200, { ok: true, rows, command, fetchedAt: new Date().toISOString() });
-        return;
-      }
-
-      if (segments[1] === 'api' && segments[2] === 'cmd' && segments.length === 5) {
-        const [, , , cliName, cmdName] = segments;
-        if (!config.clis[cliName]) {
-          sendJson(res, 404, { ok: false, error: `Unknown CLI "${cliName}"` });
-          return;
-        }
-        const q = new URL(req.url, 'http://localhost').searchParams;
-        const data = await runCommand(cliName, cmdName, q.get('resource'), q.get('id'));
-        const tmpl = config.clis[cliName].commands?.[cmdName] ?? [];
-        const command = displayCmd(config.clis[cliName].bin,
-          tmpl.map((a) => a.replaceAll('{resource}', q.get('resource') ?? '').replaceAll('{id}', q.get('id') ?? '')));
-        sendJson(res, 200, { ok: true, data, command, fetchedAt: new Date().toISOString() });
-        return;
-      }
-
-      if (segments[1] === 'api' && segments[2] === 'help' && segments.length === 5) {
-        const [, , , cliName, resourceName] = segments;
-        if (!config.clis[cliName]) {
-          sendJson(res, 404, { ok: false, error: `Unknown CLI "${cliName}"` });
-          return;
-        }
-        const text = await runHelp(cliName, resourceName);
-        sendJson(res, 200, { ok: true, text });
-        return;
-      }
-
-      if (segments[1] === 'api' && segments[2] === 'view' && segments.length === 5) {
-        const [, , , cliName, viewName] = segments;
-        if (!config.clis[cliName]) {
-          sendJson(res, 404, { ok: false, error: `Unknown CLI "${cliName}"` });
-          return;
-        }
-        const result = await runView(cliName, viewName);
-        sendJson(res, 200, { ok: true, result, fetchedAt: new Date().toISOString() });
-        return;
-      }
-
-      // Log tails (allowlisted files under logs.dir).
-      if (urlPath === '/api/logs') {
-        sendJson(res, 200, { files: (config.logs?.files ?? []).map((f) => ({ name: f.name, label: f.label ?? f.name })) });
-        return;
-      }
-      if (segments[1] === 'api' && segments[2] === 'log' && segments.length === 4) {
-        const name = segments[3];
-        const file = config.logs?.files?.find((f) => f.name === name);
-        if (!file) { sendJson(res, 404, { ok: false, error: `Unknown log "${name}"` }); return; }
-        const lines = config.logs.tailLines ?? 400;
-        const { text } = await tailFile(join(config.logs.dir, name), lines);
-        sendJson(res, 200, { ok: true, text, command: `tail -n ${lines} ${join(config.logs.dir, name)}`, fetchedAt: new Date().toISOString() });
-        return;
-      }
-
-      // Message activity (read per-session DBs; ncl has no messages resource).
-      if (urlPath === '/api/activity') {
-        if (!config.activity) { sendJson(res, 200, { ok: true, configured: false }); return; }
-        const days = config.activity.days ?? 14;
-        const { sessions, series } = collectActivity(config.activity.sessionsRoot, days, new Date());
-        const command = `node:sqlite · ${config.activity.sessionsRoot}/*/*/{inbound,outbound}.db (last ${days}d)`;
-        sendJson(res, 200, { ok: true, configured: true, sessions, series, command, fetchedAt: new Date().toISOString() });
-        return;
-      }
-
-      // Read-only file viewer (skills, CLAUDE.md, profiles, conversations).
-      if (urlPath === '/api/docs') {
-        const docs = config.docs;
-        const collections = (docs?.collections ?? []).map((coll) => ({
-          name: coll.name,
-          label: coll.label ?? coll.name,
-          lang: coll.lang ?? 'text',
-          files: globFiles(docs.root, coll.patterns, docs.deny ?? []).map((path) => ({
-            path,
-            ...describeFile(path),
-          })),
-        }));
-        sendJson(res, 200, { collections });
-        return;
-      }
-
-      if (urlPath === '/api/doc') {
-        const docs = config.docs;
-        const query = new URL(req.url, 'http://localhost').searchParams;
-        const collName = query.get('c');
-        const relPath = query.get('p') ?? '';
-        const collection = docs?.collections?.find((c) => c.name === collName);
-        if (!collection) {
-          sendJson(res, 404, { ok: false, error: `Unknown collection "${collName}"` });
-          return;
-        }
-        let abs;
-        try {
-          abs = resolveDoc(docs.root, collection, relPath, docs.deny ?? []);
-        } catch {
-          sendJson(res, 404, { ok: false, error: 'Not found' });
-          return;
-        }
-        const content = await readFile(abs, 'utf8');
-        sendJson(res, 200, {
-          ok: true,
-          path: relPath,
-          lang: collection.lang ?? 'text',
-          content: content.length > MAX_DOC_BYTES ? content.slice(0, MAX_DOC_BYTES) : content,
-        });
-        return;
-      }
-
-      if (urlPath.startsWith('/api/')) {
-        sendJson(res, 404, { ok: false, error: 'Not found' });
-        return;
-      }
-
-      await serveStatic(res, urlPath);
-    } catch (err) {
-      sendError(res, err);
-    }
-  });
-}
-
-// ---- standalone entry point ------------------------------------------------
-
-const isMain = process.argv[1] && import.meta.url === pathToFileURL(resolve(process.argv[1])).href;
-if (isMain) {
-  const configPath = process.env.CLIDASH_CONFIG ?? join(MODULE_DIR, 'clidash.config.json');
-  const config = JSON.parse(readFileSync(configPath, 'utf8'));
-  if (process.env.PORT) config.port = Number(process.env.PORT);
-  if (process.env.BIND) config.bind = process.env.BIND;
-  const finalConfig = { ...DEFAULTS, ...config };
-  const server = createApp(finalConfig);
-  server.listen(finalConfig.port, finalConfig.bind, () => {
-    console.log(`clidash listening on http://${finalConfig.bind}:${finalConfig.port}`);
-  });
-}

.claude/skills/add-clidash/add/tools/clidash/test/activity-server.test.js

@@ -1,51 +0,0 @@
-import { test, before, after } from 'node:test';
-import assert from 'node:assert/strict';
-import { mkdtempSync, mkdirSync, rmSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { DatabaseSync } from 'node:sqlite';
-import { createApp } from '../server.js';
-
-let root;
-before(() => {
-  root = mkdtempSync(join(tmpdir(), 'clidash-actsrv-'));
-  mkdirSync(join(root, 'ag-1', 'sess-1'), { recursive: true });
-  const mk = (p, t, ts) => { const db = new DatabaseSync(p); db.exec(`CREATE TABLE ${t}(id TEXT, timestamp TEXT)`); const i = db.prepare(`INSERT INTO ${t} VALUES (?,?)`); ts.forEach((x, n) => i.run(String(n), x)); db.close(); };
-  // Seed with instants moments ago: they land in the LOCAL-today bucket
-  // (series.at(-1)) regardless of the machine's timezone.
-  const now = Date.now();
-  mk(join(root, 'ag-1', 'sess-1', 'inbound.db'), 'messages_in', [
-    new Date(now - 120_000).toISOString(),
-    new Date(now - 60_000).toISOString(),
-  ]);
-  mk(join(root, 'ag-1', 'sess-1', 'outbound.db'), 'messages_out', [new Date(now - 90_000).toISOString()]);
-});
-after(() => rmSync(root, { recursive: true, force: true }));
-
-async function withServer(config, fn) {
-  const server = createApp({ port: 0, bind: '127.0.0.1', clis: {}, ...config });
-  await new Promise((r) => server.listen(0, '127.0.0.1', r));
-  const base = `http://127.0.0.1:${server.address().port}`;
-  try { return await fn(base); } finally { await new Promise((r) => server.close(r)); }
-}
-
-test('/api/activity: returns per-session totals + a daily series', async () => {
-  await withServer({ activity: { sessionsRoot: root, days: 14 } }, async (base) => {
-    const body = await (await fetch(`${base}/api/activity`)).json();
-    assert.equal(body.ok, true);
-    assert.equal(body.configured, true);
-    assert.equal(body.series.length, 14);
-    assert.equal(body.sessions[0].in, 2);
-    assert.equal(body.sessions[0].out, 1);
-    assert.equal(body.series.at(-1).in, 2); // today
-    assert.equal(body.series.at(-1).out, 1);
-  });
-});
-
-test('/api/activity: not configured → configured:false, no crash', async () => {
-  await withServer({}, async (base) => {
-    const body = await (await fetch(`${base}/api/activity`)).json();
-    assert.equal(body.ok, true);
-    assert.equal(body.configured, false);
-  });
-});

.claude/skills/add-clidash/add/tools/clidash/test/activity.test.js

@@ -1,85 +0,0 @@
-import { test, before, after } from 'node:test';
-import assert from 'node:assert/strict';
-import { mkdtempSync, mkdirSync, rmSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { DatabaseSync } from 'node:sqlite';
-import { collectActivity } from '../activity.js';
-
-let root;
-const NOW = new Date('2026-06-14T12:00:00Z');
-
-function makeDb(path, table, timestamps) {
-  const db = new DatabaseSync(path);
-  db.exec(`CREATE TABLE ${table} (id TEXT, timestamp TEXT)`);
-  const ins = db.prepare(`INSERT INTO ${table} (id, timestamp) VALUES (?, ?)`);
-  timestamps.forEach((t, i) => ins.run(String(i), t));
-  db.close();
-}
-
-before(() => {
-  root = mkdtempSync(join(tmpdir(), 'clidash-act-'));
-  // session 1 (group ag-1): 3 inbound across 2 days, 2 outbound today
-  mkdirSync(join(root, 'ag-1', 'sess-1'), { recursive: true });
-  makeDb(join(root, 'ag-1', 'sess-1', 'inbound.db'), 'messages_in',
-    ['2026-06-14 09:01:23', '2026-06-14 10:00:00', '2026-06-13 08:00:00']);
-  makeDb(join(root, 'ag-1', 'sess-1', 'outbound.db'), 'messages_out',
-    ['2026-06-14 09:05:00', '2026-06-14 10:05:00']);
-  // session 2 (group ag-2): 1 inbound 20 days ago (outside 14d window), 0 outbound
-  mkdirSync(join(root, 'ag-2', 'sess-2'), { recursive: true });
-  makeDb(join(root, 'ag-2', 'sess-2', 'inbound.db'), 'messages_in', ['2026-05-25 08:00:00']);
-  makeDb(join(root, 'ag-2', 'sess-2', 'outbound.db'), 'messages_out', []);
-});
-
-after(() => rmSync(root, { recursive: true, force: true }));
-
-test('collectActivity: per-session in/out totals + last activity', () => {
-  const { sessions } = collectActivity(root, 14, NOW);
-  const s1 = sessions.find((s) => s.session_id === 'sess-1');
-  assert.equal(s1.agent_group_id, 'ag-1');
-  assert.equal(s1.in, 3);
-  assert.equal(s1.out, 2);
-  assert.equal(s1.lastActivity, '2026-06-14T10:05:00Z'); // normalized to ISO
-  const s2 = sessions.find((s) => s.session_id === 'sess-2');
-  assert.equal(s2.in, 1);
-  assert.equal(s2.out, 0);
-});
-
-// Buckets are LOCAL calendar days — derive expectations with the same
-// mapping so the assertions hold in any machine timezone.
-const day = (t) => new Date(t).toLocaleDateString('sv-SE');
-
-test('collectActivity: series has one bucket per day for `days`, newest last', () => {
-  const { series } = collectActivity(root, 14, NOW);
-  assert.equal(series.length, 14);
-  assert.equal(series[0].date, day(new Date(NOW.getTime() - 13 * 86_400_000)));
-  assert.equal(series[13].date, day(NOW));
-});
-
-test('collectActivity: counts land in the right day buckets', () => {
-  const { series } = collectActivity(root, 14, NOW);
-  const byDate = Object.fromEntries(series.map((d) => [d.date, d]));
-  const expIn = {};
-  const expOut = {};
-  for (const t of ['2026-06-14T09:01:23Z', '2026-06-14T10:00:00Z', '2026-06-13T08:00:00Z']) {
-    expIn[day(t)] = (expIn[day(t)] ?? 0) + 1;
-  }
-  for (const t of ['2026-06-14T09:05:00Z', '2026-06-14T10:05:00Z']) {
-    expOut[day(t)] = (expOut[day(t)] ?? 0) + 1;
-  }
-  for (const [d, n] of Object.entries(expIn)) assert.equal(byDate[d].in, n);
-  for (const [d, n] of Object.entries(expOut)) assert.equal(byDate[d].out, n);
-});
-
-test('collectActivity: messages outside the window are counted in totals but not the series', () => {
-  const { series, sessions } = collectActivity(root, 14, NOW);
-  const total = series.reduce((a, d) => a + d.in + d.out, 0);
-  assert.equal(total, 5);              // the 20-day-old message is excluded from series
-  assert.equal(sessions.find((s) => s.session_id === 'sess-2').in, 1); // but still in the total count
-});
-
-test('collectActivity: a dir with no message DBs is not a session (skipped)', () => {
-  mkdirSync(join(root, 'ag-1', '.claude-shared'), { recursive: true }); // scaffolding, no db files
-  const { sessions } = collectActivity(root, 14, NOW);
-  assert.ok(!sessions.some((s) => s.session_id === '.claude-shared'));
-});

.claude/skills/add-clidash/add/tools/clidash/test/cmd.test.js

@@ -1,91 +0,0 @@
-import { test, after } from 'node:test';
-import assert from 'node:assert/strict';
-import { mkdtempSync, readFileSync, rmSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { createApp } from '../server.js';
-
-const STUB = fileURLToPath(new URL('./fixtures/stub-cli.js', import.meta.url));
-const tmp = mkdtempSync(join(tmpdir(), 'clidash-cmd-'));
-after(() => rmSync(tmp, { recursive: true, force: true }));
-
-function cli(extra = {}) {
-  return {
-    bin: process.execPath,
-    discover: { args: [STUB, 'help'], parser: 'ncl-help' },
-    list: [STUB, '{resource}', 'list', '--json'],
-    output: 'json',
-    unwrap: 'data',
-    commands: {
-      get: [STUB, '{resource}', 'get', '{id}', '--json'],
-      'config-get': [STUB, 'groups', 'config', 'get', '--id', '{id}', '--json'],
-    },
-    ...extra,
-  };
-}
-
-async function withServer(clis, fn, extra = {}) {
-  const server = createApp({ port: 0, bind: '127.0.0.1', execTimeoutMs: 2000, clis, ...extra });
-  await new Promise((r) => server.listen(0, '127.0.0.1', r));
-  const base = `http://127.0.0.1:${server.address().port}`;
-  try { return await fn(base); } finally { await new Promise((r) => server.close(r)); }
-}
-
-test('/api/cmd: runs an allowlisted command with {resource} + {id}', async () => {
-  await withServer({ ncl: cli() }, async (base) => {
-    const body = await (await fetch(`${base}/api/cmd/ncl/get?resource=sessions&id=sess-123`)).json();
-    assert.equal(body.ok, true);
-    assert.equal(body.data.id, 'sessions-detail');
-    assert.match(body.data.args, /sessions get sess-123/);
-  });
-});
-
-test('/api/cmd: config-get needs no resource', async () => {
-  await withServer({ ncl: cli() }, async (base) => {
-    const body = await (await fetch(`${base}/api/cmd/ncl/config-get?id=ag-1`)).json();
-    assert.equal(body.ok, true);
-    assert.match(body.data.args, /groups config get --id ag-1/);
-  });
-});
-
-test('/api/cmd: unknown command name → 404 (allowlist)', async () => {
-  await withServer({ ncl: cli() }, async (base) => {
-    const res = await fetch(`${base}/api/cmd/ncl/delete?resource=groups&id=ag-1`);
-    assert.equal(res.status, 404);
-  });
-});
-
-test('/api/cmd: a {resource} not in the discovered set is rejected without exec', async () => {
-  const countFile = join(tmp, 'cmd-count.txt');
-  const c = cli();
-  c.env = { STUB_COUNT_FILE: countFile };
-  await withServer({ ncl: c }, async (base) => {
-    const res = await fetch(`${base}/api/cmd/ncl/get?resource=evil&id=x`);
-    assert.equal(res.status, 404);
-    // only discovery ran, never a get for the bogus resource
-    const calls = readFileSync(countFile, 'utf8').trim().split('\n');
-    assert.deepEqual(calls, ['help']);
-  });
-});
-
-test('/api/cmd: an id with illegal characters is rejected', async () => {
-  await withServer({ ncl: cli() }, async (base) => {
-    const res = await fetch(`${base}/api/cmd/ncl/get?resource=sessions&id=${encodeURIComponent('a b;rm -rf')}`);
-    assert.equal(res.status, 400);
-  });
-});
-
-test('/api/cmd: unknown cli → 404', async () => {
-  await withServer({ ncl: cli() }, async (base) => {
-    assert.equal((await fetch(`${base}/api/cmd/nope/get?resource=sessions&id=x`)).status, 404);
-  });
-});
-
-test('/api/cmd: a cli without a commands map → 404', async () => {
-  const c = cli();
-  delete c.commands;
-  await withServer({ ncl: c }, async (base) => {
-    assert.equal((await fetch(`${base}/api/cmd/ncl/get?resource=sessions&id=x`)).status, 404);
-  });
-});

.claude/skills/add-clidash/add/tools/clidash/test/css.test.js

@@ -1,20 +0,0 @@
-import { test } from 'node:test';
-import assert from 'node:assert/strict';
-import { readFileSync } from 'node:fs';
-import { fileURLToPath } from 'node:url';
-
-const css = readFileSync(fileURLToPath(new URL('../public/style.css', import.meta.url)), 'utf8');
-
-// Regression: the `hidden` attribute must override author `display` rules.
-// `.detail-overlay` and `.cli-switcher` set `display:flex`, which beats the
-// browser's default `[hidden]{display:none}` — without this reset a hidden
-// overlay stays on top of the page and silently eats every click.
-test('style.css forces [hidden] to display:none with !important', () => {
-  assert.match(css, /\[hidden\]\s*\{\s*display:\s*none\s*!important;?\s*\}/);
-});
-
-// Guard the premise: if these stop using display:flex the reset is less load-
-// bearing, but this documents WHY the reset exists.
-test('the overlays that motivated the reset still use display:flex', () => {
-  assert.match(css, /\.detail-overlay\s*\{[^}]*display:\s*flex/);
-});

.claude/skills/add-clidash/add/tools/clidash/test/docs-server.test.js

@@ -1,111 +0,0 @@
-import { test, before, after } from 'node:test';
-import assert from 'node:assert/strict';
-import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { createApp } from '../server.js';
-
-let root;
-
-before(() => {
-  root = mkdtempSync(join(tmpdir(), 'clidash-docsrv-'));
-  const w = (rel, body) => {
-    const abs = join(root, rel);
-    mkdirSync(join(abs, '..'), { recursive: true });
-    writeFileSync(abs, body);
-  };
-  w('groups/alpha/skills/tagger/SKILL.md', '# tagger\nhello');
-  w('container/skills/welcome/SKILL.md', '# welcome');
-  w('groups/alpha/profile.json', '{"name":"Alpha"}');
-  w('groups/alpha/.env', 'SECRET=nope');
-});
-
-after(() => rmSync(root, { recursive: true, force: true }));
-
-function docsConfig() {
-  return {
-    port: 0,
-    bind: '127.0.0.1',
-    clis: {},
-    docs: {
-      root,
-      deny: ['node_modules', '.env', '*token*', '*secret*', '*.pem', '*.key'],
-      collections: [
-        { name: 'skills', label: 'Skills', lang: 'markdown', patterns: ['groups/*/skills/*/SKILL.md', 'container/skills/*/SKILL.md'] },
-        { name: 'profiles', label: 'Profiles', lang: 'json', patterns: ['groups/*/profile.json'] },
-      ],
-    },
-  };
-}
-
-async function withServer(config, fn) {
-  const server = createApp(config);
-  await new Promise((r) => server.listen(0, '127.0.0.1', r));
-  const base = `http://127.0.0.1:${server.address().port}`;
-  try {
-    return await fn(base);
-  } finally {
-    await new Promise((r) => server.close(r));
-  }
-}
-
-test('/api/docs: lists collections with their files', async () => {
-  await withServer(docsConfig(), async (base) => {
-    const body = await (await fetch(`${base}/api/docs`)).json();
-    const skills = body.collections.find((c) => c.name === 'skills');
-    assert.equal(skills.label, 'Skills');
-    assert.equal(skills.lang, 'markdown');
-    const paths = skills.files.map((f) => f.path);
-    assert.ok(paths.includes('groups/alpha/skills/tagger/SKILL.md'));
-    assert.ok(paths.includes('container/skills/welcome/SKILL.md'));
-    // each file carries a readable label + group
-    const f = skills.files.find((x) => x.path.includes('tagger'));
-    assert.equal(f.group, 'alpha');
-    assert.match(f.label, /tagger/);
-  });
-});
-
-test('/api/doc: returns file content + lang', async () => {
-  await withServer(docsConfig(), async (base) => {
-    const url = `${base}/api/doc?c=skills&p=${encodeURIComponent('groups/alpha/skills/tagger/SKILL.md')}`;
-    const body = await (await fetch(url)).json();
-    assert.equal(body.ok, true);
-    assert.equal(body.lang, 'markdown');
-    assert.match(body.content, /# tagger/);
-  });
-});
-
-test('/api/doc: a denied file is not readable even though it sits under root', async () => {
-  await withServer(docsConfig(), async (base) => {
-    // .env is excluded by the deny-list and not in any collection pattern
-    const coll = docsConfig();
-    coll.docs.collections.push({ name: 'all', label: 'All', lang: 'text', patterns: ['groups/*/*'] });
-    await withServer(coll, async (base2) => {
-      const res = await fetch(`${base2}/api/doc?c=all&p=${encodeURIComponent('groups/alpha/.env')}`);
-      assert.equal(res.status, 404);
-      assert.equal((await res.json()).ok, false);
-    });
-  });
-});
-
-test('/api/doc: path traversal is rejected', async () => {
-  await withServer(docsConfig(), async (base) => {
-    const res = await fetch(`${base}/api/doc?c=skills&p=${encodeURIComponent('../../../../etc/passwd')}`);
-    assert.equal(res.status, 404);
-    assert.equal((await res.json()).ok, false);
-  });
-});
-
-test('/api/doc: unknown collection → 404', async () => {
-  await withServer(docsConfig(), async (base) => {
-    const res = await fetch(`${base}/api/doc?c=nope&p=x`);
-    assert.equal(res.status, 404);
-  });
-});
-
-test('/api/docs: absent docs config → empty collections, no crash', async () => {
-  await withServer({ port: 0, bind: '127.0.0.1', clis: {} }, async (base) => {
-    const body = await (await fetch(`${base}/api/docs`)).json();
-    assert.deepEqual(body.collections, []);
-  });
-});

.claude/skills/add-clidash/add/tools/clidash/test/docs.test.js

@@ -1,111 +0,0 @@
-import { test, before, after } from 'node:test';
-import assert from 'node:assert/strict';
-import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { globFiles, describeFile, resolveDoc } from '../docs.js';
-
-let root;
-
-before(() => {
-  root = mkdtempSync(join(tmpdir(), 'clidash-docs-'));
-  const w = (rel, body = 'x') => {
-    const abs = join(root, rel);
-    mkdirSync(join(abs, '..'), { recursive: true });
-    writeFileSync(abs, body);
-  };
-  w('groups/alpha/skills/example-skill/SKILL.md', '# example-skill\nbody');
-  w('groups/alpha/skills/tagger/SKILL.md');
-  w('groups/alpha/CLAUDE.md', '# Alpha');
-  w('groups/alpha/CLAUDE.local.md');
-  w('groups/alpha/profile.json', '{"name":"Alpha"}');
-  w('groups/alpha/conversations/2026-06-01.md');
-  w('groups/bravo/skills/tagger/SKILL.md');
-  w('groups/bravo/profile.json');
-  w('container/skills/agent-browser/SKILL.md');
-  w('container/skills/welcome/SKILL.md');
-  // things that must NEVER be served
-  w('groups/alpha/.env', 'SECRET=1');
-  w('groups/alpha/skills/example-skill/node_modules/dep/SKILL.md');
-  w('groups/alpha/notion-token.txt', 'ntn_xxx');
-});
-
-after(() => rmSync(root, { recursive: true, force: true }));
-
-const DENY = ['node_modules', '.env', '*token*', '*secret*', '*.pem', '*.key'];
-
-// --------------------------------------------------------------- globFiles
-
-test('globFiles: matches a nested *-segment pattern', () => {
-  const files = globFiles(root, ['groups/*/skills/*/SKILL.md'], DENY);
-  assert.deepEqual(files, [
-    'groups/alpha/skills/example-skill/SKILL.md',
-    'groups/alpha/skills/tagger/SKILL.md',
-    'groups/bravo/skills/tagger/SKILL.md',
-  ]);
-});
-
-test('globFiles: multiple patterns union, sorted', () => {
-  const files = globFiles(root, ['groups/*/skills/*/SKILL.md', 'container/skills/*/SKILL.md'], DENY);
-  assert.ok(files.includes('container/skills/agent-browser/SKILL.md'));
-  assert.ok(files.includes('groups/alpha/skills/example-skill/SKILL.md'));
-});
-
-test('globFiles: wildcard inside a filename segment', () => {
-  const files = globFiles(root, ['groups/*/CLAUDE*.md'], DENY);
-  assert.deepEqual(files, ['groups/alpha/CLAUDE.local.md', 'groups/alpha/CLAUDE.md']);
-});
-
-test('globFiles: deny list excludes node_modules and secret-ish files', () => {
-  const files = globFiles(root, ['groups/*/skills/*/**', 'groups/*/*'], DENY);
-  assert.ok(!files.some((f) => f.includes('node_modules')));
-  assert.ok(!files.some((f) => f.endsWith('.env')));
-  assert.ok(!files.some((f) => f.includes('token')));
-});
-
-test('globFiles: no match returns empty array', () => {
-  assert.deepEqual(globFiles(root, ['nope/*/x.md'], DENY), []);
-});
-
-// ------------------------------------------------------------- describeFile
-
-test('describeFile: per-group skill → group + readable label', () => {
-  const d = describeFile('groups/alpha/skills/tagger/SKILL.md');
-  assert.equal(d.group, 'alpha');
-  assert.match(d.label, /alpha/);
-  assert.match(d.label, /tagger/);
-});
-
-test('describeFile: container skill → shared', () => {
-  const d = describeFile('container/skills/agent-browser/SKILL.md');
-  assert.equal(d.group, 'shared');
-  assert.match(d.label, /agent-browser/);
-});
-
-// --------------------------------------------------------------- resolveDoc
-
-const SKILLS = { name: 'skills', patterns: ['groups/*/skills/*/SKILL.md', 'container/skills/*/SKILL.md'] };
-
-test('resolveDoc: returns an absolute path for an allowed file', () => {
-  const abs = resolveDoc(root, SKILLS, 'groups/alpha/skills/example-skill/SKILL.md', DENY);
-  assert.ok(abs.endsWith('/groups/alpha/skills/example-skill/SKILL.md'));
-  assert.ok(abs.startsWith(root));
-});
-
-test('resolveDoc: rejects a path not matching the collection patterns', () => {
-  assert.throws(() => resolveDoc(root, SKILLS, 'groups/alpha/profile.json', DENY), /not allowed/i);
-});
-
-test('resolveDoc: rejects path traversal', () => {
-  assert.throws(() => resolveDoc(root, SKILLS, '../../etc/passwd', DENY), /not allowed/i);
-  assert.throws(() => resolveDoc(root, SKILLS, 'groups/alpha/skills/../../../.env', DENY), /not allowed/i);
-});
-
-test('resolveDoc: rejects an absolute path', () => {
-  assert.throws(() => resolveDoc(root, SKILLS, '/etc/passwd', DENY), /not allowed/i);
-});
-
-test('resolveDoc: a denied file is not resolvable even if pattern-shaped', () => {
-  const coll = { name: 'all', patterns: ['groups/*/*'] };
-  assert.throws(() => resolveDoc(root, coll, 'groups/alpha/.env', DENY), /not allowed/i);
-});

.claude/skills/add-clidash/add/tools/clidash/test/fixtures/ncl-help.txt

@@ -1,28 +0,0 @@
-Resources:
-  approvals            Pending approval — in-flight approval cards waiting for an admin response. Created by requestApproval() (self-mod install_packages/add_mcp_server) and OneCLI credential approval flow. Rows are deleted after the admin approves/rejects or the request expires.
-                       verbs: list, get
-  destinations         Agent destination — per-agent routing entry and ACL. Each row authorizes an agent to send messages to a target (channel or another agent) and assigns a local name the agent uses to address it. Names are scoped to the source agent — two agents can have different local names for the same target. Created automatically when wiring channels or when agents create child agents.
-                       verbs: list, add, remove
-  dropped-messages     Dropped message log — tracks messages that were dropped by the router or access gate. Aggregates by (channel_type, platform_id) with a running count. Reasons include: no_agent_wired (no wiring exists), no_agent_engaged (wiring exists but engage rules didn't fire), unknown_sender_strict (sender not recognized, strict policy), unknown_sender_request_approval (sender not recognized, approval requested).
-                       verbs: list
-  groups               Agent group — a logical agent identity. Each group has its own workspace folder (CLAUDE.md, skills, container config), conversation history, and container image. Multiple messaging groups can be wired to one agent group.
-                       verbs: list, get, create, update, delete, restart, config get, config update, config add-mcp-server, config remove-mcp-server, config add-package, config remove-package
-  members              Agent group member — grants an unprivileged user permission to interact with an agent group. Users with admin or owner roles on the group are implicitly members and do not need a separate membership row. Membership is checked by the router when sender_scope is "known".
-                       verbs: list, add, remove
-  messaging-groups     Messaging group — one chat or channel on one platform (a Telegram DM, a Discord channel, a Slack thread root, an email address). Identity is the (channel_type, platform_id) pair, which must be unique.
-                       verbs: list, get, create, update, delete
-  roles                User role — privilege grant. "owner" is always global and has full control. "admin" can be global (agent_group_id null) or scoped to a specific agent group. Admin at a group implies membership. Approval routing prefers admins/owners reachable on the same messaging platform as the request origin (e.g. a Telegram request routes the approval card to an admin on Telegram when possible).
-                       verbs: list, grant, revoke
-  sessions             Session — the runtime unit. Maps one (agent_group, messaging_group, thread) combination to a container with its own inbound.db and outbound.db. Created automatically by the router when a message arrives.
-                       verbs: list, get
-  user-dms             User DM cache — maps (user, channel_type) to the messaging group used for DM delivery. Populated lazily by ensureUserDm() when the host needs to cold-DM a user (approvals, pairing). For direct-addressable channels (Telegram, WhatsApp) the handle IS the DM chat ID. For resolution-required channels (Discord, Slack) the adapter's openDM resolves it.
-                       verbs: list
-  users                User — a messaging-platform identity. Each row is one sender on one channel. A single human may have multiple user rows across channels (no cross-channel linking yet).
-                       verbs: list, get, create, update
-  wirings              Wiring — connects a messaging group to an agent group. Determines which agent handles messages from which chat. The same messaging group can be wired to multiple agents; the same agent can be wired to multiple messaging groups.
-                       verbs: list, get, create, update, delete
-
-Commands:
-  help                 List available resources and commands.
-
-Run `ncl <resource> help` for detailed field information.

.claude/skills/add-clidash/add/tools/clidash/test/fixtures/stub-cli.js

@@ -1,57 +0,0 @@
-#!/usr/bin/env node
-// Stub CLI for clidash tests. Impersonates ncl (envelope json) or a
-// jsonlines CLI, with failure/slowness/garbage modes driven by env vars.
-import { readFileSync, appendFileSync } from 'node:fs';
-import { fileURLToPath } from 'node:url';
-
-const args = process.argv.slice(2);
-
-if (process.env.STUB_COUNT_FILE) {
-  appendFileSync(process.env.STUB_COUNT_FILE, args.join(' ') + '\n');
-}
-
-const sleepMs = Number(process.env.STUB_SLEEP_MS || 0);
-
-setTimeout(() => {
-  if (process.env.STUB_FAIL) {
-    process.stderr.write('boom: socket down\n');
-    process.exit(2);
-  }
-  if (args[0] === 'help') {
-    process.stdout.write(
-      readFileSync(fileURLToPath(new URL('./ncl-help.txt', import.meta.url)), 'utf8'),
-    );
-    process.exit(0);
-  }
-  if (args[1] === 'help') { // `<resource> help` → raw per-resource help text
-    process.stdout.write(`${args[0]}: help for ${args[0]}\n\nVerbs:\n  list\n  get <id>\n`);
-    process.exit(0);
-  }
-  if (process.env.STUB_RAW) {
-    process.stdout.write(process.env.STUB_RAW + '\n');
-    process.exit(0);
-  }
-  const resource = args[0];
-  // `get`/detail commands → single-object envelope
-  if (args.includes('get') || args.includes('config')) {
-    process.stdout.write(JSON.stringify({
-      id: 'req-1', ok: true,
-      data: { id: `${resource}-detail`, args: args.join(' '), extra: 'field' },
-    }) + '\n');
-    process.exit(0);
-  }
-  if (process.env.STUB_JSONLINES) {
-    process.stdout.write(JSON.stringify({ id: `${resource}-1`, name: 'row one' }) + '\n');
-    process.stdout.write(JSON.stringify({ id: `${resource}-2`, name: 'row two' }) + '\n');
-    process.exit(0);
-  }
-  process.stdout.write(JSON.stringify({
-    id: 'req-1',
-    ok: true,
-    data: [
-      { id: `${resource}-1`, name: 'row one' },
-      { id: `${resource}-2`, name: 'row two' },
-    ],
-  }) + '\n');
-  process.exit(0);
-}, sleepMs);

.claude/skills/add-clidash/add/tools/clidash/test/help.test.js

@@ -1,61 +0,0 @@
-import { test } from 'node:test';
-import assert from 'node:assert/strict';
-import { fileURLToPath } from 'node:url';
-import { createApp } from '../server.js';
-
-const STUB = fileURLToPath(new URL('./fixtures/stub-cli.js', import.meta.url));
-
-function cli(extra = {}) {
-  return {
-    bin: process.execPath,
-    discover: { args: [STUB, 'help'], parser: 'ncl-help' },
-    list: [STUB, '{resource}', 'list', '--json'],
-    output: 'json', unwrap: 'data',
-    help: [STUB, '{resource}', 'help'],
-    ...extra,
-  };
-}
-
-async function withServer(clis, fn) {
-  const server = createApp({ port: 0, bind: '127.0.0.1', execTimeoutMs: 2000, clis });
-  await new Promise((r) => server.listen(0, '127.0.0.1', r));
-  const base = `http://127.0.0.1:${server.address().port}`;
-  try { return await fn(base); } finally { await new Promise((r) => server.close(r)); }
-}
-
-test('/api/help: returns raw per-resource help text', async () => {
-  await withServer({ ncl: cli() }, async (base) => {
-    const body = await (await fetch(`${base}/api/help/ncl/sessions`)).json();
-    assert.equal(body.ok, true);
-    assert.match(body.text, /sessions: help for sessions/);
-    assert.match(body.text, /Verbs:/);
-  });
-});
-
-test('/api/help: undiscovered resource → 404', async () => {
-  await withServer({ ncl: cli() }, async (base) => {
-    assert.equal((await fetch(`${base}/api/help/ncl/evil`)).status, 404);
-  });
-});
-
-test('/api/help: a cli without a help template → 404', async () => {
-  const c = cli(); delete c.help;
-  await withServer({ ncl: c }, async (base) => {
-    assert.equal((await fetch(`${base}/api/help/ncl/sessions`)).status, 404);
-  });
-});
-
-test('/api/help: unknown cli → 404', async () => {
-  await withServer({ ncl: cli() }, async (base) => {
-    assert.equal((await fetch(`${base}/api/help/nope/sessions`)).status, 404);
-  });
-});
-
-test('/api/clis: reports help availability per cli', async () => {
-  const noHelp = cli(); delete noHelp.help;
-  await withServer({ ncl: cli(), docker: noHelp }, async (base) => {
-    const body = await (await fetch(`${base}/api/clis`)).json();
-    assert.equal(body.clis.find((c) => c.name === 'ncl').help, true);
-    assert.equal(body.clis.find((c) => c.name === 'docker').help, false);
-  });
-});

.claude/skills/add-clidash/add/tools/clidash/test/logs.test.js

@@ -1,75 +0,0 @@
-import { test, before, after } from 'node:test';
-import assert from 'node:assert/strict';
-import { mkdtempSync, writeFileSync, rmSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { tailFile } from '../logs.js';
-import { createApp } from '../server.js';
-
-let dir;
-before(() => {
-  dir = mkdtempSync(join(tmpdir(), 'clidash-logs-'));
-  // 10 lines, some with ANSI color codes
-  const lines = Array.from({ length: 10 }, (_, i) =>
-    `[12:00:0${i}] \x1b[32mINFO\x1b[39m line ${i}`);
-  writeFileSync(join(dir, 'app.log'), lines.join('\n') + '\n');
-  writeFileSync(join(dir, 'error.log'), 'boom\n');
-});
-after(() => rmSync(dir, { recursive: true, force: true }));
-
-test('tailFile: returns the last N lines, ANSI stripped, no trailing blank', async () => {
-  const { lines, text } = await tailFile(join(dir, 'app.log'), 3);
-  assert.equal(lines.length, 3);
-  assert.deepEqual(lines, ['[12:00:07] INFO line 7', '[12:00:08] INFO line 8', '[12:00:09] INFO line 9']);
-  assert.ok(!text.includes('\x1b'));
-});
-
-test('tailFile: maxLines larger than file returns all lines', async () => {
-  const { lines } = await tailFile(join(dir, 'app.log'), 100);
-  assert.equal(lines.length, 10);
-});
-
-// ---- server endpoints ----
-
-function cfg() {
-  return {
-    port: 0, bind: '127.0.0.1', clis: {},
-    logs: { dir, tailLines: 5, files: [{ name: 'app.log', label: 'app' }, { name: 'error.log', label: 'errors' }] },
-  };
-}
-async function withServer(config, fn) {
-  const server = createApp(config);
-  await new Promise((r) => server.listen(0, '127.0.0.1', r));
-  const base = `http://127.0.0.1:${server.address().port}`;
-  try { return await fn(base); } finally { await new Promise((r) => server.close(r)); }
-}
-
-test('/api/logs: lists the configured log files', async () => {
-  await withServer(cfg(), async (base) => {
-    const body = await (await fetch(`${base}/api/logs`)).json();
-    assert.deepEqual(body.files.map((f) => f.name), ['app.log', 'error.log']);
-  });
-});
-
-test('/api/logs: absent logs config → empty list', async () => {
-  await withServer({ port: 0, bind: '127.0.0.1', clis: {} }, async (base) => {
-    assert.deepEqual((await (await fetch(`${base}/api/logs`)).json()).files, []);
-  });
-});
-
-test('/api/log: returns the tail text + a tail command', async () => {
-  await withServer(cfg(), async (base) => {
-    const body = await (await fetch(`${base}/api/log/app.log`)).json();
-    assert.equal(body.ok, true);
-    assert.match(body.text, /line 9$/);
-    assert.equal(body.text.split('\n').length, 5); // tailLines
-    assert.match(body.command, /tail -n 5 .*app\.log/);
-  });
-});
-
-test('/api/log: a name not in the allowlist is rejected (no traversal)', async () => {
-  await withServer(cfg(), async (base) => {
-    assert.equal((await fetch(`${base}/api/log/${encodeURIComponent('../../etc/passwd')}`)).status, 404);
-    assert.equal((await fetch(`${base}/api/log/secrets.log`)).status, 404);
-  });
-});

.claude/skills/add-clidash/add/tools/clidash/test/md.test.js

@@ -1,63 +0,0 @@
-import { test } from 'node:test';
-import assert from 'node:assert/strict';
-import { escapeHtml, mdToHtml } from '../public/md.js';
-
-// ---- escaping -------------------------------------------------------------
-
-test('escapeHtml: neutralizes all HTML metacharacters', () => {
-  assert.equal(escapeHtml(`<script>"&'`), '&lt;script&gt;&quot;&amp;&#39;');
-});
-
-test('mdToHtml: raw HTML in source is escaped, never passed through', () => {
-  const html = mdToHtml('a <script>alert(1)</script> b');
-  assert.ok(!html.includes('<script>'));
-  assert.ok(html.includes('&lt;script&gt;'));
-});
-
-// ---- the security-sensitive part: links -----------------------------------
-
-test('mdToHtml: link href comes from the URL, label from the text', () => {
-  const html = mdToHtml('see [the docs](https://example.com/x)');
-  assert.match(html, /<a href="https:\/\/example\.com\/x" target="_blank" rel="noopener noreferrer">the docs<\/a>/);
-});
-
-test('mdToHtml: javascript: smuggled in link TEXT stays inert (never an href)', () => {
-  const html = mdToHtml('[javascript:alert(1)](https://safe.com)');
-  // href is the safe URL; the js string is only visible label text
-  assert.match(html, /href="https:\/\/safe\.com"/);
-  assert.ok(!/href="javascript:/i.test(html));
-});
-
-test('mdToHtml: a non-http(s) URL is not turned into a link', () => {
-  // javascript:/data: never match the (https?:...) capture, so the literal
-  // (escaped) markdown is left as-is — no anchor, no executable href.
-  const html = mdToHtml('[click](javascript:alert(1))');
-  assert.ok(!/<a /.test(html));
-  assert.ok(!/href="javascript:/i.test(html));
-});
-
-test('mdToHtml: an attribute-breakout attempt in the URL cannot escape the href', () => {
-  // The double-quote is escaped to &quot; before the regex runs, so it can never
-  // close an attribute. (Here the URL also has a space, so no anchor even forms.)
-  // The security property: no REAL attribute (with a literal quote) is injected.
-  const html = mdToHtml('[x](https://a" onmouseover="alert(1))');
-  assert.ok(!/<a/.test(html), 'malformed link must not produce an anchor');
-  assert.ok(!/onmouseover="/.test(html), 'no real (unescaped-quote) attribute injected');
-});
-
-test('mdToHtml: an escaped quote inside a matched URL stays inside the href, inert', () => {
-  // Even when a URL matches, any " in it is already &quot; (an entity), which
-  // does not terminate an HTML attribute value — so no breakout.
-  const html = mdToHtml('[x](https://a"onmouseover=alert)');
-  assert.ok(!/onmouseover="/.test(html));
-  if (/<a/.test(html)) assert.match(html, /href="https:\/\/a&quot;onmouseover=alert"/);
-});
-
-// ---- basic rendering sanity ----------------------------------------------
-
-test('mdToHtml: headings, code fences, lists render', () => {
-  const html = mdToHtml('# Title\n\n```\ncode\n```\n\n- a\n- b');
-  assert.match(html, /<h1>Title<\/h1>/);
-  assert.match(html, /<pre class="code"><code>code<\/code><\/pre>/);
-  assert.match(html, /<ul><li>a<\/li><li>b<\/li><\/ul>/);
-});

.claude/skills/add-clidash/add/tools/clidash/test/ncl-overview.test.js

@@ -1,70 +0,0 @@
-import { test } from 'node:test';
-import assert from 'node:assert/strict';
-import overview from '../views/ncl-overview.js';
-
-const minutesAgo = (m) => new Date(Date.now() - m * 60_000).toISOString();
-
-// Shapes mirror real `ncl <resource> list --json` output.
-function makeFixtures({ alphaLastActive, bravoLastActive }) {
-  return {
-    groups: [
-      { id: 'ag-1', name: 'Alpha', folder: 'alpha', created_at: '2026-05-31T11:14:48.793Z' },
-      { id: 'ag-2', name: 'Bravo Team', folder: 'bravo', created_at: '2026-05-31T11:14:48.796Z' },
-      { id: 'ag-3', name: 'Orphan', folder: 'orphan', created_at: '2026-05-31T11:14:48.799Z' },
-    ],
-    sessions: [
-      { id: 'sess-1', agent_group_id: 'ag-1', messaging_group_id: 'mg-1', thread_id: null, status: 'active', container_status: 'stopped', last_active: alphaLastActive, created_at: '2026-05-31T11:14:51.911Z' },
-      { id: 'sess-2', agent_group_id: 'ag-2', messaging_group_id: 'mg-2', thread_id: null, status: 'active', container_status: 'running', last_active: bravoLastActive, created_at: '2026-05-31T11:14:51.973Z' },
-    ],
-    'messaging-groups': [
-      { id: 'mg-1', channel_type: 'telegram', platform_id: 'telegram:1', name: 'Alpha', is_group: 0 },
-      { id: 'mg-2', channel_type: 'telegram', platform_id: 'telegram:2', name: 'Bravo Team', is_group: 0 },
-    ],
-    wirings: [
-      { id: 'mga-1', messaging_group_id: 'mg-1', agent_group_id: 'ag-1', session_mode: 'shared' },
-      { id: 'mga-2', messaging_group_id: 'mg-2', agent_group_id: 'ag-2', session_mode: 'shared' },
-    ],
-  };
-}
-
-function fetchFrom(fixtures) {
-  return async (resource) => {
-    if (!(resource in fixtures)) throw new Error(`unexpected fetch: ${resource}`);
-    return fixtures[resource];
-  };
-}
-
-test('overview: one card per agent group with joined session + wiring data', async () => {
-  const fixtures = makeFixtures({ alphaLastActive: minutesAgo(5), bravoLastActive: minutesAgo(30) });
-  const result = await overview({ fetch: fetchFrom(fixtures) });
-  assert.equal(result.cards.length, 3);
-
-  const alpha = result.cards.find((c) => c.title === 'Alpha');
-  assert.equal(alpha.subtitle, 'alpha');
-  assert.equal(alpha.fields.container, 'stopped');
-  assert.equal(alpha.fields.sessions, 1);
-  assert.deepEqual(alpha.badges, ['telegram: Alpha']);
-
-  const bravo = result.cards.find((c) => c.title === 'Bravo Team');
-  assert.equal(bravo.fields.container, 'running');
-  assert.deepEqual(bravo.badges, ['telegram: Bravo Team']);
-});
-
-test('overview: staleness thresholds — green <15m, amber <2h, red older, gray never', async () => {
-  const fixtures = makeFixtures({ alphaLastActive: minutesAgo(5), bravoLastActive: minutesAgo(30) });
-  const result = await overview({ fetch: fetchFrom(fixtures) });
-  assert.equal(result.cards.find((c) => c.title === 'Alpha').status, 'green');
-  assert.equal(result.cards.find((c) => c.title === 'Bravo Team').status, 'amber');
-  assert.equal(result.cards.find((c) => c.title === 'Orphan').status, 'gray');
-
-  const stale = makeFixtures({ alphaLastActive: minutesAgo(300), bravoLastActive: minutesAgo(30) });
-  const result2 = await overview({ fetch: fetchFrom(stale) });
-  assert.equal(result2.cards.find((c) => c.title === 'Alpha').status, 'red');
-});
-
-test('overview: last_active is exposed for relative-time rendering', async () => {
-  const ts = minutesAgo(5);
-  const fixtures = makeFixtures({ alphaLastActive: ts, bravoLastActive: minutesAgo(30) });
-  const result = await overview({ fetch: fetchFrom(fixtures) });
-  assert.equal(result.cards.find((c) => c.title === 'Alpha').fields['last active'], ts);
-});

.claude/skills/add-clidash/add/tools/clidash/test/parsers.test.js

@@ -1,111 +0,0 @@
-import { test } from 'node:test';
-import assert from 'node:assert/strict';
-import { readFileSync } from 'node:fs';
-import { fileURLToPath } from 'node:url';
-import { discoveryParsers, parseOutput, unwrapPath } from '../parsers.js';
-
-const fixture = readFileSync(
-  fileURLToPath(new URL('./fixtures/ncl-help.txt', import.meta.url)),
-  'utf8',
-);
-
-// ---------------------------------------------------------------- ncl-help
-
-test('ncl-help: parses all listable resources from real captured output', () => {
-  const resources = discoveryParsers['ncl-help'](fixture);
-  assert.deepEqual(
-    resources.map((r) => r.name),
-    [
-      'approvals', 'destinations', 'dropped-messages', 'groups', 'members',
-      'messaging-groups', 'roles', 'sessions', 'user-dms', 'users', 'wirings',
-    ],
-  );
-});
-
-test('ncl-help: every parsed resource has a non-empty description and a list verb', () => {
-  const resources = discoveryParsers['ncl-help'](fixture);
-  for (const r of resources) {
-    assert.ok(r.description.length > 0, `${r.name} has empty description`);
-    assert.ok(r.verbs.includes('list'), `${r.name} missing list verb`);
-  }
-});
-
-test('ncl-help: parses verbs correctly, including multi-word verbs', () => {
-  const resources = discoveryParsers['ncl-help'](fixture);
-  const groups = resources.find((r) => r.name === 'groups');
-  assert.deepEqual(groups.verbs, [
-    'list', 'get', 'create', 'update', 'delete', 'restart',
-    'config get', 'config update', 'config add-mcp-server',
-    'config remove-mcp-server', 'config add-package', 'config remove-package',
-  ]);
-});
-
-test('ncl-help: excludes resources without a list verb', () => {
-  const input = [
-    'Resources:',
-    '  alpha                Has list.',
-    '                       verbs: list, get',
-    '  beta                 No list here.',
-    '                       verbs: grant, revoke',
-    '',
-  ].join('\n');
-  const resources = discoveryParsers['ncl-help'](input);
-  assert.deepEqual(resources.map((r) => r.name), ['alpha']);
-});
-
-test('ncl-help: ignores the Commands section (help is not a resource)', () => {
-  const resources = discoveryParsers['ncl-help'](fixture);
-  assert.ok(!resources.some((r) => r.name === 'help'));
-});
-
-test('ncl-help: throws loudly on unrecognized format', () => {
-  assert.throws(() => discoveryParsers['ncl-help']('totally not help output'), /Resources/);
-  assert.throws(() => discoveryParsers['ncl-help'](''), /Resources/);
-});
-
-// ------------------------------------------------------------- parseOutput
-
-test('parseOutput json: parses a single document', () => {
-  assert.deepEqual(parseOutput('{"a": 1}', 'json'), { a: 1 });
-});
-
-test('parseOutput json: throws on malformed input with raw output preserved', () => {
-  assert.throws(() => parseOutput('not json', 'json'), (err) => {
-    assert.match(err.message, /JSON/i);
-    assert.equal(err.raw, 'not json');
-    return true;
-  });
-});
-
-test('parseOutput jsonlines: one object per line, blank lines skipped', () => {
-  const text = '{"id":1}\n\n{"id":2}\n{"id":3}\n';
-  assert.deepEqual(parseOutput(text, 'jsonlines'), [{ id: 1 }, { id: 2 }, { id: 3 }]);
-});
-
-test('parseOutput jsonlines: throws on a malformed line', () => {
-  assert.throws(() => parseOutput('{"ok":1}\ngarbage\n', 'jsonlines'), /line 2/i);
-});
-
-test('parseOutput: rejects unknown format', () => {
-  assert.throws(() => parseOutput('{}', 'xml'), /format/i);
-});
-
-// -------------------------------------------------------------- unwrapPath
-
-test('unwrapPath: extracts the ncl {id, ok, data} envelope', () => {
-  const doc = { id: 'x', ok: true, data: [{ id: 'sess-1' }] };
-  assert.deepEqual(unwrapPath(doc, 'data'), [{ id: 'sess-1' }]);
-});
-
-test('unwrapPath: supports nested dot paths', () => {
-  assert.deepEqual(unwrapPath({ a: { b: [1, 2] } }, 'a.b'), [1, 2]);
-});
-
-test('unwrapPath: throws when the path is missing', () => {
-  assert.throws(() => unwrapPath({ ok: true }, 'data'), /data/);
-});
-
-test('unwrapPath: no path returns the value unchanged', () => {
-  const rows = [{ id: 1 }];
-  assert.equal(unwrapPath(rows, undefined), rows);
-});

.claude/skills/add-clidash/add/tools/clidash/test/server.test.js

@@ -1,240 +0,0 @@
-import { test, before, after } from 'node:test';
-import assert from 'node:assert/strict';
-import { mkdtempSync, writeFileSync, readFileSync, rmSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { createApp } from '../server.js';
-
-const STUB = fileURLToPath(new URL('./fixtures/stub-cli.js', import.meta.url));
-const tmp = mkdtempSync(join(tmpdir(), 'clidash-test-'));
-
-function stubCli(extra = {}) {
-  return {
-    bin: process.execPath,
-    discover: { args: [STUB, 'help'], parser: 'ncl-help' },
-    list: [STUB, '{resource}', 'list', '--json'],
-    output: 'json',
-    unwrap: 'data',
-    ...extra,
-  };
-}
-
-function makeConfig(clis, extra = {}) {
-  return { port: 0, bind: '127.0.0.1', execTimeoutMs: 2000, refreshSeconds: 10, clis, ...extra };
-}
-
-async function withServer(config, fn) {
-  const server = createApp(config);
-  await new Promise((resolve) => server.listen(0, '127.0.0.1', resolve));
-  const base = `http://127.0.0.1:${server.address().port}`;
-  try {
-    return await fn(base);
-  } finally {
-    await new Promise((resolve) => server.close(resolve));
-  }
-}
-
-after(() => rmSync(tmp, { recursive: true, force: true }));
-
-// ----------------------------------------------------------------- /api/clis
-
-test('/api/clis: lists configured CLIs with discovered resources', async () => {
-  await withServer(makeConfig({ stub: stubCli() }), async (base) => {
-    const res = await fetch(`${base}/api/clis`);
-    assert.equal(res.status, 200);
-    const body = await res.json();
-    assert.equal(body.clis.length, 1);
-    assert.equal(body.clis[0].name, 'stub');
-    assert.equal(body.clis[0].refreshSeconds, 10);
-    const names = body.clis[0].resources.map((r) => r.name);
-    assert.ok(names.includes('sessions'));
-    assert.ok(names.includes('groups'));
-    assert.equal(names.length, 11);
-  });
-});
-
-test('/api/clis: static resource list needs no discovery', async () => {
-  const cli = stubCli({ resources: ['alpha', 'beta'] });
-  delete cli.discover;
-  await withServer(makeConfig({ stub: cli }), async (base) => {
-    const body = await (await fetch(`${base}/api/clis`)).json();
-    assert.deepEqual(body.clis[0].resources.map((r) => r.name), ['alpha', 'beta']);
-  });
-});
-
-test('/api/clis: discovery failure reports a loud error', async () => {
-  const cli = stubCli();
-  cli.env = { STUB_FAIL: '1' };
-  await withServer(makeConfig({ stub: cli }), async (base) => {
-    const body = await (await fetch(`${base}/api/clis`)).json();
-    assert.equal(body.clis[0].resources.length, 0);
-    assert.match(body.clis[0].error, /boom/);
-  });
-});
-
-// ------------------------------------------------------------ /api/r/cli/res
-
-test('/api/r: returns unwrapped rows with fetchedAt', async () => {
-  await withServer(makeConfig({ stub: stubCli() }), async (base) => {
-    const res = await fetch(`${base}/api/r/stub/sessions`);
-    assert.equal(res.status, 200);
-    const body = await res.json();
-    assert.equal(body.ok, true);
-    assert.deepEqual(body.rows.map((r) => r.id), ['sessions-1', 'sessions-2']);
-    assert.ok(body.fetchedAt);
-  });
-});
-
-test('/api/r: rejects a resource not in the discovered set without exec', async () => {
-  const countFile = join(tmp, 'count-reject.txt');
-  const cli = stubCli();
-  cli.env = { STUB_COUNT_FILE: countFile };
-  await withServer(makeConfig({ stub: cli }), async (base) => {
-    const res = await fetch(`${base}/api/r/stub/evil%20--rm`);
-    assert.equal(res.status, 404);
-    const body = await res.json();
-    assert.equal(body.ok, false);
-    // only the discovery exec ran — never a list exec for the bogus resource
-    const calls = readFileSync(countFile, 'utf8').trim().split('\n');
-    assert.deepEqual(calls, ['help']);
-  });
-});
-
-test('/api/r: unknown cli → 404', async () => {
-  await withServer(makeConfig({ stub: stubCli() }), async (base) => {
-    const res = await fetch(`${base}/api/r/nope/sessions`);
-    assert.equal(res.status, 404);
-  });
-});
-
-test('/api/r: jsonlines CLI with static resources works', async () => {
-  const cli = {
-    bin: process.execPath,
-    resources: ['ps'],
-    list: [STUB, '{resource}'],
-    output: 'jsonlines',
-    env: { STUB_JSONLINES: '1' },
-  };
-  await withServer(makeConfig({ docker: cli }), async (base) => {
-    const body = await (await fetch(`${base}/api/r/docker/ps`)).json();
-    assert.equal(body.ok, true);
-    assert.deepEqual(body.rows.map((r) => r.id), ['ps-1', 'ps-2']);
-  });
-});
-
-test('/api/r: exec failure returns ok:false with stderr', async () => {
-  const cli = stubCli({ resources: ['sessions'] });
-  delete cli.discover;
-  cli.env = { STUB_FAIL: '1' };
-  await withServer(makeConfig({ stub: cli }), async (base) => {
-    const res = await fetch(`${base}/api/r/stub/sessions`);
-    assert.equal(res.status, 502);
-    const body = await res.json();
-    assert.equal(body.ok, false);
-    assert.match(body.error, /boom: socket down/);
-  });
-});
-
-test('/api/r: exec timeout returns ok:false naming the resource', async () => {
-  const cli = stubCli({ resources: ['sessions'] });
-  delete cli.discover;
-  cli.env = { STUB_SLEEP_MS: '5000' };
-  await withServer(makeConfig({ stub: cli }, { execTimeoutMs: 200 }), async (base) => {
-    const body = await (await fetch(`${base}/api/r/stub/sessions`)).json();
-    assert.equal(body.ok, false);
-    assert.match(body.error, /sessions/);
-    assert.match(body.error, /timed out/i);
-  });
-});
-
-test('/api/r: malformed CLI output returns the raw output', async () => {
-  const cli = stubCli({ resources: ['sessions'] });
-  delete cli.discover;
-  cli.env = { STUB_RAW: 'this is not json' };
-  await withServer(makeConfig({ stub: cli }), async (base) => {
-    const body = await (await fetch(`${base}/api/r/stub/sessions`)).json();
-    assert.equal(body.ok, false);
-    assert.match(body.raw, /this is not json/);
-  });
-});
-
-test('/api/r: concurrent requests for the same resource coalesce into one exec', async () => {
-  const countFile = join(tmp, 'count-coalesce.txt');
-  const cli = stubCli({ resources: ['sessions'] });
-  delete cli.discover;
-  cli.env = { STUB_COUNT_FILE: countFile, STUB_SLEEP_MS: '150' };
-  await withServer(makeConfig({ stub: cli }), async (base) => {
-    const bodies = await Promise.all(
-      Array.from({ length: 5 }, () => fetch(`${base}/api/r/stub/sessions`).then((r) => r.json())),
-    );
-    for (const body of bodies) assert.equal(body.ok, true);
-    const calls = readFileSync(countFile, 'utf8').trim().split('\n');
-    assert.equal(calls.length, 1);
-  });
-});
-
-// ------------------------------------------------------------- /api/view
-
-test('/api/view: runs a view plugin with a bound fetch helper', async () => {
-  const viewsDir = join(tmp, 'views');
-  writeFileSync(join(viewsDir, '..', 'placeholder'), ''); // ensure tmp exists
-  const { mkdirSync } = await import('node:fs');
-  mkdirSync(viewsDir, { recursive: true });
-  writeFileSync(
-    join(viewsDir, 'stub-overview.js'),
-    'export default async function ({ fetch }) {\n' +
-    '  const rows = await fetch("sessions");\n' +
-    '  return { count: rows.length, first: rows[0].id };\n' +
-    '}\n',
-  );
-  await withServer(makeConfig({ stub: stubCli() }, { viewsDir }), async (base) => {
-    const res = await fetch(`${base}/api/view/stub/overview`);
-    assert.equal(res.status, 200);
-    const body = await res.json();
-    assert.equal(body.ok, true);
-    assert.deepEqual(body.result, { count: 2, first: 'sessions-1' });
-  });
-});
-
-test('/api/view: missing view → 404; bad view name → 404', async () => {
-  await withServer(makeConfig({ stub: stubCli() }, { viewsDir: join(tmp, 'views') }), async (base) => {
-    assert.equal((await fetch(`${base}/api/view/stub/nope`)).status, 404);
-    assert.equal((await fetch(`${base}/api/view/stub/..%2F..%2Fserver`)).status, 404);
-  });
-});
-
-// ------------------------------------------------------------- static files
-
-test('GET /: serves the dashboard index.html', async () => {
-  await withServer(makeConfig({ stub: stubCli() }), async (base) => {
-    const res = await fetch(`${base}/`);
-    assert.equal(res.status, 200);
-    assert.match(res.headers.get('content-type'), /text\/html/);
-    assert.match(await res.text(), /clidash/i);
-  });
-});
-
-test('static: path traversal outside public/ is rejected', async () => {
-  await withServer(makeConfig({ stub: stubCli() }), async (base) => {
-    const res = await fetch(`${base}/..%2Fserver.js`);
-    assert.notEqual(res.status, 200);
-  });
-});
-
-test('/api/r: {resource} substitutes inside a larger argv string (ssh-remote pattern)', async () => {
-  const cli = {
-    bin: process.execPath,
-    resources: ['sessions'],
-    list: [STUB, 'wrapped-{resource}-arg', 'list'],
-    output: 'json',
-    unwrap: 'data',
-    env: { STUB_COUNT_FILE: join(tmp, 'count-embed.txt') },
-  };
-  await withServer(makeConfig({ stub: cli }), async (base) => {
-    const body = await (await fetch(`${base}/api/r/stub/sessions`)).json();
-    assert.equal(body.ok, true);
-    const calls = readFileSync(join(tmp, 'count-embed.txt'), 'utf8').trim();
-    assert.equal(calls, 'wrapped-sessions-arg list');
-  });
-});

.claude/skills/add-clidash/add/tools/clidash/test/smoke.sh

@@ -1,21 +0,0 @@
-#!/usr/bin/env bash
-# Smoke test against a running clidash instance (run on the VM after deploy).
-# Usage: ./test/smoke.sh [base-url]   (default http://127.0.0.1:4690)
-set -euo pipefail
-BASE="${1:-http://127.0.0.1:4690}"
-
-check() {
-  local label="$1" url="$2" pattern="$3"
-  if curl -fsS --max-time 15 "$url" | grep -q "$pattern"; then
-    echo "OK   $label"
-  else
-    echo "FAIL $label ($url did not match $pattern)"
-    exit 1
-  fi
-}
-
-check "/api/clis"             "$BASE/api/clis"             '"resources"'
-check "/api/r/ncl/sessions"   "$BASE/api/r/ncl/sessions"   '"ok":true'
-check "/api/view/ncl/overview" "$BASE/api/view/ncl/overview" '"ok":true'
-check "GET / (static UI)"     "$BASE/"                     'clidash'
-echo "smoke: all good"

.claude/skills/add-clidash/add/tools/clidash/views/ncl-overview.js

@@ -1,60 +0,0 @@
-// Curated "Agents overview" view for ncl: joins groups + sessions +
-// messaging-groups + wirings into per-agent cards. Returns the generic
-// card shape the frontend renders, so the UI itself stays CLI-agnostic:
-//   { title, cards: [{ title, subtitle, status, fields, badges }] }
-// status: green <15m since last_active, amber <2h, red older, gray never.
-
-const GREEN_MAX_MIN = 15;
-const AMBER_MAX_MIN = 120;
-
-function staleness(lastActive) {
-  if (!lastActive) return 'gray';
-  const ageMin = (Date.now() - new Date(lastActive).getTime()) / 60_000;
-  if (ageMin < GREEN_MAX_MIN) return 'green';
-  if (ageMin < AMBER_MAX_MIN) return 'amber';
-  return 'red';
-}
-
-export default async function overview({ fetch }) {
-  const [groups, sessions, messagingGroups, wirings] = await Promise.all([
-    fetch('groups'),
-    fetch('sessions'),
-    fetch('messaging-groups'),
-    fetch('wirings'),
-  ]);
-
-  const mgById = new Map(messagingGroups.map((mg) => [mg.id, mg]));
-
-  const cards = groups.map((group) => {
-    const groupSessions = sessions.filter((s) => s.agent_group_id === group.id);
-    const lastActive = groupSessions
-      .map((s) => s.last_active)
-      .filter(Boolean)
-      .sort()
-      .at(-1) ?? null;
-    const container = groupSessions.some((s) => s.container_status === 'running')
-      ? 'running'
-      : groupSessions[0]?.container_status ?? 'none';
-
-    const badges = wirings
-      .filter((w) => w.agent_group_id === group.id)
-      .map((w) => {
-        const mg = mgById.get(w.messaging_group_id);
-        return mg ? `${mg.channel_type}: ${mg.name ?? mg.platform_id}` : w.messaging_group_id;
-      });
-
-    return {
-      title: group.name,
-      subtitle: group.folder,
-      status: staleness(lastActive),
-      fields: {
-        container,
-        sessions: groupSessions.length,
-        'last active': lastActive,
-      },
-      badges,
-    };
-  });
-
-  return { title: 'Agents overview', cards };
-}

.claude/skills/add-dashboard/resources/dashboard-pusher.ts

@@ -427,20 +427,12 @@ function collectContextWindows() {
   return results;
 }
 
-// "YYYY-MM-DDTHH" in the host's local time — the chart's hour labels are read
-// by a human, so bucket by local hour, not UTC. sv-SE renders "YYYY-MM-DD HH".
-function localHourKey(d: Date): string {
-  return d
-    .toLocaleString('sv-SE', { year: 'numeric', month: '2-digit', day: '2-digit', hour: '2-digit', hour12: false })
-    .replace(' ', 'T');
-}
-
 function collectActivity() {
   const now = Date.now();
   const buckets: Record<string, { inbound: number; outbound: number }> = {};
 
   for (let i = 0; i < 24; i++) {
-    const key = localHourKey(new Date(now - i * 3600000));
+    const key = new Date(now - i * 3600000).toISOString().slice(0, 13);
     buckets[key] = { inbound: 0, outbound: 0 };
   }
 
@@ -461,7 +453,7 @@ function collectActivity() {
             const table = direction === 'outbound' ? 'messages_out' : 'messages_in';
             const rows = db.prepare(`SELECT timestamp FROM ${table} WHERE timestamp > ?`).all(cutoff) as { timestamp: string }[];
             for (const row of rows) {
-              const key = localHourKey(new Date(row.timestamp));
+              const key = row.timestamp.slice(0, 13);
               if (buckets[key]) buckets[key][direction]++;
             }
             db.close();

.claude/skills/add-deltachat/SKILL.md

@@ -167,14 +167,7 @@ pnpm exec tsx scripts/init-first-agent.ts \
 
 ### Groups
 
-Add the bot email to a DeltaChat group. When any member sends a message, the router creates a `messaging_groups` row with `is_group = 1`. Run `/manage-channels` to wire it to an agent group, or wire it directly with `ncl` — **the host service must be running** (`ncl` connects to it over a Unix socket):
-
-```bash
-# Engage mode/pattern default to the DeltaChat adapter's declared channel
-# defaults — for DeltaChat groups that's a name pattern (the platform has no
-# mention metadata), so the agent responds when addressed by name.
-ncl wirings create --messaging-group-id <mg-id> --agent-group-id <ag-id>
-```
+Add the bot email to a DeltaChat group. When any member sends a message, the router creates a `messaging_groups` row with `is_group = 1`. Run `/manage-channels` to wire it to an agent group.
 
 ## Next Steps
 
@@ -191,7 +184,7 @@ Otherwise, run `/init-first-agent` to create an agent and wire it to your DeltaC
 - **user-id-format**: `deltachat:{email}` — the contact's email address
 - **how-to-find-id**: Send a message from DeltaChat to the bot email, then query `messaging_groups` as shown above
 - **typical-use**: Personal assistant over DeltaChat DMs; small groups where participants use DeltaChat
-- **default-isolation**: One agent per bot identity. Multiple chats with the same operator can share an agent group; groups with other people should typically get their own agent group (the default `shared` session mode already gives each messaging group its own session)
+- **default-isolation**: One agent per bot identity. Multiple chats with the same operator can share an agent group; groups with other people should typically use `isolated` session mode
 
 ### Features
 

.claude/skills/add-emacs/SKILL.md

@@ -105,14 +105,6 @@ pnpm exec tsx setup/index.ts --step register -- \
 
 `agent-shared` puts Emacs messages in the same session as any other channel wired to the same agent group — so a conversation you started in Telegram continues in Emacs. Use `shared` to keep an independent Emacs thread with the same workspace, or a new `--folder` for a dedicated Emacs-only agent.
 
-Alternatively create the rows with `ncl` — **the host service must be running** (`ncl` connects to it over a Unix socket). Engage mode/pattern and `unknown_sender_policy` default to the Emacs adapter's declared channel defaults:
-
-```bash
-ncl messaging-groups create --channel-type emacs --platform-id "default" --name "Emacs"
-ncl wirings create --messaging-group-id <mg-id-from-above> --agent-group-id <ag-id> \
-  --session-mode agent-shared
-```
-
 ## Configure Emacs
 
 `nanoclaw.el` needs only Emacs 27.1+ builtins (`url`, `json`, `org`) — no package manager.

.claude/skills/add-gcal-tool/REMOVE.md

@@ -18,7 +18,7 @@ There is no `ncl groups config remove-mount` verb yet (tracked in [#2395](https:
 pnpm exec tsx scripts/q.ts data/v2.db "UPDATE container_configs \
   SET additional_mounts = (SELECT json_group_array(value) FROM json_each(additional_mounts) \
                            WHERE json_extract(value, '\$.containerPath') != '.calendar-mcp'), \
-      updated_at = strftime('%Y-%m-%dT%H:%M:%fZ','now') \
+      updated_at = datetime('now') \
   WHERE agent_group_id = '<group-id>';"
 ```
 

.claude/skills/add-gcal-tool/SKILL.md

@@ -168,11 +168,11 @@ HOST_PATH="$HOME/.calendar-mcp"
 MOUNT=$(jq -cn --arg h "$HOST_PATH" '{hostPath:$h, containerPath:".calendar-mcp", readonly:false}')
 pnpm exec tsx scripts/q.ts data/v2.db "UPDATE container_configs \
   SET additional_mounts = json_insert(additional_mounts, '\$[#]', json('$MOUNT')), \
-      updated_at = strftime('%Y-%m-%dT%H:%M:%fZ','now') \
+      updated_at = datetime('now') \
   WHERE agent_group_id = '$GROUP_ID';"
 ```
 
-Run from your NanoClaw project root (where `data/v2.db` lives). The `$[#]` placeholder is SQLite JSON1's append-to-end notation; it's `\$`-escaped so bash doesn't arithmetic-expand it before sqlite sees it. `updated_at` is an ISO-with-Z string everywhere else in the schema (`new Date().toISOString()`), so stamp the same shape with `strftime` — plain `datetime('now')` would mix naive UTC strings into the column, and `strftime('%s','now')` epoch ints.
+Run from your NanoClaw project root (where `data/v2.db` lives). The `$[#]` placeholder is SQLite JSON1's append-to-end notation; it's `\$`-escaped so bash doesn't arithmetic-expand it before sqlite sees it. `updated_at` is ISO-string everywhere else in the schema, so use `datetime('now')` — not `strftime('%s','now')`, which would silently mix epoch ints into a column of YYYY-MM-DD HH:MM:SS strings.
 
 **Switch to `ncl groups config add-mount` once #2395 lands.** Update this skill at that time.
 

.claude/skills/add-github/SKILL.md

@@ -107,17 +107,16 @@ Ask the user: **Is this a private or public repo?**
 - **Private repo** — use `unknown_sender_policy: 'public'`. Only collaborators can comment anyway, so it's safe to let all comments through.
 - **Public repo** — use `unknown_sender_policy: 'strict'`. Only registered members can trigger the agent, preventing strangers from consuming agent resources. Add trusted collaborators as members (see below).
 
-Run `/manage-channels` to wire the GitHub channel to an agent group, or create the rows directly with `ncl`. **The host service must be running** — `ncl` connects to it over a Unix socket:
+Run `/manage-channels` to wire the GitHub channel to an agent group, or insert manually:
 
-```bash
-# Create messaging group (one per repo)
-ncl messaging-groups create --channel-type github --platform-id "github:owner/repo" \
-  --name "owner/repo" --is-group 1 --unknown-sender-policy <policy>
+```sql
+-- Create messaging group (one per repo)
+INSERT INTO messaging_groups (id, channel_type, platform_id, instance, name, is_group, unknown_sender_policy, created_at)
+VALUES ('mg-github-myrepo', 'github', 'github:owner/repo', 'github', 'owner/repo', 1, '<policy>', datetime('now'));
 
-# Wire to agent group (engage mode/pattern default to the GitHub adapter's
-# declared channel defaults; grab the mg id from the create output above)
-ncl wirings create --messaging-group-id <mg-id> --agent-group-id <your-agent-group-id> \
-  --session-mode per-thread
+-- Wire to agent group
+INSERT INTO messaging_group_agents (id, messaging_group_id, agent_group_id, trigger_rules, response_scope, session_mode, priority, created_at)
+VALUES ('mga-github-myrepo', 'mg-github-myrepo', '<your-agent-group-id>', '', 'all', 'per-thread', 10, datetime('now'));
 ```
 
 Replace `<policy>` with `public` or `strict` based on the user's choice above.
@@ -126,12 +125,14 @@ Replace `<policy>` with `public` or `strict` based on the user's choice above.
 
 When using `strict`, add each GitHub user who should be able to trigger the agent:
 
-```bash
-# Add user (kind = 'github', id = 'github:<numeric-user-id>')
-ncl users create --id "github:<user-id>" --kind github --display-name "<username>"
+```sql
+-- Add user (kind = 'github', id = 'github:<numeric-user-id>')
+INSERT OR IGNORE INTO users (id, kind, display_name, created_at)
+VALUES ('github:<user-id>', 'github', '<username>', datetime('now'));
 
-# Grant membership to the agent group
-ncl members add --user "github:<user-id>" --group "<agent-group-id>"
+-- Grant membership to the agent group
+INSERT OR IGNORE INTO agent_group_members (user_id, agent_group_id)
+VALUES ('github:<user-id>', '<agent-group-id>');
 ```
 
 To find a GitHub user's numeric ID: `gh api users/<username> --jq .id`

.claude/skills/add-gmail-tool/REMOVE.md

@@ -26,7 +26,7 @@ GROUP_ID='<group-id>'
 pnpm exec tsx scripts/q.ts data/v2.db "UPDATE container_configs \
   SET additional_mounts = (SELECT json_group_array(value) FROM json_each(additional_mounts) \
                            WHERE json_extract(value, '\$.containerPath') != '.gmail-mcp'), \
-      updated_at = strftime('%Y-%m-%dT%H:%M:%fZ','now') \
+      updated_at = datetime('now') \
   WHERE agent_group_id = '$GROUP_ID';"
 ```
 

.claude/skills/add-gmail-tool/SKILL.md

@@ -189,11 +189,11 @@ HOST_PATH="$HOME/.gmail-mcp"
 MOUNT=$(jq -cn --arg h "$HOST_PATH" '{hostPath:$h, containerPath:".gmail-mcp", readonly:false}')
 pnpm exec tsx scripts/q.ts data/v2.db "UPDATE container_configs \
   SET additional_mounts = json_insert(additional_mounts, '\$[#]', json('$MOUNT')), \
-      updated_at = strftime('%Y-%m-%dT%H:%M:%fZ','now') \
+      updated_at = datetime('now') \
   WHERE agent_group_id = '$GROUP_ID';"
 ```
 
-Run from your NanoClaw project root (where `data/v2.db` lives). The `$[#]` placeholder is SQLite JSON1's append-to-end notation; it's `\$`-escaped so bash doesn't arithmetic-expand it before sqlite sees it. `updated_at` is an ISO-with-Z string everywhere else in the schema (`new Date().toISOString()`), so stamp the same shape with `strftime` — plain `datetime('now')` would mix naive UTC strings into the column, and `strftime('%s','now')` epoch ints.
+Run from your NanoClaw project root (where `data/v2.db` lives). The `$[#]` placeholder is SQLite JSON1's append-to-end notation; it's `\$`-escaped so bash doesn't arithmetic-expand it before sqlite sees it. `updated_at` is ISO-string everywhere else in the schema, so use `datetime('now')` — not `strftime('%s','now')`, which would silently mix epoch ints into a column of YYYY-MM-DD HH:MM:SS strings.
 
 **Switch to `ncl groups config add-mount` once #2395 lands.** Update this skill at that time.
 

.claude/skills/add-linear/SKILL.md

@@ -115,20 +115,19 @@ Ask the user: **Is this a private or public Linear workspace?**
 - **Private workspace** — use `unknown_sender_policy: 'public'`. Only workspace members can comment.
 - **Public workspace** — use `unknown_sender_policy: 'strict'` and add trusted members (see GitHub skill for member registration example).
 
-Run `/manage-channels` to wire the Linear channel to an agent group, or create the rows directly with `ncl`. **The host service must be running** — `ncl` connects to it over a Unix socket:
+Run `/manage-channels` to wire the Linear channel to an agent group, or insert manually:
 
-```bash
-# Create messaging group (one per team)
-ncl messaging-groups create --channel-type linear --platform-id "linear:ENG" \
-  --name "Engineering" --is-group 1 --unknown-sender-policy <policy>
+```sql
+-- Create messaging group (one per team)
+INSERT INTO messaging_groups (id, channel_type, platform_id, instance, name, is_group, unknown_sender_policy, created_at)
+VALUES ('mg-linear-eng', 'linear', 'linear:ENG', 'linear', 'Engineering', 1, 'public', datetime('now'));
 
-# Wire to agent group (engage mode/pattern default to the Linear adapter's
-# declared channel defaults; grab the mg id from the create output above)
-ncl wirings create --messaging-group-id <mg-id> --agent-group-id <your-agent-group-id> \
-  --session-mode per-thread
+-- Wire to agent group
+INSERT INTO messaging_group_agents (id, messaging_group_id, agent_group_id, trigger_rules, response_scope, session_mode, priority, created_at)
+VALUES ('mga-linear-eng', 'mg-linear-eng', '<your-agent-group-id>', '', 'all', 'per-thread', 10, datetime('now'));
 ```
 
-Replace `<policy>` with `public` or `strict` based on the user's choice above. The `platform_id` must be `linear:<TEAM_KEY>` matching the `LINEAR_TEAM_KEY` env var. Use `per-thread` session mode so each issue comment thread gets its own agent session.
+The `platform_id` must be `linear:<TEAM_KEY>` matching the `LINEAR_TEAM_KEY` env var. Use `per-thread` session mode so each issue comment thread gets its own agent session.
 
 ## Next Steps
 

.claude/skills/add-mnemon/SKILL.md

@@ -9,13 +9,13 @@ Installs [mnemon](https://github.com/mnemon-dev/mnemon) in the agent container i
 
 ## Provider Compatibility
 
-mnemon hooks fire only under `--target claude-code`. Use this skill on agent groups that run the default Claude provider. The provider is the materialized `provider` key in each group's `container.json` (absent or `claude` = default Claude provider). Confirm it before applying:
+mnemon hooks fire only under `--target claude-code`. Use this skill on agent groups that run the default Claude provider (`AGENT_PROVIDER=claude`). Confirm the provider before applying:
 
 ```bash
-grep -H '"provider"' groups/*/container.json 2>/dev/null   # no match, or "provider": "claude" = Claude
+grep AGENT_PROVIDER .env groups/*/container.json 2>/dev/null
 ```
 
-If a group sets a different provider (e.g. `"provider": "opencode"`), it spawns its own process and never invokes the `claude` CLI, so the hooks registered by `mnemon setup` do not run for that group.
+If a group uses a different provider (e.g. `AGENT_PROVIDER=opencode`), it spawns its own process and never invokes the `claude` CLI, so the hooks registered by `mnemon setup` do not run for that group.
 
 ## Phase 1: Pre-flight
 

.claude/skills/add-opencode/SKILL.md

@@ -1,11 +1,11 @@
 ---
 name: add-opencode
-description: Use OpenCode as an agent provider. OpenRouter, OpenAI, Google, DeepSeek, etc. via OpenCode config — not the Anthropic Agent SDK. Per group via `ncl groups config update --provider opencode`; host passes OPENCODE_* and XDG mount when spawning containers.
+description: Use OpenCode as an agent provider (AGENT_PROVIDER=opencode). OpenRouter, OpenAI, Google, DeepSeek, etc. via OpenCode config — not the Anthropic Agent SDK. Per-session and per-group via agent_provider; host passes OPENCODE_* and XDG mount when spawning containers.
 ---
 
 # OpenCode agent provider
 
-NanoClaw runs agents in a long-lived **poll loop** inside the container. The backend is selected per agent group by the **`provider`** key in that group's `container.json` (materialized from the `container_configs` table) — set it with `ncl groups config update --provider opencode`. Default is `claude`.
+NanoClaw runs agents in a long-lived **poll loop** inside the container. The backend is selected with **`AGENT_PROVIDER`** (`claude` | `opencode` | `mock`).
 
 Trunk ships with only the `claude` provider baked in. This skill copies the OpenCode provider files in from the `providers` branch, wires them into the host and container barrels, installs dependencies, and rebuilds the image.
 
@@ -148,7 +148,7 @@ done
 
 Set model/provider strings in the form OpenCode expects (often `provider/model-id`). **Put comments on their own lines** — a `#` inside a value is kept verbatim and breaks model IDs.
 
-These variables are read **on the host** and passed into the container only when the effective provider is `opencode`. They do not switch the provider by themselves; the group still needs `provider` set to `opencode` (see [Select the provider](#select-the-provider) below).
+These variables are read **on the host** and passed into the container only when the effective provider is `opencode`. They do not switch the provider by themselves; the DB still needs `agent_provider` set (below).
 
 - `OPENCODE_PROVIDER` — OpenCode provider id, e.g. `openrouter`, `anthropic`, `deepseek`.
 - `OPENCODE_MODEL` — full model id in `provider/model` form, e.g. `deepseek/deepseek-chat`.
@@ -215,7 +215,7 @@ OPENCODE_SMALL_MODEL=anthropic/claude-haiku-4-5-20251001
 
 Zen's HTTP API (e.g. `POST …/zen/v1/messages`) expects the key in the **`x-api-key`** header. If OneCLI injects **`Authorization: Bearer …`** only, Zen often returns **401 / "Missing API key"** even though the gateway is working.
 
-**Naming:** NanoClaw's **`provider: opencode`** (the `container.json` key, set via `ncl groups config update --provider opencode`) means "run the **OpenCode agent provider**." Separately, **`OPENCODE_PROVIDER=opencode`** in `.env` is OpenCode's **Zen provider id** inside the OpenCode config (see [Zen docs](https://opencode.ai/docs/zen/)).
+**Naming:** NanoClaw **`AGENT_PROVIDER=opencode`** (DB `agent_provider`) means "run the **OpenCode agent provider**." Separately, **`OPENCODE_PROVIDER=opencode`** in `.env` is OpenCode's **Zen provider id** inside the OpenCode config (see [Zen docs](https://opencode.ai/docs/zen/)).
 
 **Host `.env` (typical Zen shape):**
 
@@ -236,16 +236,9 @@ onecli secrets create --name "OpenCode Zen" --type generic \
   --header-name "x-api-key" --value-format "{value}"
 ```
 
-### Select the provider
+### Per group / per session
 
-Per group, from the host:
-
-```bash
-ncl groups config update --id <group-id> --provider opencode
-ncl groups restart --id <group-id>
-```
-
-`ncl groups config update --provider` writes the `provider` value into the `container_configs` table; the host materializes it into `groups/<folder>/container.json` at spawn time and the in-container runner reads `provider` from there (defaulting to `claude`). The restart picks up the change. Switching is an operator action — run it from the host. Memory does NOT carry over automatically between providers — run `/migrate-memory` to carry it across.
+Set `"provider": "opencode"` in the group's **`container.json`** (`groups/<folder>/container.json`) — the in-container runner reads `provider` from there, not from the DB. The DB columns **`agent_groups.agent_provider`** and **`sessions.agent_provider`** (session overrides group) only drive host-side provider contribution — per-session XDG mount, `OPENCODE_*` env passthrough — and do not propagate into `container.json` at spawn time. Set both, or just edit `container.json`; if they disagree, the runner uses `container.json` and the host-side resolver falls back through session → group → `container.json` → `'claude'`.
 
 Extra MCP servers still come from **`NANOCLAW_MCP_SERVERS`** / `container_config.mcpServers` on the host; the runner merges them into the same `mcpServers` object passed to **both** Claude and OpenCode providers.
 
@@ -257,6 +250,6 @@ Extra MCP servers still come from **`NANOCLAW_MCP_SERVERS`** / `container_config
 
 ## Next Steps
 
-The registration and Dockerfile guards in step 7 verify the wiring. To confirm an end-to-end round-trip, switch a test group with `ncl groups config update --id <group-id> --provider opencode && ncl groups restart --id <group-id>`, register the matching provider key in OneCLI, and send a message. A clean exchange returns the model's reply with no `Unknown provider: opencode` error and no UUID/session warnings in the logs.
+The registration and Dockerfile guards in step 7 verify the wiring. To confirm an end-to-end round-trip, set `agent_provider = 'opencode'` (or `"provider": "opencode"` in the group's `container.json`) on a test group, register the matching provider key in OneCLI, and send a message. A clean exchange returns the model's reply with no `Unknown provider: opencode` error and no UUID/session warnings in the logs.
 
 To remove this provider, see [REMOVE.md](REMOVE.md).

.claude/skills/add-signal/SKILL.md

@@ -220,21 +220,30 @@ Pass the `id` to `/init-first-agent` or `/manage-channels` to wire it to an agen
 
 ### Groups
 
-Add the Signal number to a group from your phone, send any message, then wire the resulting row the same way. Each group gets its own session with the default `shared` mode (one session per agent + messaging group). Create the wiring with `ncl` — **the host service must be running** (`ncl` connects to it over a Unix socket):
+Add the Signal number to a group from your phone, send any message, then wire the resulting row the same way. For isolated per-group sessions:
 
 ```bash
-# Engage mode/pattern default to the Signal adapter's declared channel defaults
-ncl wirings create --messaging-group-id mg-GROUPID --agent-group-id ag-AGENTID
+NOW=$(date -u +"%Y-%m-%dT%H:%M:%S.000Z")
+pnpm exec tsx scripts/q.ts data/v2.db "
+INSERT OR IGNORE INTO messaging_group_agents
+  (id, messaging_group_id, agent_group_id, session_mode, priority, created_at)
+VALUES
+  ('mga-'||hex(randomblob(8)), 'mg-GROUPID', 'ag-AGENTID', 'isolated', 0, '$NOW');
+"
 ```
 
 ### Grant user access
 
-New Signal users (including the owner's Signal identity) are silently dropped with `not_member` until granted access. After the user's first message appears in `messaging_groups` (host service running):
+New Signal users (including the owner's Signal identity) are silently dropped with `not_member` until granted access. After the user's first message appears in `messaging_groups`:
 
 ```bash
-ncl users create --id "signal:UUID" --kind signal --display-name "<name>"
-ncl roles grant --user "signal:UUID" --role owner
-ncl members add --user "signal:UUID" --group ag-AGENTID
+NOW=$(date -u +"%Y-%m-%dT%H:%M:%S.000Z")
+pnpm exec tsx scripts/q.ts data/v2.db "
+INSERT OR REPLACE INTO user_roles (user_id, role, agent_group_id, granted_by, granted_at)
+  VALUES ('signal:UUID', 'owner', NULL, 'system', '$NOW');
+INSERT OR IGNORE INTO agent_group_members (user_id, agent_group_id, added_by, added_at)
+  VALUES ('signal:UUID', 'ag-AGENTID', 'system', '$NOW');
+"
 ```
 
 Find the UUID from `messaging_groups.platform_id` or the `users` table.
@@ -255,7 +264,7 @@ Otherwise, run `/init-first-agent` to create an agent and wire it to your Signal
   - Group: `signal:{base64GroupId}` — base64-encoded GroupV2 ID
 - **how-to-find-id**: Send a message to the bot, then query `messaging_groups` as shown above
 - **typical-use**: Personal assistant via Signal DMs or small group chats
-- **default-isolation**: One agent per Signal account. Multiple chats with the same operator can share an agent group; groups with other people should typically get their own agent group (the default `shared` session mode already gives each messaging group its own session)
+- **default-isolation**: One agent per Signal account. Multiple chats with the same operator can share an agent group; groups with other people should typically use `isolated` session mode
 
 ### Features
 

.claude/skills/add-slack/SKILL.md

@@ -18,7 +18,6 @@ Skip to **Credentials** if all of these are already in place:
 - `src/channels/slack.ts` exists
 - `src/channels/slack-registration.test.ts` exists
 - `src/channels/index.ts` contains `import './slack.js';`
-- `container/skills/slack-formatting/SKILL.md` exists
 - `@chat-adapter/slack` is listed in `package.json` dependencies
 
 Otherwise continue. Every step below is safe to re-run.
@@ -34,15 +33,8 @@ git fetch origin channels
 ```bash
 git show origin/channels:src/channels/slack.ts                 > src/channels/slack.ts
 git show origin/channels:src/channels/slack-registration.test.ts > src/channels/slack-registration.test.ts
-mkdir -p container/skills/slack-formatting
-git show origin/channels:container/skills/slack-formatting/SKILL.md > container/skills/slack-formatting/SKILL.md
 ```
 
-The `slack-formatting` container skill is part of the channel payload: it
-reaches agents via `~/.claude/skills` (synced at spawn) and teaches Slack's
-mrkdwn syntax. Trunk does not ship it — without this copy step agents send
-Slack messages with generic markdown that renders literally.
-
 ### 3. Append the self-registration import
 
 Append to `src/channels/index.ts` (skip if the line is already present):

.claude/skills/add-wechat/SKILL.md

@@ -121,11 +121,9 @@ The bot is now connected as your WeChat account.
 
 A successful QR login alone isn't enough — the adapter still needs to be wired to an agent group before it can respond.
 
-**Prerequisite: the host service must be running.** The wire script creates the wiring through `ncl`, which talks to the running host over a Unix socket — there is no offline mode.
-
 ### 1. Trigger the first inbound message
 
-Have a different WeChat account send a message to the bot account. This auto-creates a `messaging_groups` row with the sender's `platform_id` and the `unknown_sender_policy` the WeChat adapter declares.
+Have a different WeChat account send a message to the bot account. This auto-creates a `messaging_groups` row with the sender's `platform_id`.
 
 ### 2. Run the wire script
 
@@ -133,9 +131,9 @@ Have a different WeChat account send a message to the bot account. This auto-cre
 pnpm exec tsx .claude/skills/add-wechat/scripts/wire-dm.ts
 ```
 
-Interactive flow: the script lists all unwired WeChat messaging groups, asks which agent group to wire it to, and runs `ncl wirings create` — engage mode/pattern and priority come from the WeChat adapter's declared channel defaults, so a wiring created here matches one created by `/manage-channels` or the approval-card flow.
+Interactive flow: the script lists all unwired WeChat messaging groups, asks which agent group to wire it to, and creates the `messaging_group_agents` row with sensible defaults (sender policy `request_approval`, session mode `shared`).
 
-With `request_approval` as the sender policy, the next DM from a stranger fires an approval card to the admin — admin taps Approve/Deny, approved users are added as members and their queued message replays through the agent.
+With `request_approval`, the next DM from the stranger fires an approval card to the admin — admin taps Approve/Deny, approved users are added as members and their queued message replays through the agent.
 
 Non-interactive:
 
@@ -149,16 +147,10 @@ pnpm exec tsx .claude/skills/add-wechat/scripts/wire-dm.ts \
 Flags:
 
 - `--platform-id <id>` — wire a specific messaging group (default: most recent unwired)
-- `--agent-group <id>` — target agent group (default: prompt; auto-picked when only one exists)
-- `--sender-policy public|strict|request_approval` — override the messaging group's `unknown_sender_policy` (default: leave whatever the WeChat adapter declared when the row was auto-created)
+- `--agent-group <id>` — target agent group (default: prompt; or solo admin group in non-interactive)
+- `--sender-policy public|strict|request_approval` — default `request_approval` (fires an admin approval card on unknown-sender DMs)
 - `--session-mode shared|per-thread` — default `shared`
 
-Equivalent raw `ncl` invocation (host must be running):
-
-```bash
-ncl wirings create --messaging-group-id <mg-id> --agent-group-id <ag-id> --session-mode shared
-```
-
 ### 3. Test
 
 Have the sender message the bot again — the agent should respond.

.claude/skills/add-wechat/scripts/wire-dm.ts

@@ -5,49 +5,43 @@
  * After /add-wechat installs the adapter and the user scans the QR login,
  * the first inbound message from another WeChat account auto-creates a
  * `messaging_groups` row. This script finds that row, asks the operator
- * which agent group to wire it to, and creates the wiring via
- * `ncl wirings create` — engage mode/pattern and priority come from the
- * WeChat adapter's declared channel defaults, not from SQL baked into this
- * script, so it can't drift against schema migrations.
+ * which agent group to wire it to, and inserts the `messaging_group_agents`
+ * join row with sensible defaults — the "post-login wiring" step /add-wechat
+ * otherwise requires manual SQL for.
  *
- * PREREQUISITE: the NanoClaw host service must be RUNNING — `ncl` talks to
- * it over a Unix socket and has no offline mode.
- *
- * Usage (from the project root):
+ * Usage:
  *   pnpm exec tsx .claude/skills/add-wechat/scripts/wire-dm.ts
  *
  * Flags:
  *   --platform-id <id>      Wire a specific messaging group (default: most recent unwired)
- *   --agent-group <id>      Target agent group (default: interactive pick; auto-picked when only one exists)
- *   --sender-policy <p>     public | strict | request_approval — overrides the
- *                           channel-declared unknown_sender_policy on the
- *                           messaging group (default: leave as the adapter declared)
+ *   --agent-group <id>      Target agent group (default: interactive pick; or solo admin group)
+ *   --sender-policy <p>     public | strict (default: public)
  *   --session-mode <m>      shared | per-thread (default: shared)
  *   --non-interactive       Fail instead of prompting
  */
-import { spawnSync } from 'node:child_process';
+import Database from 'better-sqlite3';
 import path from 'node:path';
 import readline from 'node:readline';
-import { fileURLToPath } from 'node:url';
 
-// <root>/.claude/skills/add-wechat/scripts/wire-dm.ts → <root>
-const PROJECT_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../../../..');
+const DB_PATH = process.env.NANOCLAW_DB_PATH ?? path.join(process.cwd(), 'data', 'v2.db');
 
 type SenderPolicy = 'public' | 'strict' | 'request_approval';
 
 interface Args {
   platformId?: string;
   agentGroupId?: string;
-  senderPolicy?: SenderPolicy;
+  senderPolicy: SenderPolicy;
   sessionMode: 'shared' | 'per-thread';
   interactive: boolean;
 }
 
 function parseArgs(argv: string[]): Args {
   const args: Args = {
-    // No --sender-policy default: the router already stamped the policy the
-    // WeChat adapter declares when it auto-created the messaging group.
-    // Only an explicit flag overrides it.
+    // Default matches the router's auto-create (`request_approval`) so the
+    // admin gets an approval card on the next unknown-sender DM rather than
+    // a silent allow. Pass `--sender-policy public` to open the channel to
+    // anyone, or `strict` to require explicit membership.
+    senderPolicy: 'request_approval',
     sessionMode: 'shared',
     interactive: true,
   };
@@ -74,90 +68,72 @@ function parseArgs(argv: string[]): Args {
   return args;
 }
 
-/** Run one ncl command against the running host and return its parsed data. */
-function ncl(...cliArgs: string[]): unknown {
-  const res = spawnSync('pnpm', ['exec', 'tsx', 'src/cli/client.ts', ...cliArgs, '--json'], {
-    cwd: PROJECT_ROOT,
-    encoding: 'utf-8',
-  });
-  if (res.error) throw res.error;
-  let frame: { ok: boolean; data?: unknown; error?: { message: string } } | undefined;
-  try {
-    frame = JSON.parse(res.stdout);
-  } catch {
-    // No frame — transport-level failure (host not running), reported on stderr.
-  }
-  if (frame && !frame.ok) throw new Error(`ncl ${cliArgs.join(' ')} failed: ${frame.error?.message}`);
-  if (!frame || res.status !== 0) {
-    const detail = (res.stderr || res.stdout || '').trim();
-    throw new Error(
-      `ncl ${cliArgs.join(' ')} failed:\n${detail}\n\n` +
-      'Is the NanoClaw host service running? ncl connects to it over a Unix socket.',
-    );
-  }
-  return frame.data;
-}
-
 async function prompt(q: string): Promise<string> {
   const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
   return new Promise((resolve) => rl.question(q, (a) => { rl.close(); resolve(a.trim()); }));
 }
 
-interface MgRow { id: string; platform_id: string; name: string | null; is_group: number; created_at: string }
-interface AgRow { id: string; name: string; created_at: string }
+function generateId(prefix: string): string {
+  return `${prefix}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+}
 
 async function main(): Promise<void> {
   const args = parseArgs(process.argv.slice(2));
-
-  const mgs = ncl('messaging-groups', 'list', '--channel-type', 'wechat') as MgRow[];
-  const wirings = ncl('wirings', 'list', '--limit', '10000') as Array<{ messaging_group_id: string }>;
-  const wiredMgIds = new Set(wirings.map((w) => w.messaging_group_id));
+  const db = new Database(DB_PATH);
+  db.pragma('journal_mode = WAL');
 
   // 1. Pick the messaging group
-  let mg: MgRow | undefined;
-  if (args.platformId) {
-    mg = mgs.find((r) => r.platform_id === args.platformId);
-    if (!mg) throw new Error(`no wechat messaging_group with platform_id = ${args.platformId}`);
-  } else {
-    const unwired = mgs
-      .filter((r) => !wiredMgIds.has(r.id))
-      .sort((a, b) => b.created_at.localeCompare(a.created_at));
+  let platformId = args.platformId;
+  if (!platformId) {
+    const rows = db.prepare(`
+      SELECT mg.id, mg.platform_id, mg.name, mg.is_group, mg.created_at
+      FROM messaging_groups mg
+      LEFT JOIN messaging_group_agents mga ON mga.messaging_group_id = mg.id
+      WHERE mg.channel_type = 'wechat' AND mga.id IS NULL
+      ORDER BY mg.created_at DESC
+    `).all() as Array<{ id: string; platform_id: string; name: string | null; is_group: number; created_at: string }>;
 
-    if (unwired.length === 0) {
+    if (rows.length === 0) {
       console.error('No unwired WeChat messaging groups found.');
       console.error('Send a message to the bot first (from another WeChat account), then re-run.');
       process.exit(1);
     }
 
-    if (unwired.length === 1 || !args.interactive) {
-      mg = unwired[0];
-      console.log(`Using most recent unwired group: ${mg.platform_id} (${mg.is_group ? 'group' : 'DM'})`);
+    if (rows.length === 1 || !args.interactive) {
+      platformId = rows[0].platform_id;
+      console.log(`Using most recent unwired group: ${platformId} (${rows[0].is_group ? 'group' : 'DM'})`);
     } else {
       console.log('Unwired WeChat messaging groups:');
-      unwired.forEach((r, i) => {
+      rows.forEach((r, i) => {
         console.log(`  ${i + 1}. ${r.platform_id}  (${r.is_group ? 'group' : 'DM'}, ${r.created_at})`);
       });
       const pick = await prompt('Pick one [1]: ');
       const idx = pick === '' ? 0 : parseInt(pick, 10) - 1;
-      if (Number.isNaN(idx) || idx < 0 || idx >= unwired.length) throw new Error('invalid choice');
-      mg = unwired[idx];
+      if (Number.isNaN(idx) || idx < 0 || idx >= rows.length) throw new Error('invalid choice');
+      platformId = rows[idx].platform_id;
     }
   }
 
+  const mg = db.prepare(
+    'SELECT id, platform_id, is_group FROM messaging_groups WHERE channel_type = ? AND platform_id = ?'
+  ).get('wechat', platformId) as { id: string; platform_id: string; is_group: number } | undefined;
+  if (!mg) throw new Error(`no wechat messaging_group with platform_id = ${platformId}`);
+
   // 2. Pick the agent group
   let agentGroupId = args.agentGroupId;
   if (!agentGroupId) {
-    const agents = (ncl('groups', 'list') as AgRow[])
-      .sort((a, b) => a.created_at.localeCompare(b.created_at));
+    const agents = db.prepare('SELECT id, name, is_admin FROM agent_groups ORDER BY is_admin DESC, created_at ASC')
+      .all() as Array<{ id: string; name: string; is_admin: number }>;
     if (agents.length === 0) throw new Error('no agent groups exist — create one first');
 
-    if (agents.length === 1) {
-      agentGroupId = agents[0].id;
-      console.log(`Auto-selected sole agent group: ${agents[0].name} (${agentGroupId})`);
+    const adminAgents = agents.filter((a) => a.is_admin === 1);
+    if (adminAgents.length === 1 && !args.interactive) {
+      agentGroupId = adminAgents[0].id;
+      console.log(`Auto-selected sole admin agent group: ${adminAgents[0].name} (${agentGroupId})`);
     } else if (args.interactive) {
       console.log('Agent groups:');
       agents.forEach((a, i) => {
-        console.log(`  ${i + 1}. ${a.name} (${a.id})`);
+        console.log(`  ${i + 1}. ${a.name} (${a.id})${a.is_admin ? ' [admin]' : ''}`);
       });
       const pick = await prompt('Pick one [1]: ');
       const idx = pick === '' ? 0 : parseInt(pick, 10) - 1;
@@ -168,29 +144,26 @@ async function main(): Promise<void> {
     }
   }
 
-  const ag = (ncl('groups', 'list') as AgRow[]).find((a) => a.id === agentGroupId);
+  const ag = db.prepare('SELECT id, name FROM agent_groups WHERE id = ?').get(agentGroupId) as
+    { id: string; name: string } | undefined;
   if (!ag) throw new Error(`no agent_group with id = ${agentGroupId}`);
 
-  // 3. Wire, then apply the optional policy override. Engage mode/pattern and
-  //    priority are filled by the wirings resolveDefaults hook from the WeChat
-  //    adapter's declared channel defaults. Policy update runs second so a
-  //    failed create (e.g. already wired) leaves the mg row untouched.
-  const wiring = ncl(
-    'wirings', 'create',
-    '--messaging-group-id', mg.id,
-    '--agent-group-id', ag.id,
-    '--session-mode', args.sessionMode,
-  ) as { engage_mode: string; engage_pattern: string | null };
-  if (args.senderPolicy) {
-    ncl('messaging-groups', 'update', mg.id, '--unknown-sender-policy', args.senderPolicy);
-  }
+  // 3. Update sender policy + wire
+  const tx = db.transaction(() => {
+    db.prepare('UPDATE messaging_groups SET unknown_sender_policy = ? WHERE id = ?')
+      .run(args.senderPolicy, mg.id);
+
+    db.prepare(`
+      INSERT INTO messaging_group_agents
+        (id, messaging_group_id, agent_group_id, trigger_rules, response_scope, session_mode, priority, created_at)
+      VALUES (?, ?, ?, '', 'all', ?, 10, datetime('now'))
+    `).run(generateId('mga'), mg.id, ag.id, args.sessionMode);
+  });
+  tx();
 
   console.log('');
-  console.log(
-    `WIRED platform_id=${mg.platform_id} agent_group=${ag.name} ` +
-    `engage=${wiring.engage_mode}${wiring.engage_pattern ? `(${wiring.engage_pattern})` : ''} ` +
-    `policy=${args.senderPolicy ?? '(channel default)'} mode=${args.sessionMode}`,
-  );
+  console.log(`WIRED platform_id=${mg.platform_id} agent_group=${ag.name} policy=${args.senderPolicy} mode=${args.sessionMode}`);
+  db.close();
 }
 
 main().catch((err) => {

.claude/skills/add-whatsapp/SKILL.md

@@ -20,7 +20,6 @@ Skip to **Credentials** if all of these are already in place:
 - `src/channels/whatsapp.test.ts` exists
 - `src/channels/index.ts` contains `import './whatsapp.js';`
 - `setup/whatsapp-auth.ts` and `setup/groups.ts` both exist
-- `container/skills/whatsapp-formatting/instructions.md` exists
 - `setup/index.ts`'s `STEPS` map contains both `'whatsapp-auth':` and `groups:`
 - `@whiskeysockets/baileys`, `qrcode`, `pino` are listed in `package.json` dependencies
 - `.claude/skills/add-whatsapp/scripts/wa-qr-browser.ts` exists (ships with this skill)
@@ -41,17 +40,8 @@ git show origin/channels:src/channels/whatsapp-registration.test.ts    > src/cha
 git show origin/channels:src/channels/whatsapp.test.ts                 > src/channels/whatsapp.test.ts
 git show origin/channels:setup/whatsapp-auth.ts                        > setup/whatsapp-auth.ts
 git show origin/channels:setup/groups.ts                               > setup/groups.ts
-mkdir -p container/skills/whatsapp-formatting
-git show origin/channels:container/skills/whatsapp-formatting/SKILL.md        > container/skills/whatsapp-formatting/SKILL.md
-git show origin/channels:container/skills/whatsapp-formatting/instructions.md > container/skills/whatsapp-formatting/instructions.md
 ```
 
-The `whatsapp-formatting` container skill is part of the channel payload: its
-`instructions.md` becomes the `skill-whatsapp-formatting.md` fragment in every
-group's composed CLAUDE.md (see `src/claude-md-compose.ts`), teaching agents
-WhatsApp's formatting syntax. Trunk does not ship it — without this copy step
-agents format WhatsApp messages with generic markdown that renders literally.
-
 ### 3. Append the self-registration import
 
 Append to `src/channels/index.ts` (skip if already present):
@@ -92,7 +82,7 @@ WhatsApp uses linked-device authentication — no API key, just a one-time pairi
 
 ### Check current state
 
-Check if WhatsApp is already authenticated. If `store/auth/creds.json` exists, skip to "Dedicated vs personal number".
+Check if WhatsApp is already authenticated. If `store/auth/creds.json` exists, skip to "Shared vs dedicated number".
 
 ```bash
 test -f store/auth/creds.json && echo "WhatsApp auth exists" || echo "No WhatsApp auth"
@@ -202,60 +192,16 @@ for i in $(seq 1 60); do grep -q 'STATUS: authenticated' /tmp/wa-auth.log 2>/dev
 test -f store/auth/creds.json && echo "Authentication successful" || echo "Authentication failed"
 ```
 
-## Dedicated vs personal number
-
-The adapter behaves fundamentally differently depending on whether the linked number is the assistant's own or the operator's personal one. The switch is `ASSISTANT_HAS_OWN_NUMBER` in `.env`, read by the adapter itself at startup. **Inference rule: absent (or anything other than `true`) means shared/personal** — the safe default, since misreading a personal number as dedicated makes the bot claim messages addressed to the human.
-
-- **Shared/personal number** (`ASSISTANT_HAS_OWN_NUMBER` unset or not `true`) — DMs to this number and group @-tags of it address the *human*, not the bot. The adapter never emits a mention signal (`mentions: 'never'` in its declared channel defaults), so: no stranger DM ever auto-creates a messaging group or raises an admin approval card; group wirings default to a name pattern (`\b<AgentName>\b`) instead of platform mentions; auto-created chats default to `unknown_sender_policy: 'strict'`; outbound messages are prefixed with the assistant's name.
-- **Dedicated number** (`ASSISTANT_HAS_OWN_NUMBER=true`) — everything sent to the number is for the bot. DMs and group mentions carry a real mention signal (`mentions: 'platform'`), unknown senders escalate via `request_approval` approval cards, and card-approved groups wire with `engage_mode: 'mention'`. No name prefix on outbound.
+### Shared vs dedicated number
 
 AskUserQuestion: Is this a shared phone number (personal WhatsApp) or a dedicated number?
 - **Shared number** — your personal WhatsApp (bot prefixes messages with its name)
 - **Dedicated number** — a separate phone/SIM for the assistant
 
-Write the answer to `.env` **explicitly in both cases** (don't rely on the inference rule for new installs):
+If dedicated, add to `.env`:
 
 ```bash
-# Dedicated:
 ASSISTANT_HAS_OWN_NUMBER=true
-# Shared/personal:
-ASSISTANT_HAS_OWN_NUMBER=false
-```
-
-### Update path: existing install, flag unset
-
-If WhatsApp auth already exists (`store/auth/creds.json` present) but `.env` has no `ASSISTANT_HAS_OWN_NUMBER` line, the install predates the explicit switch. Ask the operator which mode applies and write it explicitly.
-
-Suggest a default by comparing the authed number against the wired DM chat:
-
-```bash
-# The number this install is authenticated as
-node -e "const c=JSON.parse(require('fs').readFileSync('store/auth/creds.json','utf-8'));console.log(c.me?.id?.split(':')[0])"
-# The wired WhatsApp DM chats
-pnpm exec tsx scripts/q.ts data/v2.db "SELECT mg.platform_id FROM messaging_groups mg JOIN messaging_group_agents mga ON mg.id=mga.messaging_group_id WHERE mg.channel_type='whatsapp' AND mg.is_group=0"
-```
-
-If the wired DM's phone **equals** the authed number, the operator is talking to the bot in their own self-chat — that's a personal number: suggest **Shared**. If they differ, the operator messages the bot from a different number: suggest **Dedicated**. Confirm with the operator either way, then write the flag and restart the service.
-
-### Migration audit: spam-era group wirings
-
-Before the shared-number fix, group chats approved via the channel-registration card were wired `engage_mode='pattern'` with pattern `.` — respond-to-everything — because the card flow couldn't tell groups from DMs on non-threaded platforms. On a personal number this shows up as the bot answering every message in family/work groups after someone once tapped Connect on a spam-triggered card.
-
-List the suspect wirings (host service running — `ncl` is socket-only):
-
-```bash
-ncl wirings list --engage-mode pattern --engage-pattern "." --json
-```
-
-Cross-reference against WhatsApp group chats (`ncl messaging-groups list --channel-type whatsapp --is-group 1`). For each wiring with pattern `.` on a WhatsApp group that is *not* the operator's deliberate always-on chat (e.g. their self-chat), offer:
-
-- **Flip to name-based engagement**: `ncl wirings update <wiring-id> --engage-mode pattern --engage-pattern '\b<AgentName>\b'` (or `--engage-mode mention` on a dedicated number)
-- **Delete the wiring**: `ncl wirings delete <wiring-id>`
-
-Stale approval cards from that era can also linger. Clear pending channel approvals for chats the operator doesn't want wired:
-
-```bash
-pnpm exec tsx scripts/q.ts data/v2.db "DELETE FROM pending_channel_approvals WHERE messaging_group_id IN (SELECT id FROM messaging_groups WHERE channel_type='whatsapp')"
 ```
 
 ## Next Steps
@@ -333,12 +279,3 @@ systemctl --user start $(systemd_unit)
 ### "conflict" disconnection
 
 Two instances connected with same credentials. Ensure only one NanoClaw process is running.
-
-### Trunk updated but shared-number behavior unchanged (stale adapter copy)
-
-The shared-number behavior (no stranger approval cards, name-pattern group defaults) lives in the **adapter copy** at `src/channels/whatsapp.ts`, installed from the `channels` branch — not in trunk. If you updated trunk via `/update-nanoclaw` but skipped the skill-update step, the old adapter copy neither reads `ASSISTANT_HAS_OWN_NUMBER` itself nor declares channel defaults, so trunk falls back to the legacy behavior: approval cards still fire on a personal number, and new wirings get the channel-blind defaults. Symptoms of the skew:
-
-- `.env` says `ASSISTANT_HAS_OWN_NUMBER=false` (or unset) but strangers' DMs still raise approval cards
-- `ncl wirings create` on a WhatsApp group defaults to `mention` instead of a name pattern
-
-Fix: re-run `/add-whatsapp` (or `/update-skills`) to pull the current adapter from the `channels` branch, then restart the service. The reverse skew (new adapter, old trunk) can't happen — the adapter's `defaults` field is optional and old trunk ignores it.

.claude/skills/debug/SKILL.md

@@ -206,6 +206,29 @@ ncl groups restart --id <group-id> --message "on_wake test"
 
 Without `--message`, the container comes back on the next user message. From inside a container, `--id` is auto-filled and only the calling session restarts.
 
+## Runaway task
+
+A scheduled task (cron) that keeps firing is a `messages_in` row with `kind='task'` in a session's `inbound.db`. When an agent won't stop one — or you'd rather not ask the misbehaving agent — use the `ncl tasks` operator surface to inspect and stop it directly from the host:
+
+```bash
+# List every pending/paused task across all groups (one row per series).
+ncl tasks list
+
+# Scope to a single agent group.
+ncl tasks list --group <group-id>
+
+# Inspect one task by id or series id.
+ncl tasks get --id <task-id>
+
+# Stop it. cancel/pause/resume match by id OR series id, so a recurring
+# task's live next occurrence is caught, not just the row you looked up.
+ncl tasks cancel --id <task-id>
+ncl tasks pause  --id <task-id>
+ncl tasks resume --id <task-id>
+```
+
+The host is the legitimate writer of `inbound.db`, so these apply straight to the session DB without waking the container. `cancel` marks the series completed, `pause` holds a pending task, `resume` re-arms a paused one.
+
 ## Manual Container Probes
 
 The container's entry point is `exec bun run /app/src/index.ts`; it talks only to the mounted session DBs, so there is no JSON to pipe in. To probe the image directly:
@@ -258,13 +281,14 @@ docker builder prune -af
 
 ## Clearing a Session
 
-Conversation continuity lives in the container-owned `session_state` table in `outbound.db` (the provider's session/continuation id). The agent's `/clear` clears it. To reset a session from the host, remove the session folder so a fresh one is provisioned on the next message:
+Conversation continuity lives in the container-owned `session_state` table in `outbound.db` (the provider's session/continuation id). The agent's `/clear` clears it. To reset a session from the host, just remove the session folder — it self-heals: the host re-creates the folder and re-initializes both DBs on the next inbound message, so you leave the central `sessions` row in place and don't need to restart the host.
 
 ```bash
 # Inspect first
 ncl sessions get <session-id>
 
-# Remove a single session's folder (host re-provisions both DBs on next message)
+# Remove a single session's folder — the host re-provisions it (both DBs)
+# on the next message. No row deletion or host restart needed.
 rm -rf data/v2-sessions/<group>/<session>/
 ```
 

.claude/skills/init-first-agent/SKILL.md

@@ -113,7 +113,7 @@ If they say it didn't arrive, then diagnose using the DB directly (no waiting lo
 
 **"Missing required args"** — the script wants `--channel`, `--user-id`, `--platform-id`, `--display-name` at minimum. Re-check the command you assembled.
 
-**No `messaging_groups` row appears after the user DMs (step 3a)** — auto-created rows are stamped with the channel adapter's declared `unknown_sender_policy` (two-level model: adapter declaration → per-row override; `strict` only when the adapter has no declaration). Under `strict` the router silently drops messages from unknown senders but still creates the `messaging_groups` row; under `request_approval` an approval card goes to an admin instead. If the row is missing entirely, the adapter isn't receiving the inbound message. Check `logs/nanoclaw.log` for adapter errors (auth, gateway disconnect, rate limit).
+**No `messaging_groups` row appears after the user DMs (step 3a)** — the router silently drops messages from unknown senders under `strict` policy but still creates the `messaging_groups` row. If the row is missing entirely, the adapter isn't receiving the inbound message. Check `logs/nanoclaw.log` for adapter errors (auth, gateway disconnect, rate limit).
 
 **Owner already exists** — `hasAnyOwner()` returned true, so the grant is skipped silently. That's fine; the script still creates the agent and wiring. Reassigning ownership needs a separate flow (not this skill).
 

.claude/skills/manage-channels/SKILL.md

@@ -22,7 +22,7 @@ pnpm exec tsx scripts/q.ts data/v2.db "<query>"
 ```sql
 SELECT id, name AS assistant_name, folder, agent_provider FROM agent_groups;
 SELECT id, channel_type, platform_id, name, unknown_sender_policy FROM messaging_groups;
-SELECT messaging_group_id, agent_group_id, engage_mode, engage_pattern, session_mode, threads, priority FROM messaging_group_agents;
+SELECT messaging_group_id, agent_group_id, session_mode, priority FROM messaging_group_agents;
 SELECT user_id, role, agent_group_id FROM user_roles ORDER BY role='owner' DESC;
 ```
 
@@ -36,47 +36,6 @@ If the instance has no owner yet (`SELECT COUNT(*) FROM user_roles WHERE role='o
 
 **Delegate to `/init-first-agent`.** It handles: channel choice, operator identity lookup, DM platform id resolution (with cold-DM or pair-code fallback), agent group creation, wiring, and the welcome DM. Return here afterward for any additional channels.
 
-## Channel Defaults: The Two-Level Model
-
-Wiring defaults (engage mode/pattern, threading, `unknown_sender_policy`) resolve through **exactly two levels**:
-
-1. **Adapter declaration** — each channel adapter declares `ChannelDefaults` (separate DM and group contexts, plus a `mentions` capability) in its source file. The adapter copy is skill-installed and user-owned: to change a default install-wide, edit `src/channels/<channel>.ts` and restart. Declarations are never persisted to the DB.
-2. **Per-wiring/per-mg values chosen at creation** — every creation surface (`ncl wirings create` / `ncl messaging-groups create`, the `register` wizard step, the approval-card flow, `/init-first-agent`) fills omitted fields from the declaration and stores the result on the row. Pass explicit flags to override one wiring.
-
-There is no third level: existing rows are never re-resolved, so editing a declaration only affects wirings created afterward. The one exception is the **`threads` column**, which stays live — `NULL` means "inherit the declaration at message time".
-
-Channels with no declaration (stale adapter copies) fall back to the legacy behavior; run `/update-skills` to pull current adapters.
-
-### Wiring via ncl
-
-`ncl` requires the **host service to be running** (it connects over a Unix socket):
-
-```bash
-ncl messaging-groups create --channel-type <type> --platform-id "<id>" --name "<name>" [--is-group 1]
-ncl wirings create --messaging-group-id <mg-id> --agent-group-id <ag-id> [--session-mode <mode>]
-```
-
-Omitted `engage_mode`/`engage_pattern`/`unknown_sender_policy` come from the adapter declaration for the right context (DM vs group). Run `ncl wirings help` / `ncl messaging-groups help` for the full flag list.
-
-### Threading override (`--threads`)
-
-`ncl wirings create/update ... --threads true|false` controls whether platform thread ids are honored for this wiring. `true` (in groups) means per-thread sessions and in-thread replies/typing/cards; `false` collapses to a flat session with top-level replies. Omitted = `NULL` = inherit the channel declaration. A wiring can *disable* threads on a threaded platform (Slack, Discord, GitHub), never enable them on a non-threaded one.
-
-Two consequences to warn the user about:
-
-- **Session identity**: sessions are never deleted. Flipping `threads` on a live wiring orphans existing per-thread sessions (or splinters a shared one) — history stays in the old sessions; new messages start fresh ones.
-- **`mention-sticky` needs threads**: sticky engagement is keyed on per-thread session existence, so with resolved threads off it would engage once and never disengage. Creation and update coerce `mention-sticky` → `mention` (with a warning) when the effective thread policy is off.
-
-### Mention capability
-
-Each declaration states which mention signal the adapter emits: `platform` (real platform mentions), `dm-only` (only DMs are flagged), or `never`. On a `mentions: 'never'` channel (Linear OAuth apps, WhatsApp personal-number mode, Emacs), `mention`/`mention-sticky` wirings are **inert — they can never engage** — and `ncl` rejects them at create/update with an error citing the declaration. For groups on those channels, use a name pattern instead:
-
-```bash
-ncl wirings update <id> --engage-mode pattern --engage-pattern '(?i)^@?<Name>\b'
-```
-
-**Renaming an agent group does not update stored patterns.** Declared group patterns containing `{name}` are substituted with the agent group's name *at creation* and stored literally — after `ncl groups update <id> --name <NewName>`, audit that group's wirings for patterns still matching the old name and update them.
-
 ## Wire New Channel
 
 For each unwired channel:
@@ -108,8 +67,6 @@ pnpm exec tsx setup/index.ts --step register -- \
 
 The `register` step creates the agent group (reusing it if the folder already exists), the messaging group, and the wiring row. `createMessagingGroupAgent` auto-creates the companion `agent_destinations` row so the agent can address the channel by name.
 
-Omitted engage/policy fields default from the channel adapter's declaration (see "Channel Defaults" above). Optional overrides: `--trigger "<regex>"` (explicit engage pattern), `--engage-mode <pattern|mention|mention-sticky>`, `--is-group <true|false>`, `--unknown-sender-policy <strict|request_approval|public>`. Don't pick a mention mode on a channel whose declaration says `mentions: 'never'` — it can never engage there.
-
 When creating a NEW agent group on a non-default provider, append `--provider <name>` (e.g. `--provider codex`) — there is no install-wide default; existing groups switch via `ncl groups config update --provider` instead.
 
 For separate agents, also ask for a folder name and optionally a different assistant name.
@@ -118,7 +75,7 @@ For separate agents, also ask for a folder name and optionally a different assis
 
 When adding another group/chat on an already-configured platform (e.g. a second Telegram group):
 
-1. **Telegram:** ask the isolation question first to determine intent (`wire-to:<folder>` for an existing agent, `new-agent:<folder>` for a fresh one). Run `pnpm exec tsx setup/index.ts --step pair-telegram -- --intent <intent>`, show the `CODE` from the `PAIR_TELEGRAM_CODE` status block, and tell the user to post `@<botname> CODE` in the target group (or DM the bot for a private chat). Wait for the final `PAIR_TELEGRAM` block. The inbound interceptor has already created the `messaging_groups` row stamped with the Telegram adapter's declared policy (`request_approval` on current adapter copies; `strict` only on stale pre-declaration copies) and upserted the paired user — `register` only needs to add the wiring:
+1. **Telegram:** ask the isolation question first to determine intent (`wire-to:<folder>` for an existing agent, `new-agent:<folder>` for a fresh one). Run `pnpm exec tsx setup/index.ts --step pair-telegram -- --intent <intent>`, show the `CODE` from the `PAIR_TELEGRAM_CODE` status block, and tell the user to post `@<botname> CODE` in the target group (or DM the bot for a private chat). Wait for the final `PAIR_TELEGRAM` block. The inbound interceptor has already created the `messaging_groups` row with `unknown_sender_policy = 'strict'` and upserted the paired user — `register` only needs to add the wiring:
 
    ```bash
    pnpm exec tsx setup/index.ts --step register -- \
@@ -137,16 +94,6 @@ When adding another group/chat on an already-configured platform (e.g. a second
 3. Delete the old `messaging_group_agents` entry, create a new one
 4. Note: existing sessions stay with the old agent group; new messages route to the new one. The `agent_destinations` row created for the old wiring is NOT automatically removed — if you want the old agent to stop seeing the channel as a named target, delete it from `agent_destinations` manually.
 
-## One-Time Check: Legacy Mis-Wired WhatsApp Groups
-
-Installs that approved WhatsApp group registration cards before the channel-defaults model wired those groups as `engage_mode='pattern'`, `engage_pattern='.'` — respond-to-everything (the card flow couldn't tell groups from DMs on non-threaded platforms). Check once:
-
-```bash
-pnpm exec tsx scripts/q.ts data/v2.db "SELECT mga.id, mg.platform_id, mg.name FROM messaging_group_agents mga JOIN messaging_groups mg ON mg.id = mga.messaging_group_id WHERE mg.channel_type='whatsapp' AND mg.is_group=1 AND mga.engage_mode='pattern' AND mga.engage_pattern='.'"
-```
-
-For any hit the operator didn't deliberately configure as always-on, offer the repair options in `/add-whatsapp`'s "Migration audit" section (flip to mention/name-pattern engagement, or delete the wiring).
-
 ## Show Configuration
 
 Display a readable summary showing:

.claude/skills/manage-mounts/SKILL.md

@@ -13,18 +13,18 @@ Configure which host directories NanoClaw agent containers can access. The mount
 cat ~/.config/nanoclaw/mount-allowlist.json 2>/dev/null || echo "No mount allowlist configured"
 ```
 
-Show the current config to the user in a readable format: which directories are allowed, and whether each is read-only or read-write.
+Show the current config to the user in a readable format: which directories are allowed, whether non-main agents are read-only.
 
 ## Add Directories
 
 Ask which directories the user wants agents to access. For each path:
 - Validate the path exists
-- Ask if it should be read-write (`allowReadWrite: true`) or read-only (`allowReadWrite: false`, the safer default)
+- Ask if it should be read-only for non-main agents (default: yes)
 
 Build the JSON config and write it:
 
 ```bash
-pnpm exec tsx setup/index.ts --step mounts --force -- --json '{"allowedRoots":[{"path":"/path/to/dir","allowReadWrite":true}],"blockedPatterns":[]}'
+pnpm exec tsx setup/index.ts --step mounts --force -- --json '{"allowedRoots":[{"path":"/path/to/dir","readOnly":false}],"blockedPatterns":[],"nonMainReadOnly":true}'
 ```
 
 Use `--force` to overwrite the existing config.
@@ -34,7 +34,7 @@ Use `--force` to overwrite the existing config.
 Read the current config, show it, ask which entry to remove, then write the updated config through the same write path (build the trimmed JSON and pass it to `--step mounts --force -- --json`):
 
 ```bash
-pnpm exec tsx setup/index.ts --step mounts --force -- --json '{"allowedRoots":[],"blockedPatterns":[]}'
+pnpm exec tsx setup/index.ts --step mounts --force -- --json '{"allowedRoots":[],"blockedPatterns":[],"nonMainReadOnly":true}'
 ```
 
 ## Reset to Empty
@@ -45,10 +45,12 @@ pnpm exec tsx setup/index.ts --step mounts --force -- --empty
 
 ## After Changes
 
-The allowlist is read fresh when a container is spawned, so new mounts apply to newly spawned containers automatically — no service restart needed.
+Restart the service so containers pick up the new config (the unit/label names are per-install — see `setup/lib/install-slug.sh`).
 
-To apply the new config to a group that already has a running container, restart just that group:
+Run from your NanoClaw project root:
 
 ```bash
-ncl groups restart --id <group-id>
+source setup/lib/install-slug.sh
+launchctl kickstart -k gui/$(id -u)/$(launchd_label)  # macOS
+systemctl --user restart $(systemd_unit)              # Linux
 ```

.claude/skills/migrate-from-openclaw/SKILL.md

@@ -194,10 +194,8 @@ Notes:
   runtime, so pass the `=>` value discovery emitted (or the raw OpenClaw id).
 - Reuse a `--folder` to put a group on an existing agent (shared base/separate
   conversations); use a new `--folder` for a fully separate agent.
-- Engage defaults come from the channel adapter's declaration (most group
-  chats default to mention-based engagement; channels without a mention
-  signal default to a name pattern). Pass `--trigger` to set an explicit
-  regex, or `--no-trigger-required` for respond-to-everything.
+- Group chats default to mention-only; pass `--trigger` to set a regex, or
+  `--no-trigger-required` for respond-to-everything.
 - Register groups from channels v2 doesn't support yet too — the messaging
   group and wiring persist and activate when that channel is installed.
 
@@ -240,13 +238,10 @@ model, which is **not** a JSON file. Each messaging group has an
 - `dmPolicy: "disabled"` → don't wire that chat (or leave it registered but
   unwired).
 
-The messaging groups `register` / `init-first-agent` create default their
-`unknown_sender_policy` to whatever the channel adapter declares for that
-context (DM vs group) — `strict` when the channel has no declaration — so
-unknown senders are gated until you add them (or an admin approves the
-adapter-declared approval card). Pass `--unknown-sender-policy` to `register`
-to override. Show the user the OpenClaw allowlist and confirm who to grant
-before running the commands.
+The messaging groups `register` / `init-first-agent` create already default to
+`unknown_sender_policy = 'strict'`, so unknown senders are gated until you add
+them. Show the user the OpenClaw allowlist and confirm who to grant before
+running the commands.
 
 ## Phase 3: Identity and Memory
 

.claude/skills/update-nanoclaw/SKILL.md

@@ -281,34 +281,6 @@ Keep it to these two options — the per-skill selection lives inside
   its Step 4 — so nothing container-related is owed back here.)
 - On "Skip": note that `/update-skills` can be run anytime, then proceed.
 
-## Known behavior changes when channel adapters update
-
-Channel adapters now declare per-channel wiring defaults (engage mode, threading,
-sender policy). Updating trunk alone changes nothing for existing rows, but once
-`/update-skills` pulls current adapter copies, two deliberate behavior changes
-land. If the user's install has Slack, Discord, or WhatsApp, tell them:
-
-1. **Slack/Discord DM replies move top-level.** Both adapters now declare
-   `threads: false` for DMs, so DM replies stop chasing per-message sub-threads
-   and land in the main DM view, matching the DM session (which was already
-   flat). Group/channel threading is unchanged. To keep the old in-thread DM
-   behavior for a specific wiring, override it per wiring:
-   `ncl wirings update <wiring-id> --threads true`.
-2. **Shared-identity channels stop raising stranger approval cards.** On
-   channels where the linked account is the operator's personal identity, the
-   mechanics differ by channel: WhatsApp personal-number mode suppresses the
-   mention signal entirely (no auto-created messaging groups, no cards);
-   iMessage and WeChat still emit DM mention signals — stranger DMs still
-   auto-create `messaging_groups` rows — but their declared `strict` policy
-   makes those rows drop unknown senders silently instead of raising
-   channel-registration cards to the admin.
-
-**WhatsApp installs on a shared/personal number should re-run `/add-whatsapp`**
-after the skill update: it now asks the dedicated-vs-personal question
-explicitly (writing `ASSISTANT_HAS_OWN_NUMBER` to `.env`), audits for legacy
-mis-wired group rows from spam-era approval cards, and shows how to clear
-stale pending approvals.
-
 Proceed to Step 7.9.
 
 # Step 7.9: Stamp the upgrade marker (required)

.github/workflows/label-pr.yml

@@ -14,7 +14,6 @@ jobs:
     runs-on: ubuntu-latest
     permissions:
       pull-requests: write
-      issues: write # createLabel — auto-provisions the core-team label
     steps:
       - uses: actions/github-script@v7
         with:
@@ -31,24 +30,6 @@ jobs:
 
             if (body.includes('contributing-guide: v1')) labels.push('follows-guidelines');
 
-            // Lowercase GitHub logins; keep in sync with the core team roster.
-            const CORE_TEAM = ['gavrielc', 'koshkoshinsk', 'glifocat', 'gabi-simons', 'omri-maya', 'amit-shafnir', 'moshe-nanoco'];
-            const author = context.payload.pull_request.user.login.toLowerCase();
-            if (CORE_TEAM.includes(author)) {
-              labels.push('core-team');
-              try {
-                await github.rest.issues.createLabel({
-                  owner: context.repo.owner,
-                  repo: context.repo.repo,
-                  name: 'core-team',
-                  color: '1D76DB',
-                  description: 'PR opened by a core team member',
-                });
-              } catch (e) {
-                if (e.status !== 422) throw e; // 422: label already exists
-              }
-            }
-
             if (labels.length > 0) {
               await github.rest.issues.addLabels({
                 owner: context.repo.owner,

CHANGELOG.md

@@ -4,12 +4,6 @@ All notable changes to NanoClaw will be documented in this file.
 
 ## [Unreleased]
 
-- **New skill: `/add-audit` — opt-in local audit log for the `ncl` surface.** Installs an append-only, SIEM-shaped audit log: every command through the dispatcher (both transports — host socket and container — including scope denials, approval holds, and approved replays) becomes one canonical NDJSON event under `data/audit/<UTC-day>.ndjson`. Gated chains share a `correlation_id` (the approval id: the hold's `pending` event and the replay's terminal event carry the same one); `details` pass a recursive secret-key redactor (~2 KB value cap). `AUDIT_RETENTION_DAYS` (default 90; `0` = keep forever) hard-deletes day-files past the horizon at boot and once per UTC day. Read back with `ncl audit list [--actor --action --resource --outcome --since --until --correlation --limit] [--format ndjson]` — host + global-scope callers only (the resource stays off the group-scope allowlist, so group-scoped agents fail closed). In-process exporters plug in via `registerAuditHook` — post-write hooks that fire only after the local append succeeds. Off by default: nothing is persisted (and `data/audit/` is never created) until `AUDIT_ENABLED=true`, an enabled box refuses to boot if the directory isn't writable, and a disabled box answers `ncl audit list` with a clear error instead of an empty list. The skill's whole core footprint is the dispatch composition (`export const dispatch = withAudit(dispatchInner)`) plus the resource-barrel import, both guarded by a shipped wiring test. Approval-lifecycle events (request/decision as their own events), OneCLI credential holds, and channel/sender events are later increments on the same schema.
-- **The guard seam.** Every privileged action crossing the container or channel boundary now passes ONE decision function — `guard()` in the new `src/guard/` leaf — before it executes: `allow`, `hold` (through the flow's existing approval mechanics), or `deny`. The keyed registries (ncl commands, delivery actions) wrap their handlers at registration, so the guarded path is the only path by construction: every ncl command derives its guard from its own definition inside `register()`, and a delivery action registers with a guard spec or an explicit `unguarded(<reason>)` declaration — omission doesn't compile, and `grep "unguarded("` is the complete justified inventory. The broadcast hooks (response handlers, message interceptors) stay plain registrations; the one privileged click path — channel registration — consults the guard inline in its handler, like the a2a route and the unknown-sender gate. Consults carry the branded `GuardedAction` value returned by `defineGuardedAction`, so a typo'd or dropped wiring is a compile error and a forged value is denied at runtime — never a fail-open. The decision is today's checks verbatim (cli_scope enforcement, create_agent's scope branch, a2a destination ACL + `agent_message_policies` hold, self-mod unconditional hold, unknown_sender_policy, channel-registration click auth, host-as-trusted-caller in code). Policy-as-data (tighten-only rule sources composing with the decision) is deliberately deferred — a generalized rules table can arrive later, with its first operator-visible consumer. Approved replays now carry the verified approval row as a **grant** — the `approved: true` boolean is deleted — and the guard re-runs the structural checks on every replay. Two outcome changes are inherent to that replay semantics and ship deliberately: **(a)** approving a held a2a message after its destination was revoked no longer delivers it (the checks re-run live); **(b)** a forged, already-consumed, or wrong-action/wrong-payload grant refuses the replay instead of executing (previously any in-process caller passing `approved: true` executed). Zero rules ship by default — the seeded posture is today's behavior. (The D1/D2/D4 click-auth fixes from the guarded-actions defect inventory are NOT in this change — they belong to the approval-contract PR.)
-- **Delivery-registry hardening.** Re-registering a guard-wrapped delivery action *without* a guard spec now throws at registration — previously that silently replaced the guarded handler while the catalog still reported the action as guarded. (The cross-registry pairing — every holding action has a registered approve continuation — is enforced by the conformance test; at runtime a missing continuation already resolves loudly, telling the requester no handler is installed.)
-- [BREAKING] **`whatsapp-formatting` and `slack-formatting` container skills moved from trunk to the `channels` branch.** They now install with their channel — `/add-whatsapp` / `/add-slack` and the setup installers copy them in — so installs without those channels stop carrying channel-specific formatting instructions in every agent's context. **Migration — only if this install has the channel wired** (check `src/channels/whatsapp.ts` / `src/channels/slack.ts`): updating removes both skills from the working tree — WhatsApp agents lose the formatting fragment from their composed CLAUDE.md on next spawn, Slack agents lose the mrkdwn skill from `~/.claude/skills`. Re-run the matching skill, `/add-whatsapp` or `/add-slack` (idempotent), to restore. Installs without the channel need nothing — do NOT run the add-skill just in case; it installs the full channel adapter.
-- **Pre-task script failures back their series off instead of spinning.** A `--script` that errors lands the occurrence as a failed run (`script-skip:error` ack → `failed` status); recurrence reads the series' trailing failed streak and re-arms at `max(cron next, now + 2·2^(n−1) min, cap 60)`; after 8 consecutive failures the series is auto-paused with a host-written note in its run log (`ncl tasks resume` revives it). A deliberate `wakeAgent:false` gate is a normal run and never backs off. Also fixed: an explicitly-addressed `<message to>` in a task fire's final text now delivers as a deliberate send (previously suppressed as a turn-reply echo → zero delivery when the agent skipped the MCP tool); identical echoes of an MCP send are dropped in the runner, where the duplication originates.
-- [BREAKING] **Scheduled tasks moved from MCP tools to `ncl tasks`.** The six scheduling MCP tools are no longer exposed to agent containers; agents and operators manage tasks with `ncl tasks list/get/create/update/cancel/pause/resume/delete`. New tasks run from a per-agent-group system session rather than waking the chat session that created them, and task writes are not approval-gated inside the owning group. **Migration:** [docs/ncl-tasks-migration.md](docs/ncl-tasks-migration.md).
 - **Optional per-container resource caps.** `CONTAINER_CPU_LIMIT` and `CONTAINER_MEMORY_LIMIT` pass through to `docker run` as `--cpus` / `--memory` (`container-runner.ts`). Both empty by default — no flag added, spawn args byte-identical to today — so existing installs are unaffected. Set them to cap an agent container's CPU/memory so one agent can't monopolize the host (e.g. `CONTAINER_CPU_LIMIT=2`, `CONTAINER_MEMORY_LIMIT=8g`). Swap is intentionally not managed here: `--memory` is a hard cap on a swapless host.
 - [BREAKING] **Chat SDK pinned to `4.29.0` (was `4.26.0` via `^4.24.0`).** `chat` and the `@chat-adapter/*` channel adapters are version-locked — the adapter's `ChatInstance` must match the bridge's, so a mismatched pair fails to typecheck at `createChatSdkBridge(...)`. `chat` is therefore pinned exactly, and the channel-adapter install pins move with it — the `/add-<channel>` SKILL.md steps and `setup/*.sh` scripts on `main`, plus the adapter code on the `channels` branch. Core installs with no channel (only `cli`) are unaffected. **Migration:** if any channel is installed (Slack, Discord, Telegram, Teams, …), re-run its `/add-<channel>` skill to pull the matching `4.29.0` adapter.
 - **Budget/billing-exhausted LLM turns now reach the user instead of being silently dropped.** When a turn ends in a non-retryable provider error (e.g. an Anthropic `403 billing_error`) with no `<message>` wrapping, the agent-runner delivers the provider's notice to the originating channel and stops re-nudging the failing gateway. `providers/claude.ts` now surfaces the SDK's `is_error` flag (and the error subtype's `errors[]` text); `poll-loop.ts` delivers that text and skips the re-wrap retry. Fixes the case where a spend-limit notice produced silence plus a turn-after-turn retry loop.

CLAUDE.md

@@ -15,11 +15,11 @@ If you are a fresh install (you ran `git clone`, not `git pull`) and there are n
 
 # NanoClaw
 
-Personal AI assistant. See [README.md](README.md) for philosophy and setup. Architecture lives in `docs/`.
+Personal Claude assistant. See [README.md](README.md) for philosophy and setup. Architecture lives in `docs/`.
 
 ## Quick Context
 
-The host is a single Node process that orchestrates per-session agent containers. Platform messages land via channel adapters, route through an entity model (users → messaging groups → agent groups → sessions), get written into the session's inbound DB, and wake a container. The agent-runner inside the container polls the DB, calls the agent, and writes back to the outbound DB. The host polls the outbound DB and delivers through the same adapter.
+The host is a single Node process that orchestrates per-session agent containers. Platform messages land via channel adapters, route through an entity model (users → messaging groups → agent groups → sessions), get written into the session's inbound DB, and wake a container. The agent-runner inside the container polls the DB, calls Claude, and writes back to the outbound DB. The host polls the outbound DB and delivers through the same adapter.
 
 **Everything is a message.** There is no IPC, no file watcher, no stdin piping between host and container. The two session DBs are the sole IO surface.
 
@@ -32,7 +32,7 @@ agent_group_members (user_id, agent_group_id)    — unprivileged access gate
 user_dms (user_id, channel_type, messaging_group_id) — cold-DM cache
 
 agent_groups (workspace, memory, CLAUDE.md, personality, container config)
-    ↕ many-to-many via messaging_group_agents (session_mode, engage_mode/engage_pattern, sender_scope, priority)
+    ↕ many-to-many via messaging_group_agents (session_mode, trigger_rules, priority)
 messaging_groups (one chat/channel on one platform; instance = adapter-instance name, defaults to channel_type; unknown_sender_policy)
 
 sessions (agent_group_id + messaging_group_id + thread_id → per-session container)
@@ -44,8 +44,8 @@ Privilege is user-level (owner/admin), not agent-group-level. See [docs/isolatio
 
 Each session has **two** SQLite files under `data/v2-sessions/<session_id>/`:
 
-- `inbound.db` — host writes, container reads. `messages_in`, delivered, destinations, session_routing.
-- `outbound.db` — container writes, host reads. `messages_out`, processing_ack, session_state, container_state.
+- `inbound.db` — host writes, container reads. `messages_in`, routing, destinations, pending_questions, processing_ack.
+- `outbound.db` — container writes, host reads. `messages_out`, session_state.
 
 Exactly one writer per file — no cross-mount lock contention. Heartbeat is a file touch at `/workspace/.heartbeat`, not a DB update. Host uses even `seq` numbers, container uses odd.
 
@@ -62,28 +62,25 @@ For ad-hoc queries from skills or scripts, use the in-tree wrapper rather than t
 | `src/index.ts` | Entry point: init DB, migrations, channel adapters, delivery polls, sweep, shutdown |
 | `src/router.ts` | Inbound routing: messaging group → agent group → session → `inbound.db` → wake |
 | `src/delivery.ts` | Polls `outbound.db`, delivers via adapter, handles system actions (schedule, approvals, etc.) |
-| `src/delivery-guard.ts` | `DeliveryGuardSpec` + `runGuarded` — the precheck → guard → deny/hold/allow consult path for privileged delivery actions; the registry itself stays in `delivery.ts` |
 | `src/host-sweep.ts` | 60s sweep: `processing_ack` sync, stale detection, due-message wake, recurrence |
 | `src/session-manager.ts` | Resolves sessions; opens `inbound.db` / `outbound.db`; manages heartbeat path |
 | `src/container-runner.ts` | Spawns per-agent-group Docker containers with session DB + outbox mounts, OneCLI `ensureAgent` |
-| `src/container-runtime.ts` | Docker CLI wrapper (runtime binary, host-gateway args, mount args), orphan cleanup |
-| `src/guard/` | Privileged-action decision seam: `guard(action, input)` → allow \| hold \| deny. Domain-free leaf; domain decisions are `defineGuardedAction` values exported from module-edge `guard.ts` adapters (cli, agent-to-agent, self-mod, permissions) — consults hold the value, so a missing/typo'd wiring is a compile error, never a fail-open. The keyed registries (ncl commands, delivery actions) demand a guard at registration (derived spec or explicit `unguarded(<reason>)`); broadcast hooks (response handlers, message interceptors) consult the guard inline where privileged. Approved replays carry the approval row as a grant and re-run the structural checks. Policy-as-data (a runtime rules table) is deliberately deferred. Conformance test: `src/guard/conformance.test.ts` |
+| `src/container-runtime.ts` | Runtime selection (Docker vs Apple containers), orphan cleanup |
 | `src/modules/permissions/access.ts` | `canAccessAgentGroup` — owner / global admin / scoped admin / member resolution against `user_roles` + `agent_group_members` |
 | `src/modules/approvals/primitive.ts` | `pickApprover`, `pickApprovalDelivery`, `requestApproval`, approval-handler registry |
 | `src/command-gate.ts` | Router-side admin command gate — queries `user_roles` directly (no env var, no container-side check) |
 | `src/modules/approvals/onecli-approvals.ts` | OneCLI credentialed-action approval bridge |
 | `src/modules/permissions/user-dm.ts` | Cold-DM resolution + `user_dms` cache |
-| `src/group-init.ts` | Per-agent-group filesystem scaffold (CLAUDE.md, skills) — agent-runner source is a shared read-only mount, not copied per group |
+| `src/group-init.ts` | Per-agent-group filesystem scaffold (CLAUDE.md, skills, agent-runner-src overlay) |
 | `src/db/container-configs.ts` | CRUD for `container_configs` table (per-group container runtime config) |
 | `src/backfill-container-configs.ts` | Migrates legacy `container.json` files into the DB on startup |
 | `src/container-restart.ts` | Kill + on-wake respawn for agent group containers |
 | `src/db/` | DB layer — agent_groups, messaging_groups, sessions, container_configs, user_roles, user_dms, pending_*, migrations |
 | `src/channels/` | Channel adapter infra (registry, Chat SDK bridge); specific channel adapters are skill-installed from the `channels` branch |
-| `src/channels/channel-defaults.ts` | Wiring-creation helpers over adapter-declared channel defaults (`resolveWiringDefaults`, `resolveThreadPolicy`, engage validation) |
 | `src/providers/` | Host-side provider container-config (`claude` baked in; `opencode` etc. installed from the `providers` branch) |
 | `container/agent-runner/src/` | Agent-runner: poll loop, formatter, provider abstraction, MCP tools, destinations |
-| `container/skills/` | Container skills mounted into every agent session (`agent-browser`, `frontend-engineer`, `onecli-gateway`, `self-customize`, `vercel-cli`, `welcome`; channel-specific skills like `slack-formatting` and `whatsapp-formatting` install with their channel) |
-| `groups/<folder>/` | Per-agent-group filesystem (CLAUDE.md, skills) — agent-runner source is a shared read-only mount, not copied per group |
+| `container/skills/` | Container skills mounted into every agent session (`onecli-gateway`, `welcome`, `self-customize`, `agent-browser`, `slack-formatting`) |
+| `groups/<folder>/` | Per-agent-group filesystem (CLAUDE.md, skills, per-group `agent-runner-src/` overlay) |
 | `scripts/init-first-agent.ts` | Bootstrap the first DM-wired agent (used by `/init-first-agent` skill) |
 | `migrate-v2.sh` + `setup/migrate-v2/` | v1→v2 migration. Standalone script: `bash migrate-v2.sh`. Seeds DB, copies groups/sessions, installs channels, builds container, offers service switchover, then hands off to `/migrate-from-v1` skill for owner setup and CLAUDE.md cleanup. See [docs/migration-dev.md](docs/migration-dev.md). |
 | `nanoclaw.sh --uninstall` + `setup/uninstall/` | Uninstall this copy only (slug-scoped): service, containers + image, `data/`, `logs/`, `groups/`, this copy's OneCLI agents. Confirms per group; `--dry-run` previews, `--yes` skips prompts. Other copies and the shared OneCLI app are untouched. Bypasses bootstrap entirely; `uninstall.sh` is a pointer that execs it. |
@@ -108,7 +105,7 @@ ncl help
 | members | list, add, remove | Unprivileged access gate for an agent group |
 | destinations | list, add, remove | Where an agent group can send messages |
 | sessions | list, get | Active sessions (read-only) |
-| tasks | list, get, create, update, cancel, pause, resume, delete, run, append-log | Scheduled tasks for an agent group |
+| tasks | list, get, cancel, pause, resume | Scheduled tasks (cron jobs) in a group's sessions — operator surface to stop a runaway task |
 | user-dms | list | Cold-DM cache (read-only) |
 | dropped-messages | list | Messages from unregistered senders (read-only) |
 | approvals | list, get | Pending approval requests (read-only) |
@@ -119,13 +116,11 @@ Key files: `src/cli/dispatch.ts` (dispatcher + approval handler), `src/cli/crud.
 
 Trunk does not ship any specific channel adapter or non-default agent provider. The codebase is the registry/infra; the actual adapters and providers live on long-lived sibling branches and get copied in by skills:
 
-- **`channels` branch** — Discord, Slack, Telegram, WhatsApp, Teams, Linear, GitHub, iMessage, Webex, Resend, Matrix, Google Chat, WhatsApp Cloud, Signal, WeChat, DeltaChat, Emacs (+ helpers, tests, channel-specific setup steps). Installed via `/add-<channel>` skills.
+- **`channels` branch** — Discord, Slack, Telegram, WhatsApp, Teams, Linear, GitHub, iMessage, Webex, Resend, Matrix, Google Chat, WhatsApp Cloud (+ helpers, tests, channel-specific setup steps). Installed via `/add-<channel>` skills.
 - **`providers` branch** — OpenCode (and any future non-default agent providers). Installed via `/add-opencode`.
 
 Each `/add-<name>` skill is idempotent: `git fetch origin <branch>` → copy module(s) into the standard paths → append a self-registration import to the relevant barrel → `pnpm install <pkg>@<pinned-version>` → build.
 
-**Channel defaults.** Each adapter declares its wiring-time defaults (`ChannelDefaults`: per DM/group context — engage mode/pattern, thread policy, unknown-sender policy — plus mention signaling). Exactly two levels: the adapter declaration, and the per-wiring override chosen at creation — no per-instance DB config table. Undeclared (stale) adapters resolve through a behavior-faithful fallback, so a trunk update alone changes nothing. See [docs/api-details.md](docs/api-details.md#channel-defaults) and `src/channels/channel-defaults.ts`.
-
 ## Self-Modification
 
 One tier of agent self-modification today:
@@ -143,7 +138,7 @@ Per-agent-group container runtime config (provider, model, packages, MCP servers
 | Value | Behavior |
 |-------|----------|
 | `disabled` | Agent never learns about ncl (instructions excluded from CLAUDE.md). Host dispatch rejects any `cli_request`. |
-| `group` (default) | Agent can access `groups`, `sessions`, `destinations`, `members`, `tasks` only, scoped to its own agent group. `--id` and group args are auto-filled. Cross-group access rejected. `cli_scope` changes blocked. |
+| `group` (default) | Agent can access `groups`, `sessions`, `destinations`, `members` only, scoped to its own agent group. `--id` and group args are auto-filled. Cross-group access rejected. `cli_scope` changes blocked. |
 | `global` | Unrestricted. Set automatically for owner agent groups via `init-first-agent`. |
 
 Key files: `src/db/container-configs.ts`, `src/container-config.ts`, `src/cli/dispatch.ts` (scope enforcement), `src/claude-md-compose.ts` (instructions exclusion).
@@ -176,7 +171,7 @@ No container restart needed — the gateway looks up secrets per request.
 
 Approval-gating credentialed actions is a **two-sided** flow:
 
-- **Server-side** (OneCLI gateway): decides *when* to hold a request and emit a pending approval. As of `onecli@2.2.5`, the CLI does **not** expose this — `rules create --action` only accepts `block` or `rate_limit`, and `secrets create` has no approval flag. Approval policies must be configured via the OneCLI web UI at `http://127.0.0.1:10254`. If/when the CLI grows an `approve` action, this section needs updating.
+- **Server-side** (OneCLI gateway): decides *when* to hold a request and emit a pending approval. As of `onecli@1.3.0`, the CLI does **not** expose this — `rules create --action` only accepts `block` or `rate_limit`, and `secrets create` has no approval flag. Approval policies must be configured via the OneCLI web UI at `http://127.0.0.1:10254`. If/when the CLI grows an `approve` action, this section needs updating.
 - **Host-side** (nanoclaw): receives pending approvals and routes them to a human. `src/modules/approvals/onecli-approvals.ts` registers a callback via `onecli.configureManualApproval(cb)` (long-polls `GET /api/approvals/pending`). The callback uses `pickApprover` + `pickApprovalDelivery` from `src/modules/approvals/primitive.ts` to DM an approver. Approvers are resolved from the `user_roles` table — preference order: scoped admins for the agent group → global admins → owners. There is no env var like `NANOCLAW_ADMIN_USER_IDS`; roles are persisted in the central DB only.
 
 If approvals are configured server-side but the host callback isn't running (or throws), every credentialed call hangs until the gateway times out. Conversely, if the gateway has no rule asking for approval, the host callback never fires regardless of how it's wired.
@@ -188,7 +183,7 @@ Four types of skills. See [CONTRIBUTING.md](CONTRIBUTING.md) for the full taxono
 - **Channel/provider install skills** — copy the relevant module(s) in from the `channels` or `providers` branch, wire imports, install pinned deps (e.g. `/add-discord`, `/add-slack`, `/add-whatsapp`, `/add-opencode`).
 - **Utility skills** — ship code files alongside `SKILL.md` (e.g. a `scripts/` CLI or helper).
 - **Operational skills** — instruction-only workflows (`/setup`, `/debug`, `/customize`, `/init-first-agent`, `/manage-channels`, `/init-onecli`, `/update-nanoclaw`).
-- **Container skills** — loaded inside agent containers at runtime (`container/skills/`: `agent-browser`, `frontend-engineer`, `onecli-gateway`, `self-customize`, `vercel-cli`, `welcome`; channel-specific skills like `slack-formatting` and `whatsapp-formatting` are copied in by their `/add-<channel>` skill).
+- **Container skills** — loaded inside agent containers at runtime (`container/skills/`: `onecli-gateway`, `welcome`, `self-customize`, `agent-browser`, `slack-formatting`).
 
 | Skill | When to Use |
 |-------|-------------|
@@ -222,7 +217,7 @@ Run commands directly — don't tell the user to run them.
 
 ```bash
 # Host (Node + pnpm)
-pnpm run dev          # Host via tsx (no watch)
+pnpm run dev          # Host with hot reload
 pnpm run build        # Compile host TypeScript (src/)
 ./container/build.sh  # Rebuild agent container image (nanoclaw-agent:latest)
 pnpm test             # Host tests (vitest)
@@ -257,13 +252,6 @@ Check these first when something goes wrong:
 
 Note: container logs are lost after the container exits (`--rm` flag). If the agent silently failed inside the container, there's no persistent log to inspect.
 
-## Timestamps
-
-Two rules, no exceptions:
-
-- **Storage**: every timestamp written from JS is `new Date().toISOString()` (ISO-8601 UTC with `Z`). Never `datetime('now')` — its naive `YYYY-MM-DD HH:MM:SS` shape is misparsed as local time by `new Date()` and breaks string comparisons against ISO values. In pure-SQL contexts (skill snippets) use `strftime('%Y-%m-%dT%H:%M:%fZ','now')`. SQL-side *comparisons* wrap both sides in `datetime()`.
-- **Display**: anything shown to an agent or a user renders in the install timezone — `formatLocalTime` (prose) or `formatLocalStamp` (log lines) from `src/timezone.ts` / `container/agent-runner/src/timezone.ts`. `--json` output, DB values, and operator logs stay ISO.
-
 ## Supply Chain Security (pnpm)
 
 This project uses pnpm with `minimumReleaseAge: 4320` (3 days) in `pnpm-workspace.yaml`. New package versions must exist on the npm registry for 3 days before pnpm will resolve them.
@@ -310,7 +298,7 @@ The agent container runs on **Bun**; the host runs on **Node** (pnpm). They comm
 - **Writing a new named-param SQL insert/update in the container** → use `$name` in both SQL and JS keys: `.run({ $id: msg.id })`. `bun:sqlite` does not auto-strip the prefix the way `better-sqlite3` does on the host. Positional `?` params work normally.
 - **Adding a test in `container/agent-runner/src/`** → import from `bun:test`, not `vitest`. Vitest runs on Node and can't load `bun:sqlite`. `vitest.config.ts` excludes this tree.
 - **Adding a Node CLI the agent invokes at runtime** (like `agent-browser`, `claude-code`, `vercel`) → put it in the Dockerfile's pnpm global-install block, pinned to an exact version via a new `ARG`. Don't use `bun install -g` — that bypasses the pnpm supply-chain policy.
-- **Changing the Dockerfile entrypoint or the dynamic-spawn command** (`src/container-runner.ts` line ~503) → keep `exec bun ...` so signals forward cleanly. The image has no `/app/dist`; don't reintroduce a tsc build step.
+- **Changing the Dockerfile entrypoint or the dynamic-spawn command** (`src/container-runner.ts` line ~301) → keep `exec bun ...` so signals forward cleanly. The image has no `/app/dist`; don't reintroduce a tsc build step.
 - **Changing session-DB pragmas** (`container/agent-runner/src/db/connection.ts`) → `journal_mode=DELETE` is load-bearing for cross-mount visibility. Read the comment block at the top of the file first.
 
 ## CJK font support

CONTRIBUTING.md

@@ -75,7 +75,7 @@ Standalone tools that ship code files alongside the SKILL.md. The SKILL.md tells
 
 #### 3. Operational skills (instruction-only)
 
-Workflows and guides with no code changes. The SKILL.md is the entire skill — the coding agent follows the instructions to perform a task.
+Workflows and guides with no code changes. The SKILL.md is the entire skill — Claude follows the instructions to perform a task.
 
 **Location:** `.claude/skills/` on `main`
 
@@ -88,13 +88,13 @@ Workflows and guides with no code changes. The SKILL.md is the entire skill —
 
 #### 4. Container skills (agent runtime)
 
-Skills that run inside the agent container, not on the host. These teach the NanoClaw agent how to use tools, format output, or perform tasks. They are synced into each group's `.claude/skills/` directory when a container starts.
+Skills that run inside the agent container, not on the host. These teach the container agent how to use tools, format output, or perform tasks. They are synced into each group's `.claude/skills/` directory when a container starts.
 
 **Location:** `container/skills/<name>/`
 
-**Examples:** `agent-browser` (web browsing), `frontend-engineer`, `onecli-gateway` (OneCLI proxy usage), `self-customize`, `vercel-cli`, `welcome`; channel-specific: `slack-formatting` (Slack mrkdwn syntax) and `whatsapp-formatting` (channels branch; installed by `/add-slack` / `/add-whatsapp`)
+**Examples:** `agent-browser` (web browsing), `capabilities` (/capabilities command), `status` (/status command), `slack-formatting` (Slack mrkdwn syntax)
 
-**Key difference:** You never invoke these from a coding-agent session on the host, the way you run `/setup` or `/update-nanoclaw` in Claude Code/Codex/OpenCode. They're mounted into the sandbox and loaded by the NanoClaw agent itself, shaping how it behaves when you chat with it.
+**Key difference:** These are NOT invoked by the user on the host. They're loaded by Claude Code inside the container and influence how the agent behaves.
 
 **Guidelines:**
 - Follow the same SKILL.md + frontmatter format

README.md

@@ -22,7 +22,7 @@
 
 [OpenClaw](https://github.com/openclaw/openclaw) is an impressive project, but I wouldn't have been able to sleep if I had given complex software I didn't understand full access to my life. OpenClaw has nearly half a million lines of code, 53 config files, and 70+ dependencies. Its security is at the application level (allowlists, pairing codes) rather than true OS-level isolation. Everything runs in one Node process with shared memory.
 
-NanoClaw provides that same core functionality, but in a codebase small enough to understand: one process and a handful of files. Agents run in their own Linux containers with filesystem isolation, not merely behind permission checks.
+NanoClaw provides that same core functionality, but in a codebase small enough to understand: one process and a handful of files. Claude agents run in their own Linux containers with filesystem isolation, not merely behind permission checks.
 
 ## Quick Start
 
@@ -49,7 +49,7 @@ bash migrate-v2.sh
 
 Run the script directly, not from inside a Claude session — the deterministic side needs interactive prompts and real shell I/O for Node/pnpm bootstrap, Docker, OneCLI, and the container build.
 
-**What it does:** merges `.env`, seeds the v2 DB from `registered_groups`, copies group folders + session data + scheduled tasks, installs the channel adapters you select, copies channel auth state (including the Baileys keystore for WhatsApp — LID mapping is now resolved per-message by the Baileys v7 adapter, not migrated), builds the agent container.
+**What it does:** merges `.env`, seeds the v2 DB from `registered_groups`, copies group folders + session data + scheduled tasks, installs the channel adapters you select, copies channel auth state (including Baileys keystore + LID mappings for WhatsApp), builds the agent container.
 
 **What it doesn't:** flip the system service. Pick *"switch to v2"* at the prompt, or do it manually after testing — your v1 install is left untouched.
 
@@ -78,11 +78,11 @@ See [docs/v1-to-v2-changes.md](docs/v1-to-v2-changes.md) for what's different an
 - **Multi-channel messaging** — WhatsApp, Telegram, Discord, Slack, Microsoft Teams, iMessage, Matrix, Google Chat, Webex, Linear, GitHub, WeChat, and email via Resend. Installed on demand with `/add-<channel>` skills. Run one or many at the same time.
 - **Flexible isolation** — connect each channel to its own agent for full privacy, share one agent across many channels for unified memory with separate conversations, or fold multiple channels into a single shared session so one conversation spans many surfaces. Pick per channel via `/manage-channels`. See [docs/isolation-model.md](docs/isolation-model.md).
 - **Per-agent workspace** — each agent group has its own `CLAUDE.md`, its own memory, its own container, and only the mounts you allow. Nothing crosses the boundary unless you wire it to.
-- **Scheduled tasks** — recurring jobs executed by the agent, which can message you the results
+- **Scheduled tasks** — recurring jobs that run Claude and can message you back
 - **Web access** — search and fetch content from the web
-- **Container isolation** — agents are sandboxed in Docker containers (macOS/Linux/WSL2)
+- **Container isolation** — agents are sandboxed in Docker (macOS/Linux/WSL2), with optional [Docker Sandboxes](docs/docker-sandboxes.md) micro-VM isolation or Apple Container as a macOS-native opt-in
 - **Credential security** — agents never hold raw API keys. Outbound requests route through [OneCLI's Agent Vault](https://github.com/onecli/onecli), which injects credentials at request time and enforces per-agent policies and rate limits.
-- **Agent templates**: stamp a ready-to-run agent (instructions + MCP tools + skills, no secrets) from a reusable bundle via `ncl groups create --template <ref>`. Templates load from the local `templates/` folder; populate it by hand or by copying from the [public library](https://github.com/nanocoai/nanoclaw-templates). See [docs/templates.md](docs/templates.md).
+- **Agent templates**: stamp a ready-to-run agent (instructions + MCP tools + skills, no secrets) from a reusable bundle, via the setup wizard or `ncl groups create --template <ref>`. Load from the [public library](https://github.com/nanocoai/nanoclaw-templates), a local folder, or any git repo. See [docs/templates.md](docs/templates.md).
 
 ## Usage
 
@@ -124,7 +124,10 @@ This keeps trunk as pure registry and infra, and every fork stays lean — users
 
 ### RFS (Request for Skills)
 
-No channel or provider skills are currently requested — propose one via an issue.
+Skills we'd like to see:
+
+**Communication Channels**
+- `/add-signal` — Add Signal as a channel
 
 ## Requirements
 
@@ -139,7 +142,7 @@ No channel or provider skills are currently requested — propose one via an iss
 messaging apps → host process (router) → inbound.db → container (Bun, Claude Agent SDK) → outbound.db → host process (delivery) → messaging apps
 ```
 
-A single Node host orchestrates per-session agent containers. When a message arrives, the host routes it via the entity model (user → messaging group → agent group → session), writes it to the session's `inbound.db`, and wakes the container. The agent-runner inside the container polls `inbound.db`, runs the agent, and writes responses to `outbound.db`. The host polls `outbound.db` and delivers back through the channel adapter.
+A single Node host orchestrates per-session agent containers. When a message arrives, the host routes it via the entity model (user → messaging group → agent group → session), writes it to the session's `inbound.db`, and wakes the container. The agent-runner inside the container polls `inbound.db`, runs Claude, and writes responses to `outbound.db`. The host polls `outbound.db` and delivers back through the channel adapter.
 
 Two SQLite files per session, each with exactly one writer — no cross-mount contention, no IPC, no stdin piping. Channels and alternative providers self-register at startup; trunk ships the registry and the Chat SDK bridge, while the adapters themselves are skill-installed per fork.
 
@@ -162,7 +165,7 @@ Key files:
 
 **Why Docker?**
 
-Docker provides cross-platform support (macOS, Linux and Windows via WSL2) and a mature ecosystem.
+Docker provides cross-platform support (macOS, Linux and Windows via WSL2) and a mature ecosystem. On macOS, Apple Container is also supported as a lighter-weight native runtime. For additional isolation, [Docker Sandboxes](docs/docker-sandboxes.md) run each container inside a micro VM.
 
 **Can I run this on Linux or Windows?**
 

container/agent-runner/src/cli/ncl.ts

@@ -22,9 +22,7 @@ type RequestFrame = {
 };
 
 type ResponseFrame =
-  // `human` mirrors src/cli/frame.ts: an optional server-rendered string we
-  // print verbatim instead of running our own (drift-prone) formatter.
-  | { id: string; ok: true; data: unknown; human?: string }
+  | { id: string; ok: true; data: unknown }
   | { id: string; ok: false; error: { code: string; message: string } };
 
 // ---------------------------------------------------------------------------
@@ -65,11 +63,10 @@ function writeRequest(req: RequestFrame): void {
 
     db.prepare(
       `INSERT INTO messages_out (id, seq, timestamp, kind, content)
-       VALUES ($id, $seq, $timestamp, 'system', $content)`,
+       VALUES ($id, $seq, datetime('now'), 'system', $content)`,
     ).run({
       $id: req.id,
       $seq: nextSeq,
-      $timestamp: new Date().toISOString(),
       $content: JSON.stringify({
         action: 'cli_request',
         requestId: req.id,
@@ -111,9 +108,9 @@ function pollResponse(requestId: string, timeoutMs: number): ResponseFrame | nul
         outDb.exec('PRAGMA busy_timeout = 5000');
         outDb
           .prepare(
-            "INSERT OR REPLACE INTO processing_ack (message_id, status, status_changed) VALUES (?, 'completed', ?)",
+            "INSERT OR REPLACE INTO processing_ack (message_id, status, status_changed) VALUES (?, 'completed', datetime('now'))",
           )
-          .run(row.id, new Date().toISOString());
+          .run(row.id);
         outDb.close();
 
         const parsed = JSON.parse(row.content);
@@ -185,46 +182,12 @@ function printUsage(): void {
 // Formatting (mirrors src/cli/format.ts on the host)
 // ---------------------------------------------------------------------------
 
-// Mirrors localizeIsoTimestamps in src/cli/format.ts (self-contained — no
-// imports from agent-runner). Human display shows local time (container TZ
-// env = install timezone); --json keeps the ISO machine contract. Only whole
-// ISO-instant strings convert — embedded occurrences may be machine payloads.
-const ISO_UTC_RE = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}(:\d{2}(\.\d+)?)?Z$/;
-
-// "YYYY-MM-DD HH:mm" — round-trips through parseZonedToUtc (naive = local
-// wall-clock), so a value copied from human output into --process-after
-// means what it shows.
-function localTime(iso: string): string {
-  return new Date(iso).toLocaleString('sv-SE', {
-    timeZone: process.env.TZ || 'UTC',
-    year: 'numeric',
-    month: '2-digit',
-    day: '2-digit',
-    hour: '2-digit',
-    minute: '2-digit',
-    hour12: false,
-  });
-}
-
-function localizeIsoTimestamps(value: unknown): unknown {
-  if (typeof value === 'string') {
-    return ISO_UTC_RE.test(value) ? localTime(value) : value;
-  }
-  if (Array.isArray(value)) return value.map(localizeIsoTimestamps);
-  if (value && typeof value === 'object') {
-    return Object.fromEntries(
-      Object.entries(value as Record<string, unknown>).map(([k, v]) => [k, localizeIsoTimestamps(v)]),
-    );
-  }
-  return value;
-}
-
 function formatHuman(resp: ResponseFrame): string {
   if (!resp.ok) {
     return `error (${resp.error.code}): ${resp.error.message}\n`;
   }
 
-  const data = localizeIsoTimestamps(resp.data);
+  const data = resp.data;
   if (!Array.isArray(data) || data.length === 0) {
     return JSON.stringify(data, null, 2) + '\n';
   }
@@ -281,9 +244,6 @@ if (!resp) {
 
 if (json) {
   process.stdout.write(JSON.stringify(resp, null, 2) + '\n');
-} else if (resp.ok && resp.human !== undefined) {
-  // Server-rendered view — print verbatim.
-  process.stdout.write(resp.human + '\n');
 } else {
   const output = formatHuman(resp);
   if (!resp.ok) {

container/agent-runner/src/current-batch.ts

@@ -0,0 +1,29 @@
+/**
+ * Per-batch context the poll loop publishes for downstream consumers
+ * (MCP tools, etc.) that don't sit on the poll-loop's call stack.
+ *
+ * Today the only field is `inReplyTo` — the id of the first inbound
+ * message in the batch the agent is currently processing. MCP tools like
+ * `send_message` and `send_file` read this and stamp it onto the outbound
+ * row so the host's a2a return-path routing can correlate replies back to
+ * the originating session.
+ *
+ * This is module-level state on purpose: the agent-runner is single-process
+ * and processes one batch at a time. Poll-loop calls `setCurrentInReplyTo`
+ * before invoking the provider and `clearCurrentInReplyTo` after the batch
+ * completes (or errors out).
+ */
+let currentInReplyTo: string | null = null;
+
+export function setCurrentInReplyTo(id: string | null): void {
+  currentInReplyTo = id;
+}
+
+export function clearCurrentInReplyTo(): void {
+  currentInReplyTo = null;
+}
+
+export function getCurrentInReplyTo(): string | null {
+  return currentInReplyTo;
+}
+

container/agent-runner/src/db/connection.ts

@@ -48,11 +48,7 @@ export function openInboundDb(): Database {
   // so the singleton survives for the rest of the test.
   if (_testMode && _inbound) {
     const db = _inbound;
-    return {
-      prepare: (sql: string) => db.prepare(sql),
-      exec: (sql: string) => db.exec(sql),
-      close: () => {},
-    } as unknown as Database;
+    return { prepare: (sql: string) => db.prepare(sql), exec: (sql: string) => db.exec(sql), close: () => {} } as unknown as Database;
   }
   const db = new Database(DEFAULT_INBOUND_PATH, { readonly: true });
   db.exec('PRAGMA busy_timeout = 5000');
@@ -264,3 +260,11 @@ export function closeSessionDb(): void {
   _outbound?.close();
   _outbound = null;
 }
+
+/**
+ * @deprecated Use getInboundDb() / getOutboundDb() instead.
+ * Kept for backward compatibility during migration.
+ */
+export function getSessionDb(): Database {
+  return getInboundDb();
+}

container/agent-runner/src/db/index.ts

@@ -1,6 +1,7 @@
 export {
   getInboundDb,
   getOutboundDb,
+  getSessionDb,
   initTestSessionDb,
   closeSessionDb,
   touchHeartbeat,

container/agent-runner/src/db/messages-in.ts

@@ -56,7 +56,7 @@ function getMaxMessagesPerPrompt(): number {
  * Reads from inbound.db (read-only), filters against processing_ack in outbound.db
  * to skip messages already picked up by this or a previous container run.
  *
- * Returns the most recent `maxMessagesPerPrompt` pending rows in
+ * Returns the most recent `MAX_MESSAGES_PER_PROMPT` pending rows in
  * chronological order, regardless of their `trigger` flag: accumulated
  * context (trigger=0) rides along with the wake-eligible rows so the agent
  * sees the prior context it missed. Host's countDueMessages gates waking on
@@ -101,10 +101,10 @@ export function markProcessing(ids: string[]): void {
   if (ids.length === 0) return;
   const db = getOutboundDb();
   const stmt = db.prepare(
-    "INSERT OR REPLACE INTO processing_ack (message_id, status, status_changed) VALUES (?, 'processing', ?)",
+    "INSERT OR REPLACE INTO processing_ack (message_id, status, status_changed) VALUES (?, 'processing', datetime('now'))",
   );
   db.transaction(() => {
-    for (const id of ids) stmt.run(id, new Date().toISOString());
+    for (const id of ids) stmt.run(id);
   })();
 }
 
@@ -113,28 +113,10 @@ export function markCompleted(ids: string[]): void {
   if (ids.length === 0) return;
   const db = getOutboundDb();
   const stmt = db.prepare(
-    "INSERT OR REPLACE INTO processing_ack (message_id, status, status_changed) VALUES (?, 'completed', ?)",
+    "INSERT OR REPLACE INTO processing_ack (message_id, status, status_changed) VALUES (?, 'completed', datetime('now'))",
   );
   db.transaction(() => {
-    for (const id of ids) stmt.run(id, new Date().toISOString());
-  })();
-}
-
-/**
- * Ack task messages whose pre-task script gated the run. The reason decides
- * the ack: `gated` (wakeAgent=false) is the monitor working as designed → a
- * plain `completed`; `error` (broken script) → `script-skip:error`, which the
- * host's ack sync records as a FAILED run so recurrence can read the trailing
- * failed streak off the occurrence rows and back the series off.
- */
-export function markScriptSkipped(skips: Array<{ id: string; reason: string }>): void {
-  if (skips.length === 0) return;
-  const db = getOutboundDb();
-  const stmt = db.prepare(
-    'INSERT OR REPLACE INTO processing_ack (message_id, status, status_changed) VALUES (?, ?, ?)',
-  );
-  db.transaction(() => {
-    for (const s of skips) stmt.run(s.id, s.reason === 'error' ? 'script-skip:error' : 'completed', new Date().toISOString());
+    for (const id of ids) stmt.run(id);
   })();
 }
 
@@ -142,9 +124,9 @@ export function markScriptSkipped(skips: Array<{ id: string; reason: string }>):
 export function markFailed(id: string): void {
   getOutboundDb()
     .prepare(
-      "INSERT OR REPLACE INTO processing_ack (message_id, status, status_changed) VALUES (?, 'failed', ?)",
+      "INSERT OR REPLACE INTO processing_ack (message_id, status, status_changed) VALUES (?, 'failed', datetime('now'))",
     )
-    .run(id, new Date().toISOString());
+    .run(id);
 }
 
 /** Get a message by ID (read from inbound.db). */
@@ -181,3 +163,4 @@ export function findQuestionResponse(questionId: string): MessageInRow | undefin
     inbound.close();
   }
 }
+

container/agent-runner/src/db/messages-out.ts

@@ -58,12 +58,11 @@ export function writeMessageOut(msg: WriteMessageOut): number {
   outbound
     .prepare(
       `INSERT INTO messages_out (id, seq, in_reply_to, timestamp, deliver_after, recurrence, kind, platform_id, channel_type, thread_id, content)
-     VALUES ($id, $seq, $in_reply_to, $timestamp, $deliver_after, $recurrence, $kind, $platform_id, $channel_type, $thread_id, $content)`,
+     VALUES ($id, $seq, $in_reply_to, datetime('now'), $deliver_after, $recurrence, $kind, $platform_id, $channel_type, $thread_id, $content)`,
     )
     .run({
       $id: msg.id,
       $seq: nextSeq,
-      $timestamp: new Date().toISOString(),
       $in_reply_to: msg.in_reply_to ?? null,
       $deliver_after: msg.deliver_after ?? null,
       $recurrence: msg.recurrence ?? null,
@@ -137,27 +136,8 @@ export function getUndeliveredMessages(): MessageOutRow[] {
   return getOutboundDb()
     .prepare(
       `SELECT * FROM messages_out
-       WHERE (deliver_after IS NULL OR datetime(deliver_after) <= datetime('now'))
+       WHERE (deliver_after IS NULL OR deliver_after <= datetime('now'))
        ORDER BY timestamp ASC`,
     )
     .all() as MessageOutRow[];
 }
-
-/**
- * True if a deliberate send with this exact destination + text already exists
- * (an MCP send_message row from the current turn). Used by the task-fire
- * final-text dispatcher to drop the turn-final <message> echo of a send the
- * agent already made — the dedup happens where the duplication originates.
- */
-export function hasIdenticalSend(platformId: string, channelType: string, text: string): boolean {
-  const row = getOutboundDb()
-    .prepare(
-      `SELECT 1 FROM messages_out
-        WHERE platform_id = $platform_id AND channel_type = $channel_type
-          AND (in_reply_to IS NULL OR in_reply_to = '')
-          AND json_extract(content, '$.text') = $text
-        LIMIT 1`,
-    )
-    .get({ $platform_id: platformId, $channel_type: channelType, $text: text });
-  return row != null;
-}

container/agent-runner/src/db/session-state.ts

@@ -77,47 +77,3 @@ export function setContinuation(providerName: string, id: string): void {
 export function clearContinuation(providerName: string): void {
   deleteValue(continuationKey(providerName));
 }
-
-/**
- * The a2a reply stamp: the id of the first inbound message in the batch the
- * agent is currently processing. The poll loop publishes it at batch start;
- * MCP tools (`send_message`, `send_file`) read it and stamp it onto outbound
- * rows so the host's a2a return-path routing can correlate replies back to
- * the originating session.
- *
- * This lives in outbound.db rather than module state because the MCP server
- * runs as a separate stdio subprocess from the poll loop — module state set
- * by the poll loop is invisible to it. Both processes open outbound.db
- * (journal_mode=DELETE + busy_timeout make intra-container access safe).
- */
-const IN_REPLY_TO_KEY = 'current_in_reply_to';
-
-/**
- * Ignore a stamp older than this. The poll loop clears the stamp in a
- * finally, but a container killed mid-batch (SIGKILL) can leave one behind;
- * the guard stops a later out-of-batch read from picking up a dead stamp.
- * Generous so a long-running batch's late sends still stamp correctly.
- */
-const IN_REPLY_TO_MAX_AGE_MS = 30 * 60 * 1000;
-
-export function setCurrentInReplyTo(id: string | null): void {
-  if (id === null) {
-    clearCurrentInReplyTo();
-    return;
-  }
-  setValue(IN_REPLY_TO_KEY, id);
-}
-
-export function clearCurrentInReplyTo(): void {
-  deleteValue(IN_REPLY_TO_KEY);
-}
-
-export function getCurrentInReplyTo(): string | null {
-  const row = getOutboundDb()
-    .prepare('SELECT value, updated_at FROM session_state WHERE key = ?')
-    .get(IN_REPLY_TO_KEY) as { value: string; updated_at: string } | undefined;
-  if (!row) return null;
-  const age = Date.now() - new Date(row.updated_at).getTime();
-  if (!Number.isFinite(age) || age > IN_REPLY_TO_MAX_AGE_MS) return null;
-  return row.value;
-}

container/agent-runner/src/destinations.ts

@@ -105,11 +105,13 @@ function buildDestinationsSection(): string {
   const lines = ['## Sending messages', ''];
   if (all.length === 1) {
     const d = all[0];
-    lines.push(`Your destination is \`${d.name}\`${destinationLabel(d)}.`);
+    const label = d.displayName && d.displayName !== d.name ? ` (${d.displayName})` : '';
+    lines.push(`Your destination is \`${d.name}\`${label}.`);
   } else {
     lines.push('You can send messages to the following destinations:', '');
     for (const d of all) {
-      lines.push(`- \`${d.name}\`${destinationLabel(d)}`);
+      const label = d.displayName && d.displayName !== d.name ? ` (${d.displayName})` : '';
+      lines.push(`- \`${d.name}\`${label}`);
     }
   }
   lines.push('');
@@ -126,10 +128,3 @@ function buildDestinationsSection(): string {
   );
   return lines.join('\n');
 }
-
-function destinationLabel(d: DestinationEntry): string {
-  const parts: string[] = [];
-  if (d.channelType) parts.push(d.channelType);
-  if (d.displayName && d.displayName !== d.name) parts.push(d.displayName);
-  return parts.length > 0 ? ` (${parts.join(' · ')})` : '';
-}

container/agent-runner/src/formatter.test.ts

@@ -14,7 +14,7 @@ import { describe, it, expect, beforeEach, afterEach } from 'bun:test';
 import { initTestSessionDb, closeSessionDb, getInboundDb } from './db/connection.js';
 import { getPendingMessages } from './db/messages-in.js';
 import { formatMessages, stripInternalTags } from './formatter.js';
-import { TIMEZONE, formatLocalTime } from './timezone.js';
+import { TIMEZONE } from './timezone.js';
 
 beforeEach(() => {
   initTestSessionDb();
@@ -109,14 +109,6 @@ describe('timestamp formatting', () => {
   });
 });
 
-describe('task timestamps', () => {
-  it('renders task time in the user TZ, same as chat rows', () => {
-    insertMessage('t1', 'task', { prompt: 'do the thing' }, { timestamp: '2026-01-05T12:00:00.000Z' });
-    const result = formatMessages(getPendingMessages());
-    expect(result).toContain(`time="${formatLocalTime('2026-01-05T12:00:00.000Z', TIMEZONE)}"`);
-  });
-});
-
 describe('reply_to + quoted_message rendering', () => {
   it('renders reply_to attribute and quoted_message when all fields present', () => {
     insertMessage('m1', 'chat', {

container/agent-runner/src/formatter.ts

@@ -98,11 +98,6 @@ export interface RoutingContext {
   channelType: string | null;
   threadId: string | null;
   inReplyTo: string | null;
-  /** Batch is a task fire — explicit `<message to>` sends must NOT inherit
-   *  inReplyTo (the series id), or the host's task-fire suppression drops
-   *  them as turn-final echoes: zero delivery. Deliberate sends are
-   *  in_reply_to-null, same as the out-of-process MCP send_message path. */
-  taskFire: boolean;
 }
 
 /**
@@ -116,7 +111,6 @@ export function extractRouting(messages: MessageInRow[]): RoutingContext {
     channelType: first?.channel_type ?? null,
     threadId: first?.thread_id ?? null,
     inReplyTo: first?.id ?? null,
-    taskFire: messages.length > 0 && messages.every((m) => m.kind === 'task'),
   };
 }
 

container/agent-runner/src/mcp-tools/cli.instructions.md

@@ -18,13 +18,12 @@ Your CLI access may be scoped. Run `ncl help` to see which resources are availab
 
 Run `ncl help` for the full list. Common resources:
 
-| Resource     | Verbs                                                                                                                                     | What it is                                              |
-| ------------ | ----------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------- |
-| groups       | list, get, create, update, delete, restart, config get/update, config add-mcp-server/remove-mcp-server, config add-package/remove-package | Agent groups (workspace, personality, container config) |
-| sessions     | list, get                                                                                                                                 | Active sessions (read-only)                             |
-| destinations | list, add, remove                                                                                                                         | Where an agent group can send messages                  |
-| members      | list, add, remove                                                                                                                         | Unprivileged access gate for an agent group             |
-| tasks        | list, get, create, update, cancel, pause, resume, delete, append-log                                                                      | Scheduled tasks for your agent group                    |
+| Resource | Verbs | What it is |
+|----------|-------|------------|
+| groups | list, get, create, update, delete, restart, config get/update, config add-mcp-server/remove-mcp-server, config add-package/remove-package | Agent groups (workspace, personality, container config) |
+| sessions | list, get | Active sessions (read-only) |
+| destinations | list, add, remove | Where an agent group can send messages |
+| members | list, add, remove | Unprivileged access gate for an agent group |
 
 Additional resources (available under `global` scope only): messaging-groups, wirings, users, roles, user-dms, dropped-messages, approvals.
 
@@ -34,12 +33,11 @@ Additional resources (available under `global` scope only): messaging-groups, wi
 - **Restarting your container** — `ncl groups restart` (with optional `--rebuild` and `--message`).
 - **Checking who's in your group** — `ncl members list`.
 - **Seeing your destinations** — `ncl destinations list`.
-- **Scheduling work** — `ncl tasks create`, then `ncl tasks list/get/update/cancel/pause/resume/delete`; `ncl tasks run <id>` fires one extra run now (testing) without changing the schedule. At the end of each task run, `ncl tasks append-log --msg "…"` to record what happened (host-timestamped, not a message).
 - **Answering questions about the system** — query `ncl` rather than guessing.
 
 ### Access rules
 
-Read commands (list, get) are open. Most write commands (create, update, delete, restart, config update, add, remove) require admin approval — the request is held until an admin approves it. `ncl tasks` is the exception: an agent can manage its own group tasks without approval.
+Read commands (list, get) are open. Write commands (create, update, delete, restart, config update, add, remove) require admin approval — the request is held until an admin approves it.
 
 ### Approval flow
 
@@ -63,13 +61,6 @@ ncl groups config get
 ncl sessions list
 ncl destinations list
 ncl members list
-ncl tasks list
-# Always pass a short descriptive --name so the task id is readable (e.g. daily-briefing-a25c, not a long uuid).
-# For a recurring task, --recurrence alone sets the schedule (first run derived from it); add --process-after only for one-shots.
-ncl tasks create --name "daily briefing" --prompt "Send the daily briefing" --recurrence "0 9 * * *"
-# At the END of every task run, record one line of history. The host stamps the local time — you supply only the summary.
-# This is a LOG ENTRY, not a message: it sends nothing to anyone. Inside a task fire --id is auto-derived from your session.
-ncl tasks append-log --msg "posted the daily digest to slack; one feed returned 403, skipped"
 
 # Write commands (approval required)
 ncl groups restart

container/agent-runner/src/mcp-tools/core.test.ts

@@ -4,31 +4,14 @@
  * batch in poll-loop, and outbound writes from MCP tools (send_message,
  * send_file) must pick it up so a2a return-path routing on the host can
  * correlate replies back to the originating session.
- *
- * The stamp is published through session_state in outbound.db, not module
- * state — the MCP server runs as a separate stdio subprocess from the poll
- * loop, so it can only see the stamp through the shared DB. These tests seed
- * it the same way the poll-loop process does (a direct DB write) rather than
- * via any in-memory helper, so they exercise the real process boundary.
  */
 import { describe, it, expect, beforeEach, afterEach } from 'bun:test';
 
-import { initTestSessionDb, closeSessionDb, getInboundDb, getOutboundDb } from '../db/connection.js';
+import { initTestSessionDb, closeSessionDb, getInboundDb } from '../db/connection.js';
 import { getUndeliveredMessages } from '../db/messages-out.js';
+import { setCurrentInReplyTo, clearCurrentInReplyTo } from '../current-batch.js';
 import { sendMessage } from './core.js';
 
-/**
- * Publish the a2a reply stamp the way the poll loop does: a direct write to
- * session_state in outbound.db. `ageMs` back-dates updated_at to exercise the
- * staleness guard MCP tools apply when reading it.
- */
-function publishInReplyTo(id: string, ageMs = 0): void {
-  const updatedAt = new Date(Date.now() - ageMs).toISOString();
-  getOutboundDb()
-    .prepare('INSERT OR REPLACE INTO session_state (key, value, updated_at) VALUES (?, ?, ?)')
-    .run('current_in_reply_to', id, updatedAt);
-}
-
 beforeEach(() => {
   initTestSessionDb();
   // Seed a peer agent destination
@@ -41,12 +24,13 @@ beforeEach(() => {
 });
 
 afterEach(() => {
+  clearCurrentInReplyTo();
   closeSessionDb();
 });
 
 describe('send_message MCP tool — in_reply_to plumbing', () => {
-  it('stamps the batch in_reply_to (published via the DB) on outbound rows', async () => {
-    publishInReplyTo('inbound-msg-1');
+  it('stamps current batch in_reply_to on outbound rows', async () => {
+    setCurrentInReplyTo('inbound-msg-1');
 
     await sendMessage.handler({ to: 'peer', text: 'hello' });
 
@@ -56,17 +40,7 @@ describe('send_message MCP tool — in_reply_to plumbing', () => {
   });
 
   it('writes null when no batch is active', async () => {
-    // Nothing published to session_state — simulates ad-hoc / out-of-batch invocation.
-    await sendMessage.handler({ to: 'peer', text: 'hello' });
-
-    const out = getUndeliveredMessages();
-    expect(out).toHaveLength(1);
-    expect(out[0].in_reply_to).toBeNull();
-  });
-
-  it('ignores a stale stamp left behind by a killed container', async () => {
-    publishInReplyTo('inbound-msg-1', 60 * 60 * 1000); // an hour old
-
+    // No setCurrentInReplyTo before this call — simulates ad-hoc / out-of-batch invocation.
     await sendMessage.handler({ to: 'peer', text: 'hello' });
 
     const out = getUndeliveredMessages();

container/agent-runner/src/mcp-tools/core.ts

@@ -9,9 +9,9 @@
 import fs from 'fs';
 import path from 'path';
 
+import { getCurrentInReplyTo } from '../current-batch.js';
 import { findByName, getAllDestinations } from '../destinations.js';
 import { getMessageIdBySeq, getRoutingBySeq, writeMessageOut } from '../db/messages-out.js';
-import { getCurrentInReplyTo } from '../db/session-state.js';
 import { getSessionRouting } from '../db/session-routing.js';
 import { registerTools } from './server.js';
 import type { McpToolDefinition } from './types.js';

container/agent-runner/src/mcp-tools/index.ts

@@ -6,6 +6,7 @@
  * at module scope, and append the import here. No central list.
  */
 import './core.js';
+import './scheduling.js';
 import './interactive.js';
 import './agents.js';
 import './self-mod.js';

container/agent-runner/src/mcp-tools/scheduling.instructions.md

@@ -1,25 +1,40 @@
-## Task scheduling (`ncl tasks`)
+## Task scheduling (`schedule_task`)
 
-Use `ncl tasks` for one-shot and recurring tasks. A task runs in this agent group's system session, not in the current chat session, so when it fires you must choose a destination explicitly with `<message to="name">...</message>` or `send_message({ to: "name", ... })`.
+For any recurring task, use `schedule_task`. This is the scheduling path — tasks persist across sessions and restarts, and support the pre-task `script` hook described below.
 
-Pass `--name "<short label>"` on create to get a readable task id (e.g. `--name "sales briefing"` → `sales-briefing-a25c`); without it ids are `t-<hex>`.
+To inspect or change existing tasks, use `list_tasks` (returns one row per series with the stable id) and `update_task` / `cancel_task` / `pause_task` / `resume_task`. Prefer `update_task` over cancel + reschedule.
 
-Common commands:
+Frequent recurring scheduled tasks — more than a few times a day — consume API credits and can risk account restrictions. You can add a `script` that runs first, and you will only be called when the check passes.
+
+### How it works
+
+1. Provide a bash `script` alongside the `prompt` when scheduling
+2. When the task fires, the script runs first
+3. Script returns: `{ "wakeAgent": true/false, "data": {...} }`
+4. If `wakeAgent: false` — nothing happens, task waits for next run
+5. If `wakeAgent: true` — claude receives the script's data + prompt and handles
+
+### Always test your script first
+
+Before scheduling, run the script directly to verify it works:
 
 ```bash
-ncl tasks create --name "ping" --prompt "Remind me to call Dana" --process-after "tomorrow 18:00"
-ncl tasks list
-ncl tasks get ping-a25c        # includes run count, failures, and recent run-log lines
-ncl tasks run ping-a25c         # fire once now without changing the schedule (testing)
-ncl tasks update ping-a25c --prompt "New instructions"
-ncl tasks pause ping-a25c
-ncl tasks resume ping-a25c
-ncl tasks cancel ping-a25c      # or --all as a kill switch
-ncl tasks delete ping-a25c
+bash -c 'node --input-type=module -e "
+  const r = await fetch(\"https://api.github.com/repos/owner/repo/pulls?state=open\");
+  const prs = await r.json();
+  console.log(JSON.stringify({ wakeAgent: prs.length > 0, data: prs.slice(0, 5) }));
+"'
 ```
 
-Use good judgement on whether it's appropriate to check in with the user about the task prompt before task creation, and if so, whether to share verbatim or a description of it.
+### When NOT to use scripts
 
-`--process-after` accepts UTC timestamps or naive local timestamps interpreted in the instance timezone (shown in the `<context timezone="..."/>` header).
+If a task requires your judgment every time (daily briefings, reminders, reports), skip the script — just use a regular prompt. Do not attempt to do things like sentiment analysis or advanced nlp in scripts.
 
-Run `ncl tasks create --help` for schedules, options, and pre-task gate scripts (checks that run before you wake).
+### Frequent task guidance
+
+If a user wants a task to run more than a few times a day and a script can't be used:
+
+- Explain that each time the task fires it uses API credits and risks rate limits
+- Suggest adjusting the task requirements in a way that will allow you to use a script
+- If the user needs an LLM to evaluate data, suggest using an API key with direct Anthropic API calls inside the script
+- Help the user find the minimum viable frequency

container/agent-runner/src/mcp-tools/scheduling.ts

@@ -0,0 +1,302 @@
+/**
+ * Scheduling MCP tools: schedule_task, list_tasks, cancel_task, pause_task, resume_task.
+ *
+ * With the two-DB split, the container cannot write to inbound.db (host-owned).
+ * Scheduling operations are sent as system actions via messages_out — the host
+ * reads them during delivery and applies the changes to inbound.db.
+ */
+import { getInboundDb } from '../db/connection.js';
+import { writeMessageOut } from '../db/messages-out.js';
+import { getSessionRouting } from '../db/session-routing.js';
+import { TIMEZONE, parseZonedToUtc } from '../timezone.js';
+import { registerTools } from './server.js';
+import type { McpToolDefinition } from './types.js';
+
+function log(msg: string): void {
+  console.error(`[mcp-tools] ${msg}`);
+}
+
+function generateId(): string {
+  return `task-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+}
+
+function routing() {
+  return getSessionRouting();
+}
+
+function ok(text: string) {
+  return { content: [{ type: 'text' as const, text }] };
+}
+
+function err(text: string) {
+  return { content: [{ type: 'text' as const, text: `Error: ${text}` }], isError: true };
+}
+
+export const scheduleTask: McpToolDefinition = {
+  tool: {
+    name: 'schedule_task',
+    description:
+      `Schedule a one-shot or recurring task. The user's timezone is declared in the <context timezone="..."/> header of your prompt — interpret the user's "9pm" etc. in that zone. Cron expressions are interpreted in the user's timezone too.`,
+    inputSchema: {
+      type: 'object' as const,
+      properties: {
+        prompt: { type: 'string', description: 'Task instructions/prompt' },
+        processAfter: {
+          type: 'string',
+          description:
+            `ISO 8601 timestamp for the first run. Accepts either UTC (ending in "Z" or "+00:00") or a naive local timestamp (no offset) which is interpreted in the user's timezone (e.g. "2026-01-15T21:00:00" = 9pm user-local). Prefer naive local.`,
+        },
+        recurrence: {
+          type: 'string',
+          description:
+            'Cron expression for recurring tasks (e.g., "0 9 * * 1-5" = weekdays at 9am user-local). Evaluated in the user\'s timezone.',
+        },
+        script: { type: 'string', description: 'Optional pre-agent script to run before processing' },
+      },
+      required: ['prompt', 'processAfter'],
+    },
+  },
+  async handler(args) {
+    const prompt = args.prompt as string;
+    const processAfterIn = args.processAfter as string;
+    if (!prompt || !processAfterIn) return err('prompt and processAfter are required');
+
+    let processAfter: string;
+    try {
+      const d = parseZonedToUtc(processAfterIn, TIMEZONE);
+      if (Number.isNaN(d.getTime())) return err(`invalid processAfter: ${processAfterIn}`);
+      processAfter = d.toISOString();
+    } catch {
+      return err(`invalid processAfter: ${processAfterIn}`);
+    }
+
+    const id = generateId();
+    const r = routing();
+    const recurrence = (args.recurrence as string) || null;
+    const script = (args.script as string) || null;
+
+    // Write as a system action — host will insert into inbound.db
+    writeMessageOut({
+      id,
+      kind: 'system',
+      platform_id: r.platform_id,
+      channel_type: r.channel_type,
+      thread_id: r.thread_id,
+      content: JSON.stringify({
+        action: 'schedule_task',
+        taskId: id,
+        prompt,
+        script,
+        processAfter,
+        recurrence,
+        platformId: r.platform_id,
+        channelType: r.channel_type,
+        threadId: r.thread_id,
+      }),
+    });
+
+    log(`schedule_task: ${id} at ${processAfter}${recurrence ? ` (recurring: ${recurrence})` : ''}`);
+    return ok(`Task scheduled (id: ${id}, runs at: ${processAfter}${recurrence ? `, recurrence: ${recurrence}` : ''})`);
+  },
+};
+
+export const listTasks: McpToolDefinition = {
+  tool: {
+    name: 'list_tasks',
+    description:
+      'List scheduled tasks. Returns one row per series — the live (pending or paused) occurrence. The id shown is the series id, which is what update_task / cancel_task / pause_task / resume_task expect.',
+    inputSchema: {
+      type: 'object' as const,
+      properties: {
+        status: { type: 'string', description: 'Filter by status: pending or paused (default: both)' },
+      },
+    },
+  },
+  async handler(args) {
+    const status = args.status as string | undefined;
+    const db = getInboundDb();
+    // One row per series — the live (pending or paused) occurrence. Recurring
+    // tasks accumulate one completed row per firing plus one live follow-up;
+    // exposing the whole pile to the agent is noisy and confuses task identity
+    // ("which id do I cancel?"). The series_id is the stable handle.
+    //
+    // SQLite quirk: when MAX(seq) appears in the SELECT list of a GROUP BY
+    // query, the bare columns take values from the row that contains that max
+    // — that's how we pick "the latest live row per series" in one pass.
+    let rows;
+    if (status) {
+      rows = db
+        .prepare(
+          `SELECT series_id AS id, status, process_after, recurrence, content, MAX(seq) AS _seq
+             FROM messages_in
+            WHERE kind = 'task' AND status = ?
+            GROUP BY series_id
+            ORDER BY process_after ASC`,
+        )
+        .all(status);
+    } else {
+      rows = db
+        .prepare(
+          `SELECT series_id AS id, status, process_after, recurrence, content, MAX(seq) AS _seq
+             FROM messages_in
+            WHERE kind = 'task' AND status IN ('pending', 'paused')
+            GROUP BY series_id
+            ORDER BY process_after ASC`,
+        )
+        .all();
+    }
+
+    if ((rows as unknown[]).length === 0) return ok('No tasks found.');
+
+    const lines = (rows as Array<{ id: string; status: string; process_after: string | null; recurrence: string | null; content: string }>).map((r) => {
+      const content = JSON.parse(r.content);
+      const prompt = (content.prompt as string || '').slice(0, 80);
+      return `- ${r.id} [${r.status}] at=${r.process_after || 'now'} ${r.recurrence ? `recur=${r.recurrence} ` : ''}→ ${prompt}`;
+    });
+
+    return ok(lines.join('\n'));
+  },
+};
+
+export const cancelTask: McpToolDefinition = {
+  tool: {
+    name: 'cancel_task',
+    description: 'Cancel a scheduled task.',
+    inputSchema: {
+      type: 'object' as const,
+      properties: {
+        taskId: { type: 'string', description: 'Task ID to cancel' },
+      },
+      required: ['taskId'],
+    },
+  },
+  async handler(args) {
+    const taskId = args.taskId as string;
+    if (!taskId) return err('taskId is required');
+
+    // Write as a system action — host will update inbound.db
+    writeMessageOut({
+      id: `sys-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+      kind: 'system',
+      content: JSON.stringify({ action: 'cancel_task', taskId }),
+    });
+
+    log(`cancel_task: ${taskId}`);
+    return ok(`Task cancellation requested: ${taskId}`);
+  },
+};
+
+export const pauseTask: McpToolDefinition = {
+  tool: {
+    name: 'pause_task',
+    description: 'Pause a scheduled task. It will not run until resumed.',
+    inputSchema: {
+      type: 'object' as const,
+      properties: {
+        taskId: { type: 'string', description: 'Task ID to pause' },
+      },
+      required: ['taskId'],
+    },
+  },
+  async handler(args) {
+    const taskId = args.taskId as string;
+    if (!taskId) return err('taskId is required');
+
+    writeMessageOut({
+      id: `sys-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+      kind: 'system',
+      content: JSON.stringify({ action: 'pause_task', taskId }),
+    });
+
+    log(`pause_task: ${taskId}`);
+    return ok(`Task pause requested: ${taskId}`);
+  },
+};
+
+export const resumeTask: McpToolDefinition = {
+  tool: {
+    name: 'resume_task',
+    description: 'Resume a paused task.',
+    inputSchema: {
+      type: 'object' as const,
+      properties: {
+        taskId: { type: 'string', description: 'Task ID to resume' },
+      },
+      required: ['taskId'],
+    },
+  },
+  async handler(args) {
+    const taskId = args.taskId as string;
+    if (!taskId) return err('taskId is required');
+
+    writeMessageOut({
+      id: `sys-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+      kind: 'system',
+      content: JSON.stringify({ action: 'resume_task', taskId }),
+    });
+
+    log(`resume_task: ${taskId}`);
+    return ok(`Task resume requested: ${taskId}`);
+  },
+};
+
+export const updateTask: McpToolDefinition = {
+  tool: {
+    name: 'update_task',
+    description:
+      'Update a scheduled task. Pass the series id from list_tasks. Any field omitted is left unchanged. Use this instead of cancel + reschedule when adjusting an existing task.',
+    inputSchema: {
+      type: 'object' as const,
+      properties: {
+        taskId: { type: 'string', description: 'Series id of the task to update (as shown by list_tasks)' },
+        prompt: { type: 'string', description: 'New task prompt (optional)' },
+        recurrence: {
+          type: 'string',
+          description: 'New cron expression (optional). Pass empty string to clear and make the task one-shot.',
+        },
+        processAfter: {
+          type: 'string',
+          description:
+            `New ISO 8601 timestamp for the next run (optional). Accepts either UTC (ending in "Z" / "+00:00") or a naive local timestamp interpreted in the user's timezone.`,
+        },
+        script: {
+          type: 'string',
+          description: 'New pre-agent script (optional). Pass empty string to clear.',
+        },
+      },
+      required: ['taskId'],
+    },
+  },
+  async handler(args) {
+    const taskId = args.taskId as string;
+    if (!taskId) return err('taskId is required');
+
+    const update: Record<string, unknown> = { taskId };
+    if (typeof args.prompt === 'string') update.prompt = args.prompt;
+    if (typeof args.processAfter === 'string') {
+      try {
+        const d = parseZonedToUtc(args.processAfter, TIMEZONE);
+        if (Number.isNaN(d.getTime())) return err(`invalid processAfter: ${args.processAfter}`);
+        update.processAfter = d.toISOString();
+      } catch {
+        return err(`invalid processAfter: ${args.processAfter}`);
+      }
+    }
+    // Empty string clears recurrence/script; undefined leaves them as-is.
+    if (typeof args.recurrence === 'string') update.recurrence = args.recurrence === '' ? null : args.recurrence;
+    if (typeof args.script === 'string') update.script = args.script === '' ? null : args.script;
+
+    if (Object.keys(update).length === 1) return err('at least one field to update is required');
+
+    writeMessageOut({
+      id: `sys-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+      kind: 'system',
+      content: JSON.stringify({ action: 'update_task', ...update }),
+    });
+
+    log(`update_task: ${taskId}`);
+    return ok(`Task update requested: ${taskId}`);
+  },
+};
+
+registerTools([scheduleTask, listTasks, updateTask, cancelTask, pauseTask, resumeTask]);

container/agent-runner/src/poll-loop.ts

@@ -1,14 +1,9 @@
 import { findByName, getAllDestinations, type DestinationEntry } from './destinations.js';
-import { getPendingMessages, markProcessing, markCompleted, markScriptSkipped, type MessageInRow } from './db/messages-in.js';
-import { hasIdenticalSend, writeMessageOut } from './db/messages-out.js';
+import { getPendingMessages, markProcessing, markCompleted, type MessageInRow } from './db/messages-in.js';
+import { writeMessageOut } from './db/messages-out.js';
 import { getInboundDb, touchHeartbeat, clearStaleProcessingAcks } from './db/connection.js';
-import {
-  clearContinuation,
-  clearCurrentInReplyTo,
-  migrateLegacyContinuation,
-  setContinuation,
-  setCurrentInReplyTo,
-} from './db/session-state.js';
+import { clearContinuation, migrateLegacyContinuation, setContinuation } from './db/session-state.js';
+import { clearCurrentInReplyTo, setCurrentInReplyTo } from './current-batch.js';
 import {
   formatMessages,
   extractRouting,
@@ -207,15 +202,15 @@ export async function runPollLoop(config: PollLoopConfig): Promise<void> {
     // Without the scheduling module, the marker block is empty, `keep`
     // falls back to `normalMessages`, and no gating happens.
     let keep: MessageInRow[] = normalMessages;
-    let skipped: Array<{ id: string; reason: string }> = [];
+    let skipped: string[] = [];
     // MODULE-HOOK:scheduling-pre-task:start
     const { applyPreTaskScripts } = await import('./scheduling/task-script.js');
     const preTask = await applyPreTaskScripts(normalMessages);
     keep = preTask.keep;
     skipped = preTask.skipped;
     if (skipped.length > 0) {
-      markScriptSkipped(skipped);
-      log(`Pre-task script skipped ${skipped.length} task(s): ${skipped.map((s) => s.id).join(', ')}`);
+      markCompleted(skipped);
+      log(`Pre-task script skipped ${skipped.length} task(s): ${skipped.join(', ')}`);
     }
     // MODULE-HOOK:scheduling-pre-task:end
 
@@ -238,7 +233,7 @@ export async function runPollLoop(config: PollLoopConfig): Promise<void> {
     });
 
     // Process the query while concurrently polling for new messages
-    const skippedSet = new Set(skipped.map((s) => s.id));
+    const skippedSet = new Set(skipped);
     const processingIds = ids.filter((id) => !commandIds.includes(id) && !skippedSet.has(id));
     // Publish the batch's in_reply_to so MCP tools (send_message, send_file)
     // can stamp it on outbound rows — needed for a2a return-path routing.
@@ -401,15 +396,15 @@ export async function processQuery(
         // its script gate and always wakes the agent, defeating the gate.
         // Mirrors the initial-batch hook above.
         let keep = newMessages;
-        let skipped: Array<{ id: string; reason: string }> = [];
+        let skipped: string[] = [];
         // MODULE-HOOK:scheduling-pre-task-followup:start
         const { applyPreTaskScripts } = await import('./scheduling/task-script.js');
         const preTask = await applyPreTaskScripts(newMessages);
         keep = preTask.keep;
         skipped = preTask.skipped;
         if (skipped.length > 0) {
-          markScriptSkipped(skipped);
-          log(`Pre-task script skipped ${skipped.length} follow-up task(s): ${skipped.map((s) => s.id).join(', ')}`);
+          markCompleted(skipped);
+          log(`Pre-task script skipped ${skipped.length} follow-up task(s): ${skipped.join(', ')}`);
         }
         // MODULE-HOOK:scheduling-pre-task-followup:end
 
@@ -650,15 +645,6 @@ function dispatchResultText(text: string, routing: RoutingContext): { sent: numb
 function sendToDestination(dest: DestinationEntry, body: string, routing: RoutingContext): void {
   const platformId = dest.type === 'channel' ? dest.platformId! : dest.agentGroupId!;
   const channelType = dest.type === 'channel' ? dest.channelType! : 'agent';
-  // Task fires: an explicitly-addressed final-text block is either the echo of
-  // an MCP send the agent already made this turn (drop it HERE, where the
-  // duplication originates) or the agent's only deliberate send (write it
-  // in_reply_to-null like the MCP path, or the host's task-fire suppression
-  // would discard it — zero delivery).
-  if (routing.taskFire && hasIdenticalSend(platformId, channelType, body)) {
-    log(`Dropping turn-final echo of an already-sent task message to ${dest.name}`);
-    return;
-  }
   // Resolve thread_id per-destination from the most recent inbound message
   // that came from this same channel+platform. In agent-shared sessions,
   // different destinations have different thread contexts — using a single
@@ -666,7 +652,7 @@ function sendToDestination(dest: DestinationEntry, body: string, routing: Routin
   const destRouting = resolveDestinationThread(channelType, platformId);
   writeMessageOut({
     id: generateId(),
-    in_reply_to: destRouting?.inReplyTo ?? (routing.taskFire ? null : routing.inReplyTo),
+    in_reply_to: destRouting?.inReplyTo ?? routing.inReplyTo,
     kind: 'chat',
     platform_id: platformId,
     channel_type: channelType,