@phnx-labs/agents-cli 1.22.34 → 1.22.37

package/dist/lib/activity.js

@@ -20,6 +20,7 @@
 import * as fs from 'fs';
 import * as path from 'path';
 import * as yaml from 'yaml';
+import { stringifyDoc } from './yaml-io.js';
 import chalk from 'chalk';
 import { relTime, truncate } from './format.js';
 import { getActivityDir, getUserAgentsDir } from './state.js';
@@ -1561,7 +1562,13 @@ export function ensureActivityLogHook(userAgentsDir = getUserAgentsDir()) {
         }
         if (installed) {
             const tmpYaml = `${agentsYamlPath}.${process.pid}.tmp`;
-            fs.writeFileSync(tmpYaml, String(yamlDoc));
+            // `flowCollectionPadding: false` matches the committed formatting — see the
+            // twin `ensureFeedPublishHook` in feed.ts. Without it, re-emitting a
+            // committed flow node (`[a, b]` -> `[ a, b ]`) leaves the git-backed
+            // `~/.agents` tree permanently dirty and blocks `agents repo pull`
+            // fleet-wide (RUSH-2505). This writer runs back-to-back with the feed one
+            // on the `agents feed` path, so both must round-trip cleanly.
+            fs.writeFileSync(tmpYaml, stringifyDoc(yamlDoc));
             fs.renameSync(tmpYaml, agentsYamlPath);
         }
         return { installed };

package/dist/lib/add-dir.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Cross-harness application of project / `--add-dir` directory grants.
+ *
+ * A multi-repo project binds several checkouts; the primary becomes cwd and the
+ * rest become grants so the agent can read and write the siblings. How a grant
+ * lands depends on the harness:
+ *
+ * - `native-flag`  — Claude, Kimi, Cursor: repeatable `--add-dir <path>`
+ * - `codex-policy` — Codex: folded into the named edit profile's workspace_roots
+ *                    (handled in buildExecCommand / codex-policy, not here)
+ * - `grok-sandbox` — Grok: OS sandbox is off by default (siblings already
+ *                    writable); when a non-off sandbox is active, write a
+ *                    project-local profile with `read_write` and select it.
+ *                    Always appends a short `--rules` note so the model knows
+ *                    the siblings are in scope.
+ * - `none`         — harness has no multi-root surface; grants are ignored
+ *                    (caller may warn). Not a configuration mistake — the CLI
+ *                    has nowhere to put the grant.
+ *
+ * Capability honesty: only strategies that actually change the launch count as
+ * support. Silent no-ops stay `none`.
+ */
+import type { AgentId } from './types.js';
+export type AddDirStrategy = 'native-flag' | 'codex-policy' | 'grok-sandbox' | 'none';
+/** How each harness consumes directory grants. Keep in lockstep with apply* below. */
+export declare const ADD_DIR_STRATEGY: Record<AgentId, AddDirStrategy>;
+/** Agents whose launch command is widened by applyAddDirs (excludes codex — policy path). */
+export declare function agentsWithNativeOrGrokAddDir(): AgentId[];
+/** Expand `~` / `$HOME` and de-dupe, preserving order. */
+export declare function normalizeAddDirs(dirs: string[] | undefined): string[];
+/**
+ * Append native `--add-dir` flags for harnesses that take them (Claude, Kimi, Cursor).
+ * No-op for other strategies — call sites route by ADD_DIR_STRATEGY.
+ */
+export declare function appendNativeAddDirFlags(cmd: string[], dirs: string[]): void;
+/** Profile name written into `.grok/sandbox.toml` under the run cwd. */
+export declare const GROK_PROJECT_SANDBOX_PROFILE = "agents-project";
+/**
+ * Active Grok sandbox profile from the env, if a non-off profile is set.
+ * Returns null when sandbox is off / unset / devbox (no widen needed).
+ *
+ * Only `GROK_SANDBOX` is consulted — a profile set only in config.toml is not
+ * visible here (Grok does not expose it on the CLI), so those runs still get
+ * the rules note but not a custom widen. Prefer env when launching sandboxed.
+ */
+export declare function grokActiveSandboxProfile(env?: NodeJS.ProcessEnv): string | null;
+/** Whether Grok's active sandbox needs a custom profile with extra read_write. */
+export declare function grokNeedsSandboxWiden(env?: NodeJS.ProcessEnv): boolean;
+/**
+ * Ensure `.grok/sandbox.toml` under `cwd` defines `[profiles.agents-project]`
+ * with `read_write` covering every grant, **extending the active base profile**
+ * (so `GROK_SANDBOX=strict` does not silently widen to `workspace`).
+ * Returns the profile name to pass as `--sandbox`, or null when not needed.
+ *
+ * Idempotent: rewrites only the managed profile block.
+ */
+export declare function ensureGrokProjectSandboxProfile(cwd: string, dirs: string[], opts?: {
+    extendsBase?: string;
+}): string | null;
+/**
+ * Short rules blob so Grok's model treats sibling dirs as in-scope.
+ * Wording tracks whether we actually widened the sandbox for write access.
+ */
+export declare function grokAddDirRules(dirs: string[], opts?: {
+    writeGranted?: boolean;
+}): string;
+/**
+ * Apply directory grants on the argv for harnesses handled here.
+ * Codex is intentionally excluded — its path lives next to codexPolicyArgs.
+ *
+ * @returns true when any argv / on-disk change was made for the grants
+ */
+export declare function applyAddDirs(agent: AgentId, cmd: string[], dirs: string[] | undefined, opts?: {
+    cwd?: string;
+    env?: NodeJS.ProcessEnv;
+}): boolean;
+/** Whether this harness effectively consumes directory grants. */
+export declare function supportsAddDir(agent: AgentId): boolean;
+/** One-line note for harnesses that ignore grants (used by callers that want to warn). */
+export declare function addDirUnsupportedNote(agent: AgentId): string | null;

package/dist/lib/add-dir.js

@@ -0,0 +1,241 @@
+/**
+ * Cross-harness application of project / `--add-dir` directory grants.
+ *
+ * A multi-repo project binds several checkouts; the primary becomes cwd and the
+ * rest become grants so the agent can read and write the siblings. How a grant
+ * lands depends on the harness:
+ *
+ * - `native-flag`  — Claude, Kimi, Cursor: repeatable `--add-dir <path>`
+ * - `codex-policy` — Codex: folded into the named edit profile's workspace_roots
+ *                    (handled in buildExecCommand / codex-policy, not here)
+ * - `grok-sandbox` — Grok: OS sandbox is off by default (siblings already
+ *                    writable); when a non-off sandbox is active, write a
+ *                    project-local profile with `read_write` and select it.
+ *                    Always appends a short `--rules` note so the model knows
+ *                    the siblings are in scope.
+ * - `none`         — harness has no multi-root surface; grants are ignored
+ *                    (caller may warn). Not a configuration mistake — the CLI
+ *                    has nowhere to put the grant.
+ *
+ * Capability honesty: only strategies that actually change the launch count as
+ * support. Silent no-ops stay `none`.
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { expandLocalHome } from './project-root.js';
+/** How each harness consumes directory grants. Keep in lockstep with apply* below. */
+export const ADD_DIR_STRATEGY = {
+    claude: 'native-flag',
+    kimi: 'native-flag',
+    cursor: 'native-flag',
+    codex: 'codex-policy',
+    grok: 'grok-sandbox',
+    // No multi-root CLI surface today (single --dir / project path).
+    opencode: 'none',
+    gemini: 'none',
+    pi: 'none',
+    openclaw: 'none',
+    copilot: 'none',
+    amp: 'none',
+    kiro: 'none',
+    goose: 'none',
+    antigravity: 'none',
+    droid: 'none',
+    hermes: 'none',
+    muse: 'none',
+    warp: 'none',
+};
+/** Agents whose launch command is widened by applyAddDirs (excludes codex — policy path). */
+export function agentsWithNativeOrGrokAddDir() {
+    return Object.keys(ADD_DIR_STRATEGY).filter((id) => ADD_DIR_STRATEGY[id] === 'native-flag' || ADD_DIR_STRATEGY[id] === 'grok-sandbox');
+}
+/** Expand `~` / `$HOME` and de-dupe, preserving order. */
+export function normalizeAddDirs(dirs) {
+    if (!dirs?.length)
+        return [];
+    const seen = new Set();
+    const out = [];
+    for (const raw of dirs) {
+        const expanded = expandLocalHome(raw);
+        if (!expanded || seen.has(expanded))
+            continue;
+        seen.add(expanded);
+        out.push(expanded);
+    }
+    return out;
+}
+/**
+ * Append native `--add-dir` flags for harnesses that take them (Claude, Kimi, Cursor).
+ * No-op for other strategies — call sites route by ADD_DIR_STRATEGY.
+ */
+export function appendNativeAddDirFlags(cmd, dirs) {
+    for (const dir of dirs) {
+        cmd.push('--add-dir', dir);
+    }
+}
+/** Profile name written into `.grok/sandbox.toml` under the run cwd. */
+export const GROK_PROJECT_SANDBOX_PROFILE = 'agents-project';
+/**
+ * Active Grok sandbox profile from the env, if a non-off profile is set.
+ * Returns null when sandbox is off / unset / devbox (no widen needed).
+ *
+ * Only `GROK_SANDBOX` is consulted — a profile set only in config.toml is not
+ * visible here (Grok does not expose it on the CLI), so those runs still get
+ * the rules note but not a custom widen. Prefer env when launching sandboxed.
+ */
+export function grokActiveSandboxProfile(env = process.env) {
+    const raw = (env.GROK_SANDBOX ?? '').trim();
+    if (!raw)
+        return null;
+    const lower = raw.toLowerCase();
+    if (lower === 'off' || lower === 'devbox')
+        return null;
+    // Never extend our own managed profile (would recurse).
+    if (lower === GROK_PROJECT_SANDBOX_PROFILE.toLowerCase())
+        return 'workspace';
+    return raw;
+}
+/** Whether Grok's active sandbox needs a custom profile with extra read_write. */
+export function grokNeedsSandboxWiden(env = process.env) {
+    return grokActiveSandboxProfile(env) !== null;
+}
+/**
+ * Ensure `.grok/sandbox.toml` under `cwd` defines `[profiles.agents-project]`
+ * with `read_write` covering every grant, **extending the active base profile**
+ * (so `GROK_SANDBOX=strict` does not silently widen to `workspace`).
+ * Returns the profile name to pass as `--sandbox`, or null when not needed.
+ *
+ * Idempotent: rewrites only the managed profile block.
+ */
+export function ensureGrokProjectSandboxProfile(cwd, dirs, opts = {}) {
+    if (!dirs.length)
+        return null;
+    if (!cwd)
+        return null;
+    const base = opts.extendsBase ?? 'workspace';
+    // Refuse to extend ourselves or an empty name.
+    const extendsBase = !base || base.toLowerCase() === GROK_PROJECT_SANDBOX_PROFILE.toLowerCase()
+        ? 'workspace'
+        : base;
+    const grokDir = path.join(cwd, '.grok');
+    const sandboxPath = path.join(grokDir, 'sandbox.toml');
+    const readWriteLines = dirs
+        .map((d) => `  ${JSON.stringify(d)},`)
+        .join('\n');
+    const managedBlock = [
+        '# BEGIN agents-cli managed — project multi-repo grants (do not edit by hand)',
+        `[profiles.${GROK_PROJECT_SANDBOX_PROFILE}]`,
+        `extends = ${JSON.stringify(extendsBase)}`,
+        'read_write = [',
+        readWriteLines,
+        ']',
+        '# END agents-cli managed',
+        '',
+    ].join('\n');
+    let existing = '';
+    try {
+        existing = fs.readFileSync(sandboxPath, 'utf-8');
+    }
+    catch {
+        // create fresh
+    }
+    const begin = '# BEGIN agents-cli managed';
+    const end = '# END agents-cli managed';
+    let next;
+    const beginIdx = existing.indexOf(begin);
+    const endIdx = existing.indexOf(end);
+    if (beginIdx !== -1 && endIdx !== -1 && endIdx > beginIdx) {
+        // Replace through end of the end-marker line
+        const afterEnd = existing.indexOf('\n', endIdx);
+        const endCut = afterEnd === -1 ? existing.length : afterEnd + 1;
+        next = existing.slice(0, beginIdx) + managedBlock + existing.slice(endCut);
+    }
+    else if (existing.trim()) {
+        // If a hand-written [profiles.agents-project] already exists without our
+        // markers, refuse to append a second block with the same name.
+        const bare = new RegExp(`\\[profiles\\.${GROK_PROJECT_SANDBOX_PROFILE}\\]`);
+        if (bare.test(existing)) {
+            return null;
+        }
+        next = existing.replace(/\s*$/, '\n\n') + managedBlock;
+    }
+    else {
+        next = managedBlock;
+    }
+    fs.mkdirSync(grokDir, { recursive: true });
+    fs.writeFileSync(sandboxPath, next, 'utf-8');
+    return GROK_PROJECT_SANDBOX_PROFILE;
+}
+/**
+ * Short rules blob so Grok's model treats sibling dirs as in-scope.
+ * Wording tracks whether we actually widened the sandbox for write access.
+ */
+export function grokAddDirRules(dirs, opts = {}) {
+    const list = dirs.map((d) => `- ${d}`).join('\n');
+    const access = opts.writeGranted === false
+        ? 'intended as first-class workspace roots (OS sandbox may still restrict writes unless GROK_SANDBOX is set so agents-cli can widen it)'
+        : 'read + write';
+    return [
+        `Project sibling directories (part of this multi-repo project; ${access}):`,
+        list,
+        'Treat these as first-class workspace roots alongside the primary cwd.',
+    ].join('\n');
+}
+/**
+ * Apply directory grants on the argv for harnesses handled here.
+ * Codex is intentionally excluded — its path lives next to codexPolicyArgs.
+ *
+ * @returns true when any argv / on-disk change was made for the grants
+ */
+export function applyAddDirs(agent, cmd, dirs, opts = {}) {
+    const normalized = normalizeAddDirs(dirs);
+    if (normalized.length === 0)
+        return false;
+    const strategy = ADD_DIR_STRATEGY[agent];
+    if (strategy === 'native-flag') {
+        appendNativeAddDirFlags(cmd, normalized);
+        return true;
+    }
+    if (strategy === 'grok-sandbox') {
+        const env = opts.env ?? process.env;
+        const activeBase = grokActiveSandboxProfile(env);
+        let writeGranted = true; // default off sandbox = unrestricted FS
+        if (activeBase) {
+            const cwd = opts.cwd ?? process.cwd();
+            const profile = ensureGrokProjectSandboxProfile(cwd, normalized, {
+                extendsBase: activeBase,
+            });
+            if (profile) {
+                // Drop a prior --sandbox <x> pair so the managed profile wins.
+                for (let i = cmd.length - 2; i >= 0; i--) {
+                    if (cmd[i] === '--sandbox') {
+                        cmd.splice(i, 2);
+                    }
+                }
+                cmd.push('--sandbox', profile);
+                writeGranted = true;
+            }
+            else {
+                // Could not write the profile (e.g. hand-owned agents-project block).
+                writeGranted = false;
+            }
+        }
+        // Model awareness always — even when the OS sandbox is off.
+        cmd.push('--rules', grokAddDirRules(normalized, { writeGranted }));
+        return true;
+    }
+    // codex-policy / none — not applied here
+    return false;
+}
+/** Whether this harness effectively consumes directory grants. */
+export function supportsAddDir(agent) {
+    const s = ADD_DIR_STRATEGY[agent];
+    return s === 'native-flag' || s === 'codex-policy' || s === 'grok-sandbox';
+}
+/** One-line note for harnesses that ignore grants (used by callers that want to warn). */
+export function addDirUnsupportedNote(agent) {
+    if (supportsAddDir(agent))
+        return null;
+    return (`${agent} has no multi-root / --add-dir surface; project sibling directory ` +
+        `grants are ignored (cwd only). Claude, Codex, Cursor, Kimi, and Grok consume them.`);
+}

package/dist/lib/agent-cli-commands.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Agent CLI binary names — the `cliCommand` field of each harness in AGENTS.
+ *
+ * Leaf module with zero imports. brand.ts uses this for reservedBrandNames so
+ * the eager index.ts → brand.js graph never pulls agents.ts / versions.ts on
+ * every invocation (RUSH-2331). agents.ts AGENTS[*].cliCommand values are
+ * pinned equal by agent-cli-commands.test.ts — when a harness is added or
+ * renamed, both this list and AGENTS must change together.
+ */
+/** Every managed harness CLI binary name (no `agents` / `ag`). */
+export declare const AGENT_CLI_COMMANDS: readonly string[];

package/dist/lib/agent-cli-commands.js

@@ -0,0 +1,30 @@
+/**
+ * Agent CLI binary names — the `cliCommand` field of each harness in AGENTS.
+ *
+ * Leaf module with zero imports. brand.ts uses this for reservedBrandNames so
+ * the eager index.ts → brand.js graph never pulls agents.ts / versions.ts on
+ * every invocation (RUSH-2331). agents.ts AGENTS[*].cliCommand values are
+ * pinned equal by agent-cli-commands.test.ts — when a harness is added or
+ * renamed, both this list and AGENTS must change together.
+ */
+/** Every managed harness CLI binary name (no `agents` / `ag`). */
+export const AGENT_CLI_COMMANDS = [
+    'claude',
+    'codex',
+    'gemini',
+    'cursor-agent',
+    'opencode',
+    'omp',
+    'openclaw',
+    'copilot',
+    'amp',
+    'kiro-cli',
+    'goose',
+    'agy',
+    'grok',
+    'kimi',
+    'droid',
+    'hermes',
+    'muse',
+    'warp',
+];

package/dist/lib/agents.js

@@ -654,7 +654,12 @@ export const AGENTS = {
             skills: true,
             commands: false,
             plugins: true,
-            subagents: true, // YAML agent files under ~/.kimi-code/agents/ (see transformSubagentForKimi)
+            // Claude-shaped agent markdown under ~/.kimi-code/agents/. kimi-code
+            // discovers that dir from `USER_BRAND_DIRS = ["agents"]` (agent-file
+            // discovery, added in 0.29.0); 0.28.x and older compile their four agent
+            // profiles into the bundle with no filesystem loader at all, so a synced
+            // file there is never read.
+            subagents: { since: '0.29.0' },
             rules: { file: 'AGENTS.md' },
             workflows: true,
             memory: false,
@@ -859,27 +864,32 @@ export const AGENTS = {
             interactiveRepl: true,
         },
     },
-    // Warp Agent CLI (`oz`) — the standalone coding-agent CLI on Warp's "Oz"
-    // platform (the same shared Warp binary invoked via the `oz` symlink). Native
-    // binary via `brew install --cask oz` (macOS) / `oz-stable` apt|yum|pacman
-    // package (Linux); self-updating, no npm package. Config lives under `~/.warp/`
-    // (`.mcp.json`, `skills/`, `tab_configs/`, `worktrees/`, `remote-server`).
-    // Headless: `oz agent run --prompt "<task>" [--model <id>]` (local) /
-    // `oz agent run-cloud` (cloud). Auth: `oz login` (browser OAuth) or a
-    // `WARP_API_KEY` env token for headless/CI (`oz api-key create`). Rules/context
-    // file is `AGENTS.md` (also reads WARP.md / CLAUDE.md). Autonomy is governed by
-    // the selected agent profile (`--profile`), not a per-run permission flag.
-    // Sessions/conversations are stored SERVER-SIDE (retrieved with auth via
-    // `oz run conversation get <id>`), so there is no local transcript for
-    // `agents sessions` to index — warp is intentionally absent from SESSION_AGENTS.
-    // Docs: https://docs.warp.dev/reference/cli
+    // Warp Agent CLI (`warp`) — Warp's standalone interactive TUI coding agent
+    // (docs.warp.dev/cli). Installed by the official cross-platform installer
+    // `curl -fsSL https://app.warp.dev/download/agent-cli | bash` (Windows: the
+    // sibling agent-cli.ps1), which drops a self-updating `warp` binary at
+    // ~/.local/bin/warp — NOT the older `oz` platform runner (brew cask `oz` /
+    // apt `oz-stable`), a separate headless product that no longer matches this
+    // CLI. Config lives under `~/.warp/` (`.mcp.json`, `skills/`, `tui/`). It is
+    // interactive-only: bare `warp` opens the TUI (streamed responses, diffs,
+    // inline approvals). There is NO headless one-shot form — the documented
+    // flags are --api-key / --auto-approve / --resume <token> /
+    // --set-provider-api-key / --clear-provider-api-key / --version / --help; no
+    // -p/--prompt, no --model (model is the `/model` picker), no JSON output.
+    // Auth: interactive browser sign-in on launch, or the `WARP_API_KEY` env
+    // token / `--api-key` for CI. Rules/context file is `AGENTS.md` (also reads
+    // WARP.md / CLAUDE.md). Conversations sync SERVER-SIDE to the Warp/Oz
+    // platform (resume a prior one with `warp --resume <token>`), so there is no
+    // local transcript for `agents sessions` to index — warp is intentionally
+    // absent from SESSION_AGENTS.
+    // Docs: https://docs.warp.dev/cli/quickstart
     warp: {
         id: 'warp',
         name: 'Warp',
         color: 'blueBright',
-        cliCommand: 'oz',
+        cliCommand: 'warp',
         npmPackage: '',
-        installScript: 'brew install --cask oz',
+        installScript: 'curl -fsSL https://app.warp.dev/download/agent-cli | bash',
         configDir: path.join(HOME, '.warp'),
         commandsDir: '',
         commandsSubdir: '',
@@ -888,44 +898,42 @@ export const AGENTS = {
         instructionsFile: 'AGENTS.md',
         format: 'markdown',
         variableSyntax: '$ARGUMENTS',
-        // Oz has no event->shell-command hook registration surface (its documented
-        // capabilities are agent-profiles-permissions, codebase-context,
-        // full-terminal-use, mcp, planning, rules, slash-commands — no hooks).
+        // Warp has no event->shell-command hook registration surface (its startup
+        // flags are --api-key/--auto-approve/--resume/--set-provider-api-key/
+        // --clear-provider-api-key — no hooks).
         supportsHooks: false,
         capabilities: {
             hooks: false,
-            // MCP: Oz reads the Claude `{ "mcpServers": {...} }` schema from
-            // `.warp/.mcp.json` (user `~/.warp/.mcp.json`, project `<root>/.warp/.mcp.json`)
-            // and accepts `--mcp <path|json>` at run time; `oz mcp list` reads them
-            // back. stdio + http with headers, same schema as Claude's .mcp.json.
+            // MCP: Warp reads the Claude `{ "mcpServers": {...} }` schema from
+            // `.warp/.mcp.json` (user `~/.warp/.mcp.json`, project `<root>/.warp/.mcp.json`),
+            // stdio + http with headers, same schema as Claude's .mcp.json.
             mcp: true,
             mcpHttp: true,
             mcpHeaders: true,
-            // Autonomy is governed by the selected agent profile
-            // (agent-profiles-permissions), not a Claude-style tool-name allow/deny
-            // list agents-cli can write — so no allowlist writer (mirrors muse).
+            // Autonomy is a single toggle (`--auto-approve`), not a Claude-style
+            // tool-name allow/deny list agents-cli can write — so no allowlist writer
+            // (mirrors muse).
             allowlist: false,
-            // Skills: `--skill <spec>` + `oz agent skills`; searched in
-            // `.agents/skills/`, `.warp/skills/`, `.claude/skills/`, `.codex/skills/`.
+            // Skills searched in `.agents/skills/`, `.warp/skills/`, `.claude/skills/`,
+            // `.codex/skills/`.
             skills: true,
             // Slash-commands are native/server-managed (no droppable markdown
             // command-file directory for agents-cli to sync into).
             commands: false,
             // No Claude marketplace / plugin manifest support.
             plugins: false,
-            // Cloud agents + agent profiles are server-side; no installable
-            // subagent-definition directory to sync into (keeps the table truthful).
+            // Cloud agents are server-side; no installable subagent-definition
+            // directory to sync into (keeps the table truthful).
             subagents: false,
             rules: { file: 'AGENTS.md' },
             workflows: false,
             memory: false,
-            // Oz has no per-run permission flag; a single autonomous mode maps to no
-            // flags (the `--profile` selection governs autonomy). Mirrors hermes.
+            // No per-run permission flag beyond `--auto-approve`; the single `edit`
+            // mode maps to no flags (mirrors hermes).
             modes: ['edit'],
             rulesImports: false,
-            // `oz agent run` requires a prompt (--prompt/--saved-prompt/--task-id/
-            // --skill), so a bare invocation opens no REPL.
-            interactiveRepl: false,
+            // Bare `warp` opens the interactive TUI (its only run form).
+            interactiveRepl: true,
         },
     },
 };

package/dist/lib/answer-router.js

@@ -123,7 +123,7 @@ export function resolveAnswerRoute(input) {
         return {
             kind: 'refuse',
             reason: 'Agent is parked on a question but has no addressable terminal (no tmux/iterm/pty rail). ' +
-                'Open its terminal and answer there, or run `agents sessions focus <id>` first.',
+                'Open its terminal and answer there, or run `agents sessions resume <id>` first.',
         };
     }
     // Open block but agent is still looping between tool calls — mailbox is correct.

package/dist/lib/audit/log.d.ts

@@ -1,29 +1,12 @@
 /**
- * Cross-agent, tamper-evident audit log of every dispatched run (issue #347).
+ * Run-dispatch recording (issue #347) — now a thin write into the unified
+ * event stream (`emit('run.dispatched', …)`). The historical hash-chained file
+ * at `~/.agents/.history/audit/log.jsonl` is still readable via
+ * `readAuditLog` / `verifyAuditChain` for pre-unification history; new runs do
+ * NOT append there. Operators list run outcomes with:
  *
- * Every run that reaches the single dispatch chokepoint in `agents run`
- * (src/commands/exec.ts) appends ONE record here. Records form a hash chain:
- * each record embeds the previous record's `hash` as `prevHash`, and its own
- * `hash` is `sha256(canonicalJSON(record-without-hash))`. Because `prevHash`
- * is part of the hashed payload, rewriting or reordering any record breaks the
- * chain from that point forward — `verifyAuditChain()` reports the first index
- * that fails to reproduce.
- *
- * Storage is append-only JSONL under the durable-runtime bucket
- * (`~/.agents/.history/audit/log.jsonl`), one record per line. `.history/` is
- * machine-local, gitignored, and NEVER synced by `agents repo push/pull` — so
- * the `repo` field (a git remote url that can embed an access token) never
- * lands in a version-controlled DotAgents repo, and a cross-machine pull can't
- * splice a foreign chain into this one. The write path is deliberately cheap
- * and non-fatal: a logging failure must never crash a run (see
- * `recordDispatchedRun`). Concurrent writers (parallel teams/routines dispatch)
- * are serialized by an advisory lock file so the chain never forks — see
- * `appendAuditRecord`.
- *
- * Governance context: this is the evidence trail an operator needs to answer
- * "which agent, at which version, ran against which repo, and did it succeed?"
- * — the kind of automated-decision logging the EU AI Act (Art. 12) expects of
- * high-risk systems, kept tamper-evident so the log itself can be trusted.
+ *   agents events --include runs
+ *   agents audit                 # alias of the above
  */
 /** First record's `prevHash` — a fixed anchor so the chain has a root. */
 export declare const GENESIS_HASH = "GENESIS";
@@ -79,9 +62,9 @@ export declare function verifyAuditChain(logPath?: string): {
 /** Read the whole chain, oldest-first. Exposed for `agents audit list`. */
 export declare function readAuditLog(logPath?: string): AuditRecord[];
 /**
- * Record ONE dispatched run at the single exec chokepoint. Non-fatal by
- * contract: any failure is caught and warned, never thrown — an audit-log
- * hiccup must not crash a run that already finished.
+ * Record ONE dispatched run at the single exec chokepoint into the unified
+ * event stream. Non-fatal by contract: any failure is caught and warned, never
+ * thrown — a log hiccup must not crash a run that already finished.
  */
 export declare function recordDispatchedRun(run: {
     agent: string;