@agent-deck/cli 2.0.0 → 2.1.0

package/dist/run.js

@@ -0,0 +1,680 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RUN_FAKE_ENV = exports.RUN_CLAUDE_NOT_SIGNED_IN_ERROR = exports.RUN_CLAUDE_NOT_INSTALLED_ERROR = exports.CLAUDE_AUTH_LOGIN_COMMAND = exports.RUN_TOOL_PROFILES = exports.RUN_SETTING_SOURCES = exports.RUN_READONLY_TOOLS = exports.RUN_PERMISSION_MODE = exports.RUN_EDIT_TOOLS = exports.allowedToolsForProfile = void 0;
+exports.parseRunArgs = parseRunArgs;
+exports.findExecutableOnPath = findExecutableOnPath;
+exports.claudeAuthStatusShowsLogin = claudeAuthStatusShowsLogin;
+exports.defaultClaudeClientProbe = defaultClaudeClientProbe;
+exports.loadRunFakeBehavior = loadRunFakeBehavior;
+exports.newRunId = newRunId;
+exports.writeRunMeta = writeRunMeta;
+exports.findReceiptDeckMismatch = findReceiptDeckMismatch;
+exports.validateRunPrereqs = validateRunPrereqs;
+exports.printRunHelp = printRunHelp;
+exports.runRun = runRun;
+exports.runRunCommand = runRunCommand;
+/**
+ * `agent-deck run` — start a local agent session bound to a deck (NOT-400, NOT-404).
+ *
+ * Productizes the throwaway botmancers runner: one command takes a deck, a
+ * working directory, and a brief, streams the session to a JSONL log, and
+ * records a small meta.json that later tickets (detach, status) can read.
+ * Resume continues the same client session id under a new run log.
+ *
+ * Client-specific launching lives behind the {@link ClientAdapter} interface
+ * (`run-adapter.ts`); this file owns arg parsing, the deck binding gate,
+ * tool profiles, the JSONL log, and meta.json. New adapters plug in without
+ * touching this file's run/log/status paths.
+ *
+ * `--detach` (NOT-401) re-executes this same command as a background child;
+ * status/log/list (NOT-402) poll the run record the child writes.
+ */
+const node_child_process_1 = require("node:child_process");
+const node_crypto_1 = require("node:crypto");
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const backend_runtime_1 = require("./backend-runtime");
+const paths_1 = require("./managed/paths");
+const mcp_launcher_1 = require("./mcp-launcher");
+const run_adapter_1 = require("./run-adapter");
+const run_claude_1 = require("./run-claude");
+const run_codex_1 = require("./run-codex");
+const run_cursor_1 = require("./run-cursor");
+const run_muse_1 = require("./run-muse");
+// Tool profiles stay owned by the shared run code (re-exported so existing
+// `from './run'` imports keep working).
+var run_adapter_2 = require("./run-adapter");
+Object.defineProperty(exports, "allowedToolsForProfile", { enumerable: true, get: function () { return run_adapter_2.allowedToolsForProfile; } });
+Object.defineProperty(exports, "RUN_EDIT_TOOLS", { enumerable: true, get: function () { return run_adapter_2.RUN_EDIT_TOOLS; } });
+Object.defineProperty(exports, "RUN_PERMISSION_MODE", { enumerable: true, get: function () { return run_adapter_2.RUN_PERMISSION_MODE; } });
+Object.defineProperty(exports, "RUN_READONLY_TOOLS", { enumerable: true, get: function () { return run_adapter_2.RUN_READONLY_TOOLS; } });
+Object.defineProperty(exports, "RUN_SETTING_SOURCES", { enumerable: true, get: function () { return run_adapter_2.RUN_SETTING_SOURCES; } });
+Object.defineProperty(exports, "RUN_TOOL_PROFILES", { enumerable: true, get: function () { return run_adapter_2.RUN_TOOL_PROFILES; } });
+function parseRunArgs(args) {
+    let deckRef;
+    let client;
+    let cwd;
+    let prompt;
+    let promptFile;
+    let tools = 'readonly';
+    let log;
+    let resume;
+    let detach = false;
+    let runIdOverride;
+    for (let i = 0; i < args.length; i += 1) {
+        const arg = args[i];
+        if (arg === '--client') {
+            client = args[++i];
+        }
+        else if (arg === '--cwd') {
+            cwd = args[++i];
+        }
+        else if (arg === '--prompt') {
+            prompt = args[++i];
+        }
+        else if (arg === '--prompt-file') {
+            promptFile = args[++i];
+        }
+        else if (arg === '--tools') {
+            tools = args[++i] ?? '';
+        }
+        else if (arg === '--log') {
+            log = args[++i];
+        }
+        else if (arg === '--resume') {
+            resume = args[++i];
+        }
+        else if (arg === '--detach') {
+            detach = true;
+        }
+        else if (arg === '--_run-id') {
+            runIdOverride = args[++i];
+        }
+        else if (arg === '--help' || arg === '-h') {
+            return { error: 'help' };
+        }
+        else if (arg.startsWith('-')) {
+            return { error: `Unknown run option: ${arg}` };
+        }
+        else if (!deckRef) {
+            deckRef = arg;
+        }
+        else {
+            return { error: `Unexpected argument: ${arg}` };
+        }
+    }
+    if (!deckRef) {
+        return { error: 'deck name or id is required' };
+    }
+    if (!client) {
+        return { error: (0, run_adapter_1.missingRunClientMessage)() };
+    }
+    if (client !== 'claude' && client !== 'codex' && client !== 'cursor' && client !== 'muse') {
+        return { error: (0, run_adapter_1.runClientMessage)(client) };
+    }
+    if (!cwd) {
+        return { error: '--cwd is required' };
+    }
+    if (prompt !== undefined && promptFile !== undefined) {
+        return { error: 'Pass exactly one of --prompt or --prompt-file' };
+    }
+    if (prompt === undefined && promptFile === undefined) {
+        return { error: 'A brief is required: pass --prompt <text> or --prompt-file <path>' };
+    }
+    if (tools !== 'readonly' && tools !== 'edit') {
+        return { error: `--tools must be one of: readonly, edit (got "${tools}")` };
+    }
+    return {
+        deckRef,
+        client,
+        cwd: node_path_1.default.resolve(cwd),
+        ...(prompt !== undefined ? { prompt } : {}),
+        ...(promptFile !== undefined ? { promptFile } : {}),
+        tools,
+        ...(log ? { log: node_path_1.default.resolve(log) } : {}),
+        ...(resume ? { resume } : {}),
+        detach,
+        ...(runIdOverride ? { runIdOverride } : {}),
+    };
+}
+/** The one fix command both preflight remedies name. Verified against `claude auth --help`. */
+exports.CLAUDE_AUTH_LOGIN_COMMAND = 'claude auth login';
+exports.RUN_CLAUDE_NOT_INSTALLED_ERROR = `Claude Code is not installed (no \`claude\` on PATH). Install Claude Code, then run \`${exports.CLAUDE_AUTH_LOGIN_COMMAND}\` to sign in, then retry.`;
+exports.RUN_CLAUDE_NOT_SIGNED_IN_ERROR = `Claude Code is not signed in. Run \`${exports.CLAUDE_AUTH_LOGIN_COMMAND}\` to sign in with your own account, then retry.`;
+/** First executable `name` on `pathEnv`, or null. Pure apart from the fs check. */
+function findExecutableOnPath(name, pathEnv = process.env.PATH ?? '') {
+    for (const dir of pathEnv.split(node_path_1.default.delimiter)) {
+        if (!dir) {
+            continue;
+        }
+        const candidate = node_path_1.default.join(dir, name);
+        try {
+            node_fs_1.default.accessSync(candidate, node_fs_1.default.constants.X_OK);
+            return candidate;
+        }
+        catch {
+            // Not here; keep scanning.
+        }
+    }
+    return null;
+}
+/**
+ * True only when `claude auth status` JSON reports a login. Never throws:
+ * garbage, an empty string, or a logged-out report all read as signed out.
+ */
+function claudeAuthStatusShowsLogin(stdout) {
+    try {
+        return JSON.parse(stdout).loggedIn === true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Default Claude Code preflight: the `claude` CLI must be on PATH and
+ * `claude auth status` must report a login. Local only — no model call.
+ * An explicit ANTHROPIC_API_KEY passes without the OAuth check once the
+ * `claude` CLI is found on PATH (API-key onboarding stays out of scope;
+ * the friend path signs in via `claude auth login`). Any other failure —
+ * logged out, unparseable output, a hung or crashed `claude` — reads as
+ * not signed in; re-running the login is the remedy in every case.
+ */
+async function defaultClaudeClientProbe() {
+    const claudePath = findExecutableOnPath('claude');
+    if (!claudePath) {
+        return { ok: false, reason: 'not-installed' };
+    }
+    if ((process.env.ANTHROPIC_API_KEY ?? '').trim()) {
+        return { ok: true };
+    }
+    try {
+        const out = (0, node_child_process_1.execFileSync)(claudePath, ['auth', 'status'], {
+            encoding: 'utf8',
+            timeout: 15_000,
+            stdio: ['ignore', 'pipe', 'ignore'],
+        });
+        return claudeAuthStatusShowsLogin(out)
+            ? { ok: true }
+            : { ok: false, reason: 'not-signed-in' };
+    }
+    catch (error) {
+        // The binary vanished between the PATH scan and the exec.
+        if (error?.code === 'ENOENT') {
+            return { ok: false, reason: 'not-installed' };
+        }
+        return { ok: false, reason: 'not-signed-in' };
+    }
+}
+/**
+ * Test-only fake runner for the `run --detach` integration suite. The detached
+ * child is a real process, so dependency injection cannot reach it; instead the
+ * suite points AGENT_DECK_RUN_FAKE at a JSON behavior file and both the starter
+ * (deck lookup) and the child (deck lookup + model stream) honor it. Explicit
+ * `deps` always win, so unit tests are unaffected. Never set in production.
+ */
+exports.RUN_FAKE_ENV = 'AGENT_DECK_RUN_FAKE';
+function loadRunFakeBehavior() {
+    const file = process.env[exports.RUN_FAKE_ENV]?.trim();
+    if (!file) {
+        return null;
+    }
+    try {
+        return JSON.parse(node_fs_1.default.readFileSync(file, 'utf8'));
+    }
+    catch {
+        throw new Error(`Cannot read ${exports.RUN_FAKE_ENV} behavior file: ${file}`);
+    }
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function fakeQueryFromBehavior(behavior) {
+    const sessionId = behavior.sessionId ?? 'ses_fake';
+    return async function* ({ prompt, options }) {
+        if (behavior.recordOptionsPath) {
+            node_fs_1.default.mkdirSync(node_path_1.default.dirname(behavior.recordOptionsPath), { recursive: true });
+            node_fs_1.default.writeFileSync(behavior.recordOptionsPath, `${JSON.stringify({ prompt, options }, null, 2)}\n`, 'utf8');
+        }
+        if (behavior.mode === 'crash') {
+            // A crash leaves no log line behind: sync write, then out with no yield.
+            node_fs_1.default.writeSync(2, `${behavior.crashStderr ?? 'fake runner crashed'}\n`);
+            process.exit(behavior.exitCode ?? 1);
+        }
+        if (behavior.lineDelayMs) {
+            await sleep(behavior.lineDelayMs);
+        }
+        if (behavior.mode === 'fail') {
+            throw new Error(behavior.error ?? 'fake runner failed');
+        }
+        yield {
+            type: 'assistant',
+            session_id: sessionId,
+            message: { content: [{ type: 'text', text: behavior.text ?? 'fake runner here' }] },
+        };
+        if (behavior.endDelayMs) {
+            await sleep(behavior.endDelayMs);
+        }
+        yield { type: 'result', subtype: 'success', session_id: sessionId, result: 'fake ok' };
+    };
+}
+function fakeResolveDeckFromBehavior(behavior) {
+    return async (ref) => ({
+        id: behavior.deckId ?? 'deck-fake',
+        name: behavior.deckName ?? ref,
+    });
+}
+function defaultResolveDeck(ref) {
+    return (0, backend_runtime_1.createCollectionAdmin)().resolveDeck(ref);
+}
+function selectResolveDeck(deps) {
+    if (deps.resolveDeck) {
+        return deps.resolveDeck;
+    }
+    const fake = loadRunFakeBehavior();
+    return fake ? fakeResolveDeckFromBehavior(fake) : defaultResolveDeck;
+}
+function selectClaudeProbe(deps) {
+    if (deps.claudeProbe) {
+        return deps.claudeProbe;
+    }
+    // The fake runner brings its own working client, like it brings its own
+    // deck and model stream; the real probe only guards the real transport.
+    if (loadRunFakeBehavior()) {
+        return async () => ({ ok: true });
+    }
+    return defaultClaudeClientProbe;
+}
+/**
+ * `query()` for the Claude adapter: explicit deps win, then the NOT-401
+ * detach-integration fake (the detached child is a real process, so the
+ * AGENT_DECK_RUN_FAKE behavior file is its only seam), then undefined so the
+ * adapter lazily requires the real Claude Agent SDK.
+ */
+function selectClaudeQuery(deps) {
+    if (deps.query) {
+        return deps.query;
+    }
+    if (deps.claude?.query) {
+        return deps.claude.query;
+    }
+    const fake = loadRunFakeBehavior();
+    return fake ? fakeQueryFromBehavior(fake) : undefined;
+}
+function resolveAdapter(client, deps) {
+    if (client === 'codex') {
+        return (0, run_codex_1.createCodexAdapter)(deps.codex ?? {});
+    }
+    if (client === 'cursor') {
+        return (0, run_cursor_1.createCursorAdapter)(deps.cursor ?? {});
+    }
+    if (client === 'muse') {
+        return (0, run_muse_1.createMuseAdapter)(deps.muse ?? {});
+    }
+    const query = selectClaudeQuery(deps);
+    return (0, run_claude_1.createClaudeAdapter)({
+        ...deps.claude,
+        ...(query ? { query } : {}),
+    });
+}
+function newRunId() {
+    const stamp = new Date().toISOString().replace(/[-:]/g, '').replace(/\..+/, '');
+    return `run-${stamp}-${(0, node_crypto_1.randomBytes)(3).toString('hex')}`;
+}
+/**
+ * Atomic run-record write: readers (`run status`, detach tests, orchestrators)
+ * poll meta.json while the run child rewrites it, and a plain writeFileSync
+ * truncates before writing — a concurrent read lands on empty/partial bytes
+ * and JSON.parse throws. Writing to a sibling temp file and renaming keeps
+ * every observed state a complete document (rename is atomic on POSIX and
+ * Windows). The pid suffix keeps the starter's and the child's temp files
+ * distinct when both target the same meta.json.
+ */
+function writeRunMeta(metaPath, meta) {
+    const tmpPath = `${metaPath}.tmp-${process.pid}`;
+    node_fs_1.default.writeFileSync(tmpPath, `${JSON.stringify(meta, null, 2)}\n`, 'utf8');
+    node_fs_1.default.renameSync(tmpPath, metaPath);
+}
+function writeMeta(metaPath, meta) {
+    writeRunMeta(metaPath, meta);
+}
+/**
+ * Session receipt check: the agent harness prints the bound deck as one
+ * `get_session_context` receipt line rendering `display_summary`
+ * (e.g. `◆ dev · 2 MCP · 0 keys · 1 playbooks`). Returns the mismatching deck
+ * token when the log positively shows a deck other than the requested one;
+ * a missing receipt is not a mismatch (the pre-start assignment gate is the
+ * fail-closed check; this is a second net for a mis-bound session).
+ * The fragments are joined before scanning: real clients stream token-level
+ * deltas, so one receipt line can arrive split across many text events and a
+ * per-fragment scan would miss the mismatch.
+ */
+function findReceiptDeckMismatch(texts, deck) {
+    const joined = texts.join('');
+    const pattern = /◆\s*([^·\r\n]+?)\s*·/g;
+    for (const match of joined.matchAll(pattern)) {
+        const token = match[1].trim();
+        if (token && token !== deck.name && token !== deck.id) {
+            return token;
+        }
+    }
+    return null;
+}
+/**
+ * Everything a run must prove before it may start streaming: a readable brief,
+ * an existing cwd, a known deck, and a folder assignment already bound to that
+ * deck. Shared by the foreground run and the `--detach` starter so both fail
+ * closed on the same inputs with the same messages.
+ */
+async function validateRunPrereqs(options, deps = {}) {
+    const resolveDeck = selectResolveDeck(deps);
+    const resolveLaunchPlan = deps.resolveLaunchPlan ?? mcp_launcher_1.resolveMcpLaunchPlan;
+    let promptText;
+    if (options.promptFile !== undefined) {
+        try {
+            promptText = node_fs_1.default.readFileSync(options.promptFile, 'utf8');
+        }
+        catch {
+            return { error: `Cannot read prompt file: ${options.promptFile}` };
+        }
+    }
+    else {
+        promptText = options.prompt ?? '';
+    }
+    if (!promptText.trim()) {
+        return { error: 'Prompt is empty: pass a non-empty --prompt or --prompt-file' };
+    }
+    let cwdStat;
+    try {
+        cwdStat = node_fs_1.default.statSync(options.cwd);
+    }
+    catch {
+        return { error: `--cwd does not exist: ${options.cwd}` };
+    }
+    if (!cwdStat.isDirectory()) {
+        return { error: `--cwd is not a directory: ${options.cwd}` };
+    }
+    const deck = await resolveDeck(options.deckRef);
+    if (!deck) {
+        return { error: `Deck not found: ${options.deckRef}` };
+    }
+    // Fail closed before any model call: the session's MCP launch must already
+    // resolve to the requested deck. Never rewrite the folder assignment here.
+    const plan = await resolveLaunchPlan(options.cwd);
+    if (plan.deckId !== deck.id) {
+        if (!plan.deckId) {
+            return {
+                error: `No deck assigned in ${options.cwd}: run \`agent-deck use ${options.deckRef}\` there first, then retry. Refusing to start an unbound session.`,
+            };
+        }
+        return {
+            error: `Folder ${options.cwd} is bound to "${plan.deckName ?? plan.deckId}" (${plan.deckId}), not "${options.deckRef}". ` +
+                `Run \`agent-deck use ${options.deckRef}\` in that folder to rebind it, then retry. Refusing to start a mis-bound session.`,
+        };
+    }
+    // Last and slowest (it shells out to `claude auth status`): for claude runs,
+    // the Claude Code client must be installed and signed in before any model
+    // call (NOT-405). Other clients (codex) skip this probe; their adapters own
+    // their preflight. Shared by the foreground run and the `--detach` starter,
+    // so both fail closed with the same one-line remedy instead of an SDK
+    // stack trace.
+    if (options.client === 'claude') {
+        const client = await selectClaudeProbe(deps)();
+        if (!client.ok) {
+            return {
+                error: client.reason === 'not-installed'
+                    ? exports.RUN_CLAUDE_NOT_INSTALLED_ERROR
+                    : exports.RUN_CLAUDE_NOT_SIGNED_IN_ERROR,
+            };
+        }
+    }
+    return { promptText, deck };
+}
+function printRunHelp() {
+    console.log(`Usage:
+  agent-deck run <deck> --client claude|codex|cursor|muse --cwd <dir> (--prompt <text>|--prompt-file <path>) [--tools readonly|edit] [--log <path>] [--resume <sessionId>] [--detach]
+  agent-deck run status <runId> [--json]
+  agent-deck run log <runId> [--tail <n>] [--follow] [--json]
+  agent-deck run list [--json] [--limit <n>]
+
+Starts a local agent session bound to <deck> and streams a JSONL log.
+The folder's assignment must already name <deck> (agent-deck use <deck>);
+run never rewrites .agent-deck/use.json and fails closed on a mismatch.
+Claude runs require the Claude Code CLI on this machine, signed in
+('claude auth login'); otherwise run fails before any model call.
+A set ANTHROPIC_API_KEY skips the sign-in check (the SDK accepts the
+key instead); API-key setup is otherwise out of scope for this path.
+
+  --client claude|codex|cursor|muse
+                         Required.
+                         codex maps --tools to -s read-only|workspace-write;
+                         cursor maps --tools edit to --force (readonly passes
+                         no write flag); all log lines land when the run ends;
+                         muse maps readonly to --disable-write --disable-shell
+                         (edit uses the default bounded permissions).
+  --cwd <dir>            Required. Session working directory.
+  --prompt <text>        Brief text (exactly one of --prompt/--prompt-file).
+  --prompt-file <path>   Brief read from a file.
+  --tools readonly|edit  Tool profile, default readonly. edit adds Edit, Write
+                         and git-scoped Bash (diff/add/commit/checkout -b).
+  --log <path>           Log file. Default: ~/.agent-deck/runs/<runId>/run.jsonl
+                         (meta.json sits next to the log in both cases).
+  --resume <sessionId>   Continue a previous session id. The profile
+                         passed on this invocation applies; nothing is inherited.
+                         codex resume keeps the thread's original sandbox, so
+                         --tools edit cannot be resumed and fails closed.
+  --detach             Start in the background in a new session, so the run
+                         survives this shell disconnecting. Prints runId, pid,
+                         and the log path, then exits. Every other flag is
+                         passed to the run unchanged. Stop it with kill <pid>.
+
+Poll a run without parsing files by hand:
+
+  status <runId>         State (running|ended|error|died), sessionId, log path.
+  log <runId>            One readable line per event; --json prints raw JSONL.
+  list                   Recent runs, newest first (default limit 20).`);
+}
+async function runRun(options, deps = {}) {
+    const homeDir = deps.homeDir ?? (0, paths_1.agentDeckHome)();
+    const prereq = await validateRunPrereqs(options, deps);
+    if ('error' in prereq) {
+        console.error(prereq.error);
+        return 1;
+    }
+    const { promptText, deck } = prereq;
+    const adapter = resolveAdapter(options.client, deps);
+    const preflight = await adapter.preflight();
+    if (!preflight.ok) {
+        console.error(preflight.remedy);
+        return 1;
+    }
+    const startPlan = adapter.planStart({
+        cwd: options.cwd,
+        prompt: promptText,
+        tools: options.tools,
+        ...(options.resume ? { resumeId: options.resume } : {}),
+    });
+    if (!startPlan.ok) {
+        console.error(startPlan.remedy);
+        return 1;
+    }
+    const runId = options.runIdOverride ?? newRunId();
+    const logPath = options.log ?? node_path_1.default.join(homeDir, 'runs', runId, 'run.jsonl');
+    const metaPath = node_path_1.default.join(node_path_1.default.dirname(logPath), 'meta.json');
+    node_fs_1.default.mkdirSync(node_path_1.default.dirname(logPath), { recursive: true });
+    const meta = {
+        runId,
+        deck: deck.id,
+        client: options.client,
+        tools: options.tools,
+        cwd: options.cwd,
+        pid: process.pid,
+        startedAt: new Date().toISOString(),
+        state: 'running',
+        ...(startPlan.trustOverride ? { trustOverride: true } : {}),
+    };
+    writeMeta(metaPath, meta);
+    const appendLine = (line) => {
+        node_fs_1.default.appendFileSync(logPath, `${JSON.stringify(line)}\n`, 'utf8');
+    };
+    let sessionId = options.resume ?? null;
+    let metaSessionWritten = false;
+    const captureSessionId = (value) => {
+        if (typeof value === 'string' && value) {
+            sessionId = value;
+            if (!metaSessionWritten) {
+                metaSessionWritten = true;
+                meta.sessionId = value;
+                writeMeta(metaPath, meta);
+            }
+            else {
+                meta.sessionId = value;
+            }
+        }
+    };
+    let lastResultSubtype;
+    const seenTexts = [];
+    try {
+        const stream = adapter.start({
+            cwd: options.cwd,
+            prompt: promptText,
+            tools: options.tools,
+            ...(options.resume ? { resumeId: options.resume } : {}),
+        });
+        for await (const event of stream) {
+            if (event.sessionId !== undefined) {
+                captureSessionId(event.sessionId);
+            }
+            if (event.kind === 'text') {
+                seenTexts.push(event.text);
+                appendLine({ t: 'text', ts: new Date().toISOString(), text: event.text });
+            }
+            else if (event.kind === 'tool') {
+                appendLine({ t: 'tool', ts: new Date().toISOString(), name: event.name });
+            }
+            else if (event.kind === 'result') {
+                lastResultSubtype = event.subtype;
+                appendLine({
+                    t: 'result',
+                    ts: new Date().toISOString(),
+                    sessionId,
+                    subtype: event.subtype,
+                    result: event.result,
+                });
+            }
+            else {
+                appendLine({
+                    t: 'notice',
+                    ts: new Date().toISOString(),
+                    message: event.message,
+                    sessionId,
+                });
+            }
+        }
+        appendLine({ t: 'end', ts: new Date().toISOString(), sessionId });
+    }
+    catch (error) {
+        appendLine({
+            t: 'error',
+            ts: new Date().toISOString(),
+            message: String(error instanceof Error ? error.message : error).slice(0, 500),
+            sessionId,
+        });
+        meta.state = 'error';
+        if (sessionId) {
+            meta.sessionId = sessionId;
+        }
+        writeMeta(metaPath, meta);
+        console.log(`run ${runId} error: log ${logPath} sessionId ${sessionId ?? 'unknown'}`);
+        return 1;
+    }
+    let success = lastResultSubtype === 'success';
+    if (success) {
+        const mismatch = findReceiptDeckMismatch(seenTexts, deck);
+        if (mismatch) {
+            success = false;
+            console.error(`Session receipt names deck "${mismatch}", not "${deck.name}": marking run error. ` +
+                `Rebind the folder with \`agent-deck use ${options.deckRef}\` and retry.`);
+        }
+    }
+    meta.state = success ? 'ended' : 'error';
+    if (sessionId) {
+        meta.sessionId = sessionId;
+    }
+    writeMeta(metaPath, meta);
+    console.log(`run ${runId} ${meta.state}: log ${logPath} sessionId ${sessionId ?? 'unknown'}`);
+    return success ? 0 : 1;
+}
+async function runRunCommand(args, deps = {}) {
+    // Poll subcommands (NOT-402) share the `run` prefix with launch (NOT-400).
+    const [head, ...tail] = args;
+    if (head === 'status' || head === 'log' || head === 'list') {
+        const inspect = await Promise.resolve().then(() => __importStar(require('./run-status')));
+        if (head === 'status') {
+            return inspect.runRunStatusCommand(tail, { homeDir: deps.homeDir });
+        }
+        if (head === 'log') {
+            return inspect.runRunLogCommand(tail, {
+                homeDir: deps.homeDir,
+                ...(deps.followPollMs !== undefined ? { followPollMs: deps.followPollMs } : {}),
+            });
+        }
+        return inspect.runRunListCommand(tail, { homeDir: deps.homeDir });
+    }
+    const parsed = parseRunArgs(args);
+    if ('error' in parsed) {
+        if (parsed.error === 'help') {
+            printRunHelp();
+            return 0;
+        }
+        console.error(parsed.error);
+        return 1;
+    }
+    try {
+        if (parsed.detach) {
+            const { startDetachedRun } = await Promise.resolve().then(() => __importStar(require('./run-detach')));
+            return await startDetachedRun(args, parsed, deps);
+        }
+        return await runRun(parsed, deps);
+    }
+    catch (error) {
+        console.error(error instanceof Error ? error.message : error);
+        return 1;
+    }
+}
+//# sourceMappingURL=run.js.map