@claudexor/cli 1.0.1 → 2.1.3

package/dist/cli.js

@@ -1,45 +1,42 @@
 #!/usr/bin/env node
 import process from "node:process";
-import { existsSync, lstatSync, readdirSync } from "node:fs";
-import { basename, dirname, extname, join, relative, resolve, sep } from "node:path";
-import { Orchestrator } from "@claudexor/orchestrator";
+import { createReadStream, existsSync, lstatSync, readFileSync, readdirSync } from "node:fs";
+import { createHash } from "node:crypto";
+import { Readable, Transform } from "node:stream";
+import { dirname, join, relative, resolve, sep } from "node:path";
 import { ArtifactStore } from "@claudexor/artifact-store";
-import { DELIVER_MODES, checkPatch, deliver, validateApplyGate, } from "@claudexor/delivery";
-import { CLAUDEXOR_VERSION, containsSecretLikeToken, ensureDir, newId, noProjectRepoRoot, readTextSafe, userConfigDir, writeJson, } from "@claudexor/util";
+import { CLAUDEXOR_VERSION, containsSecretLikeToken, noProjectRepoRoot, readTextSafe, userConfigDir, } from "@claudexor/util";
 import { checkName } from "./release.js";
-import { defaultClaudexorTools, serveClaudexorMcp } from "@claudexor/mcp-server";
-import { AcpServer } from "@claudexor/acp-server";
-import { initProjectConfig, loadConfig } from "@claudexor/config";
-import { atRiskNodeAdvisory, validateModel } from "@claudexor/core";
-import { DecisionRecord, EffortHint, ExternalContextPolicy, ModeKind as ModeKindSchema, Portfolio, RunTelemetry, TaskContract, WorkProduct, } from "@claudexor/schema";
+import { serveAcpBridge, serveMcpBridge } from "./bridge-serve.js";
+import { initProjectConfig } from "@claudexor/config";
+import { DecisionRecord, ControlSpecSession, EffortHint, ExternalContextPolicy, ModeKind as ModeKindSchema, RoutingGoal, ControlThreadListResponse, RunTelemetry, StructuredOutputConformance, TaskContract, } from "@claudexor/schema";
 import { flagBool, flagStr, flagStringList, flagValues, parseArgs, requiredStringFlagError, } from "./args.js";
-import { authSourceAvailability, checksSummary, print, printJson, printUsageError, statusGlyph } from "./cli-io.js";
-import { KNOWN_FLAGS, VALUE_FLAGS, commandFlagScopeError, helpJson, renderHelp } from "./command-registry.js";
+import { print, printJson, printJsonLine, printUsageError, statusGlyph } from "./cli-io.js";
+import { pickResumableThread } from "./thread-select.js";
+import { KNOWN_FLAGS, VALUE_FLAGS, commandFlagScopeError, helpJson, renderHelp, } from "./command-registry.js";
 import { buildAgentCapabilityCatalog } from "./capabilities.js";
-import { authCommand, daemonCommand, modelsCommand, secretsCommand } from "./ops-commands.js";
+import { dispatchOpsCommand } from "./ops-commands.js";
 import { reviewCommand } from "./review-command.js";
-import { followRun, formatRunEventLine, promptQuestionsOnTty } from "./live.js";
+import { controlApiFetch, followRun } from "./live.js";
+import { retryCommand, runAgainCommand } from "./retry-command.js";
 import { assertCliRunParamsHaveNoInlineSecrets } from "./run-secret-scan.js";
-import { connectDaemonIfRunning, daemonOutcomeSummary, ensureDaemon, enqueueAndAwait, exitCodeForState, fetchApplyEligibility, } from "./daemon-run.js";
+import { openLocalAttachment, resolveLocalAttachment, } from "./local-attachment.js";
+import { connectDaemonIfRunning, daemonOutcomeSummary, ensureDaemon, enqueueAndAwait, exitCodeForState, fetchApplyEligibility, runStatusForCli, } from "./daemon-run.js";
 import { resolveDecisionBody } from "./decision.js";
 import { primaryOutputForCli } from "./primary-output.js";
 import { PLUGIN_TARGETS, PLUGIN_VERBS, formatPluginResult, pluginCommandErrorResult, runPluginCommand, } from "./plugins.js";
-import { buildGateway, buildRegistry, harnessModels } from "./registry.js";
-import { mcpSurfaceRunner, orchestratorRunner } from "./mcp-runner.js";
+import { buildRegistry } from "./registry.js";
 import { settingsCommand } from "./settings-command.js";
+import { quotaCommand } from "./quota-command.js";
 import { trustCommand } from "./trust-command.js";
-import { extractQuestionsFromPlan, freezeSpecFromGrounding, loadFrozenSpec, loadPreviousSpec, persistSpec, readAnswers, resolveRunTestCommands, } from "./spec.js";
+import { projectCommand } from "./project-command.js";
+import { loadFrozenSpec, readAnswers, resolveRunTestCommands } from "./spec.js";
 import { parseAutonomy } from "./orchestrate-options.js";
 import { runRepl } from "./repl.js";
 import { parseProtectedPathApprovalFlags, parseTestCommandFlags, parseReviewerEffortFlags, parseReviewerModelFlags, parseReviewerPanelFlags, } from "./run-options.js";
-// Single version SSOT: the generated CLAUDEXOR_VERSION constant (from the root
-// package.json) so the banner / --version can never ship stale or drift.
 const CLI_VERSION = CLAUDEXOR_VERSION;
-// The help text is a rendered view of the command registry (the ONE owner of
-// the CLI surface — command-registry.ts). Never hand-edit a help literal.
 const HELP = renderHelp(CLI_VERSION);
 const MODES = new Set(["ask", "plan", "audit", "agent", "orchestrate"]);
-/** Canonical mode ids are single words; trim and validate against the schema. */
 function normalizeMode(s) {
     const trimmed = s.trim();
     const parsed = ModeKindSchema.safeParse(trimmed);
@@ -71,7 +68,7 @@ function floatFlag(args, key) {
         throw new Error(`invalid --${key} '${v}' (expected a non-negative number)`);
     return n;
 }
-/** Deterministic gate commands from `--test "<cmd>"`; repeat flag or separate with `;;`. */
+/** Deterministic typed-argv gates from repeated `--test '["program","arg"]'`. */
 function testCommands(args) {
     return parseTestCommandFlags(flagValues(args, "test"));
 }
@@ -79,6 +76,27 @@ function testCommands(args) {
 function protectedPathApprovals(args) {
     return parseProtectedPathApprovalFlags(flagValues(args, "allow-protected-path"));
 }
+/**
+ * Per-run system instructions from `--instructions "<text>"` or
+ * `--instructions-file <path>` (mutually exclusive; the file form avoids
+ * ARG_MAX and keeps long instructions out of the process argv / `ps`).
+ */
+function resolveInstructions(args) {
+    const inline = flagStr(args, "instructions");
+    const file = flagStr(args, "instructions-file");
+    if (inline !== undefined && file !== undefined) {
+        throw new Error("pass either --instructions or --instructions-file, not both");
+    }
+    if (file !== undefined) {
+        try {
+            return readFileSync(file, "utf8");
+        }
+        catch (err) {
+            throw new Error(`could not read --instructions-file ${file}: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    return inline;
+}
 const ACCESS_PROFILES = new Set([
     "readonly",
     "workspace_write",
@@ -134,45 +152,58 @@ function attachmentPaths(args) {
     }
     return values;
 }
-function imageMimeFor(path) {
-    switch (extname(path).toLowerCase()) {
-        case ".png":
-            return "image/png";
-        case ".jpg":
-        case ".jpeg":
-            return "image/jpeg";
-        case ".gif":
-            return "image/gif";
-        case ".webp":
-            return "image/webp";
-        default:
-            return null;
-    }
-}
 function attachmentInputs(args) {
-    const out = attachmentPaths(args).map(({ path, forceImage }) => {
-        const resolved = resolve(path);
-        if (!existsSync(resolved) || !lstatSync(resolved).isFile())
-            throw new Error(`attachment must be an existing file: ${path}`);
-        const imageMime = imageMimeFor(resolved);
-        const kind = forceImage || imageMime ? "image" : "file";
-        return {
-            kind,
-            mime: imageMime ?? "application/octet-stream",
-            name: basename(resolved),
-            path: resolved,
-        };
-    });
+    const out = attachmentPaths(args).map(({ path, forceImage }) => resolveLocalAttachment(path, forceImage));
     return out.length > 0 ? out : undefined;
 }
-function attachmentsFromInputs(inputs) {
-    return inputs?.map((a) => ({
-        id: newId("att"),
-        kind: a.kind,
-        mime: a.mime,
-        name: a.name,
-        path: a.path,
+async function uploadLocalAttachment(addr, attachment) {
+    const created = (await controlJson(addr, "/uploads", {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({
+            kind: attachment.kind,
+            mime: attachment.mime,
+            name: attachment.name,
+            sizeBytes: attachment.sizeBytes,
+        }),
     }));
+    try {
+        const source = createReadStream(attachment.path, {
+            fd: openLocalAttachment(attachment),
+            autoClose: true,
+        });
+        const hash = createHash("sha256");
+        const hashingStream = new Transform({
+            transform(chunk, _encoding, callback) {
+                hash.update(chunk);
+                callback(null, chunk);
+            },
+        });
+        source.pipe(hashingStream);
+        const response = await controlApiFetch(addr, `/uploads/${encodeURIComponent(created.uploadId)}/bytes`, {
+            method: "PUT",
+            headers: { "content-type": "application/octet-stream" },
+            body: Readable.toWeb(hashingStream),
+            duplex: "half",
+        });
+        if (!response.ok) {
+            const detail = (await response.json().catch(() => ({})));
+            throw new Error(String(detail["message"] ?? detail["error"] ?? `HTTP ${response.status}`));
+        }
+        const expectedSha256 = `sha256:${hash.digest("hex")}`;
+        const resource = (await controlJson(addr, `/uploads/${encodeURIComponent(created.uploadId)}/finalize`, {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({ expectedSha256 }),
+        }));
+        return { resourceId: resource.resourceId };
+    }
+    catch (error) {
+        await controlApiFetch(addr, `/uploads/${encodeURIComponent(created.uploadId)}`, {
+            method: "DELETE",
+        }).catch(() => undefined);
+        throw error;
+    }
 }
 /** Per-family reviewer model map from `--reviewer-model "openai=gpt-4o-mini,anthropic=claude-haiku"`. Fails loudly on malformed input. */
 function reviewerModels(args) {
@@ -187,7 +218,28 @@ function reviewerPanel(args) {
     return parseReviewerPanelFlags(flagValues(args, "reviewer-panel"));
 }
 async function orchestrate(args, mode, json, forced = {}) {
-    const rawPrompt = args._.slice(1).join(" ").trim();
+    let rawPrompt = args._.slice(1).join(" ").trim();
+    // Headless prompt sources (W13): `-` reads the prompt from stdin; a file
+    // beats retyping. Exactly ONE source — ambiguity is a usage error, never a
+    // silent pick.
+    const promptFile = flagStr(args, "prompt-file");
+    if (promptFile !== undefined) {
+        if (rawPrompt && rawPrompt !== "-") {
+            return printUsageError(json, "claudexor: pass either an inline prompt or --prompt-file, not both");
+        }
+        try {
+            rawPrompt = readFileSync(promptFile, "utf8").trim();
+        }
+        catch (err) {
+            return printUsageError(json, `claudexor: --prompt-file: cannot read ${promptFile}: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    else if (rawPrompt === "-") {
+        rawPrompt = readFileSync(0, "utf8").trim();
+        if (!rawPrompt) {
+            return printUsageError(json, "claudexor: stdin prompt (`-`) was empty");
+        }
+    }
     const specPath = flagStr(args, "spec");
     let loadedSpec = null;
     try {
@@ -229,9 +281,14 @@ async function orchestrate(args, mode, json, forced = {}) {
         return printUsageError(json, "claudexor: missing prompt");
     }
     const portfolioRaw = flagStr(args, "portfolio");
-    const portfolio = portfolioRaw !== undefined ? Portfolio.safeParse(portfolioRaw) : null;
-    if (portfolioRaw !== undefined && !portfolio?.success) {
-        return printUsageError(json, `claudexor: unknown --portfolio '${portfolioRaw}'`);
+    if (portfolioRaw !== undefined) {
+        return printUsageError(json, "claudexor: --portfolio was removed in v2; use --routing-goal auto|quality|economy");
+    }
+    const credentialProfileId = flagStr(args, "profile");
+    const routingGoalRaw = flagStr(args, "routing-goal");
+    const routingGoal = routingGoalRaw !== undefined ? RoutingGoal.safeParse(routingGoalRaw) : null;
+    if (routingGoalRaw !== undefined && !routingGoal?.success) {
+        return printUsageError(json, `claudexor: unknown --routing-goal '${routingGoalRaw}'`);
     }
     let reviewerEffortOverrides;
     let resolvedReviewerModels;
@@ -239,7 +296,7 @@ async function orchestrate(args, mode, json, forced = {}) {
     let resolvedWebPolicy = undefined;
     let resolvedAccess = undefined;
     let resolvedEffort;
-    let maxUsd;
+    let paidBudget;
     let maxToolCalls;
     let nFlag;
     let attemptsFlag;
@@ -248,9 +305,13 @@ async function orchestrate(args, mode, json, forced = {}) {
     let resolvedHarnesses;
     let resolvedPrimaryHarness;
     let resolvedModel;
-    let attachments;
     let attachmentRequest;
     let resolvedProtectedPathApprovals;
+    let resolvedInstructions;
+    let resolvedMaxSeconds;
+    let resolvedMaxTurns;
+    let resolvedDenyPaths;
+    let resolvedOutputSchema;
     try {
         reviewerEffortOverrides = reviewerEfforts(args);
         resolvedReviewerModels = reviewerModels(args);
@@ -261,15 +322,41 @@ async function orchestrate(args, mode, json, forced = {}) {
         resolvedHarnesses = harnessList(args);
         resolvedPrimaryHarness = flagStr(args, "primary-harness");
         resolvedModel = flagStr(args, "model");
-        maxUsd = floatFlag(args, "max-usd");
+        const maxUsd = floatFlag(args, "max-usd");
+        paidBudget = maxUsd === undefined ? undefined : { kind: "finite", maxUsd };
         maxToolCalls = intFlag(args, "max-tool-calls");
         nFlag = intFlag(args, "n");
         attemptsFlag = intFlag(args, "attempts");
         autonomy = parseAutonomy(flagStr(args, "autonomy"));
         resolvedSynthesis = synthesisMode(args);
         attachmentRequest = attachmentInputs(args);
-        attachments = attachmentsFromInputs(attachmentRequest);
         resolvedProtectedPathApprovals = protectedPathApprovals(args);
+        resolvedInstructions = resolveInstructions(args);
+        resolvedMaxSeconds = intFlag(args, "max-seconds");
+        resolvedMaxTurns = intFlag(args, "max-turns");
+        const denyPathFlags = flagStringList(args, "deny-path");
+        resolvedDenyPaths = denyPathFlags.length > 0 ? denyPathFlags : undefined;
+        const outputSchemaPath = flagStr(args, "output-schema");
+        if (outputSchemaPath !== undefined) {
+            let raw;
+            try {
+                raw = readFileSync(outputSchemaPath, "utf8");
+            }
+            catch (err) {
+                throw new Error(`--output-schema: cannot read ${outputSchemaPath}: ${err instanceof Error ? err.message : String(err)}`);
+            }
+            let parsedSchema;
+            try {
+                parsedSchema = JSON.parse(raw);
+            }
+            catch {
+                throw new Error(`--output-schema: ${outputSchemaPath} is not valid JSON`);
+            }
+            if (!parsedSchema || typeof parsedSchema !== "object" || Array.isArray(parsedSchema)) {
+                throw new Error(`--output-schema: ${outputSchemaPath} must contain a JSON Schema object`);
+            }
+            resolvedOutputSchema = parsedSchema;
+        }
     }
     catch (err) {
         return printUsageError(json, `claudexor: ${err instanceof Error ? err.message : String(err)}`);
@@ -280,6 +367,7 @@ async function orchestrate(args, mode, json, forced = {}) {
         tests = resolveRunTestCommands(cliTests, spec);
         assertCliRunParamsHaveNoInlineSecrets({
             prompt,
+            instructions: resolvedInstructions,
             attachments: attachmentRequest,
             mode,
             harnesses: resolvedHarnesses,
@@ -291,7 +379,7 @@ async function orchestrate(args, mode, json, forced = {}) {
             reviewerEfforts: reviewerEffortOverrides,
             tests,
             protectedPathApprovals: resolvedProtectedPathApprovals,
-            maxUsd,
+            paidBudget,
             access: resolvedAccess,
             web: resolvedWebPolicy,
             externalContextPolicy: resolvedWebPolicy,
@@ -305,137 +393,60 @@ async function orchestrate(args, mode, json, forced = {}) {
     catch (err) {
         return printUsageError(json, `claudexor: ${err instanceof Error ? err.message : String(err)}`);
     }
-    // `--autonomy` only governs the orchestrate executor; on any other
-    // mode it would silently do nothing, so reject it loudly (a misplaced flag is
-    // an error, not a no-op).
     if (autonomy !== undefined && mode !== "orchestrate") {
         return printUsageError(json, `claudexor: --autonomy only applies to 'orchestrate' (got mode '${mode}')`);
     }
-    // The mutating run paths are DAEMON-TRACKED: they enqueue via the daemon
-    // (auto-started if needed) so the control-api can see/unblock them and a
-    // blocked run is unblockable through `claudexor decision`. This covers `agent`
-    // and an `orchestrate` run that actually ACTS (auto_safe/auto_full execute the
-    // plan against the tree). Read-only routes (ask/plan/audit and orchestrate in
-    // the default `suggest` autonomy, where the plan IS the work product) have
-    // nothing to apply or unblock, so they stay in-process.
-    const orchestrateExecutes = mode === "orchestrate" && autonomy !== undefined && autonomy !== "suggest";
-    // --max-tool-calls caps the orchestrate EXECUTOR's plan steps; on any other
-    // mode it would be a silent no-op knob (INV-023) — refuse loudly.
     if (maxToolCalls !== undefined && mode !== "orchestrate") {
         return printUsageError(json, "claudexor: --max-tool-calls only applies to orchestrate runs");
     }
-    if (mode === "agent" || orchestrateExecutes) {
-        return daemonAgentRun(args, json, {
-            mode,
-            autonomy,
-            prompt,
-            tests,
-            portfolio: portfolio?.success ? portfolio.data : undefined,
-            maxUsd,
-            maxToolCalls,
-            reviewerPanel: resolvedReviewerPanel,
-            reviewerModels: resolvedReviewerModels,
-            reviewerEfforts: reviewerEffortOverrides,
-            protectedPathApprovals: resolvedProtectedPathApprovals,
-            resolvedWebPolicy,
-            resolvedAccess,
-            resolvedEffort,
-            resolvedSynthesis,
-            nFlag,
-            attemptsFlag,
-            specId: spec?.id,
-            specHash: loadedSpec?.specHash,
-            specPath: loadedSpec?.specPath,
-            attachmentRequest,
-            forced,
-        });
-    }
-    const orch = new Orchestrator({
-        registry: buildRegistry(),
-        portfolio: portfolio?.success ? portfolio.data : undefined,
-        maxUsd: maxUsd ?? null,
+    return daemonRun(args, json, {
+        mode,
+        autonomy,
+        prompt: prompt || "audit this repository",
+        instructions: resolvedInstructions,
+        maxSeconds: resolvedMaxSeconds,
+        maxTurns: resolvedMaxTurns,
+        denyPaths: resolvedDenyPaths,
+        outputSchema: resolvedOutputSchema,
+        tests,
+        paidBudget,
+        routingGoal: routingGoal?.success ? routingGoal.data : undefined,
+        credentialProfileId,
+        maxToolCalls,
         reviewerPanel: resolvedReviewerPanel,
         reviewerModels: resolvedReviewerModels,
         reviewerEfforts: reviewerEffortOverrides,
+        protectedPathApprovals: resolvedProtectedPathApprovals,
+        resolvedWebPolicy,
+        resolvedAccess,
+        resolvedEffort,
+        resolvedSynthesis,
+        resolvedHarnesses,
+        resolvedPrimaryHarness,
+        resolvedModel,
+        nFlag,
+        attemptsFlag,
+        specId: spec?.id,
+        specHash: loadedSpec?.specHash,
+        specPath: loadedSpec?.specPath,
+        attachmentRequest,
+        forced,
     });
-    // Ctrl-C on a direct (in-process) run cancels GRACEFULLY: abort the run
-    // signal so harness children die via the process-group kill plumbing, gates
-    // are skipped, and the run ends with a typed cancelled terminal — instead
-    // of the node process dying and orphaning children + a terminal-less
-    // events.jsonl. A second Ctrl-C force-exits.
-    const cancelController = new AbortController();
-    let sigints = 0;
-    const onSigint = () => {
-        sigints += 1;
-        if (sigints >= 2)
-            process.exit(130);
-        process.stderr.write("\ncancelling run (Ctrl-C again to force-quit)...\n");
-        cancelController.abort();
-    };
-    process.on("SIGINT", onSigint);
-    process.on("SIGTERM", onSigint);
+}
+/**
+ * All five product modes enter through the managed daemon and control API.
+ * `--json` prints one stable `{ runId, runDir, status }` machine envelope.
+ */
+async function daemonRun(args, json, p) {
+    const inPlace = flagBool(args, "in-place");
+    const jsonStream = flagBool(args, "json-stream");
+    if (json && jsonStream) {
+        return printUsageError(json, "claudexor: --json prints exactly one object and --json-stream prints NDJSON; pass one, not both");
+    }
+    let client;
+    let addr;
     try {
-        const res = await orch.run({
-            repoRoot: process.cwd(),
-            prompt: prompt || "audit this repository",
-            attachments,
-            mode,
-            signal: cancelController.signal,
-            // Only `suggest` (or unset) reaches the in-process path; auto_safe/auto_full
-            // are routed to the daemon above. Forward it so an explicit --autonomy
-            // suggest is honoured rather than silently dropped.
-            ...(autonomy ? { autonomy } : {}),
-            harnesses: resolvedHarnesses,
-            primaryHarness: resolvedPrimaryHarness,
-            portfolio: portfolio?.success ? portfolio.data : undefined,
-            n: forced.race === true ? (nFlag ?? 2) : nFlag,
-            attempts: attemptsFlag ?? null,
-            untilClean: flagBool(args, "until-clean"),
-            swarm: forced.swarm === true || flagBool(args, "swarm"),
-            create: forced.create === true || flagBool(args, "create"),
-            tests,
-            protectedPathApprovals: resolvedProtectedPathApprovals,
-            maxUsd: maxUsd ?? null,
-            maxToolCalls: maxToolCalls ?? null,
-            access: resolvedAccess,
-            web: resolvedWebPolicy,
-            externalContextPolicy: resolvedWebPolicy,
-            model: resolvedModel,
-            effort: resolvedEffort,
-            synthesis: resolvedSynthesis,
-            specId: spec?.id,
-            specHash: loadedSpec?.specHash,
-            specPath: loadedSpec?.specPath,
-            inPlace: flagBool(args, "in-place"),
-            // Live progress + interactive answers on a TTY; --json stays a pure
-            // machine surface (no printer, no prompts — questions decline benignly).
-            ...(json
-                ? {}
-                : {
-                    onEvent: (ev) => {
-                        const line = formatRunEventLine(ev);
-                        if (line)
-                            print(line);
-                    },
-                    onInteraction: (ctx) => promptQuestionsOnTty(ctx.request.interaction_id, ctx.request.questions, ctx.timeoutAt),
-                }),
-        });
-        if (json) {
-            // One machine surface: on a non-success terminal, ADD a top-level `error`
-            // (mirroring the daemon path's `error`) so a JSON consumer reads the reason
-            // the same way regardless of which run path produced it. Add-only: the full
-            // result (runId/runDir/status/mode/winner/summary/candidates) is preserved.
-            printJson(res.status === "success" ? res : { ...res, error: res.summary });
-        }
-        else {
-            print(`run ${res.runId} [${res.status}] mode=${res.mode} winner=${res.winner ?? "none"}`);
-            print(`  artifacts: ${res.runDir}`);
-            for (const c of res.candidates)
-                print(`  - ${c.attemptId} ${c.harnessId} [${c.status}]`);
-            print("");
-            print(res.summary);
-        }
-        return res.status === "success" ? 0 : 1;
+        ({ client, addr } = await ensureDaemon());
     }
     catch (err) {
         if (json)
@@ -448,38 +459,81 @@ async function orchestrate(args, mode, json, forced = {}) {
             process.stderr.write(`claudexor: ${err instanceof Error ? err.message : String(err)}\n`);
         return 1;
     }
-    finally {
-        process.removeListener("SIGINT", onSigint);
-        process.removeListener("SIGTERM", onSigint);
+    // Thread continuation (W13): --thread <id> targets a thread explicitly;
+    // --resume picks the most recently updated one. POST /runs already funnels a
+    // threadId through the SINGLE createThreadTurn point server-side — this is
+    // parameter plumbing, never a second turn-creation path.
+    let threadId = flagStr(args, "thread");
+    if (threadId === undefined && flagBool(args, "resume")) {
+        try {
+            const res = await controlApiFetch(addr, "/threads", {
+                headers: { Authorization: `Bearer ${addr.token}` },
+            });
+            if (!res.ok)
+                throw new Error(`GET /threads failed: ${res.status}`);
+            // Parse through the typed DTO — the field is camelCase `updatedAt`, and a
+            // hand-rolled `updated_at` read silently sorts undefined and throws.
+            const list = ControlThreadListResponse.parse(await res.json());
+            const newest = pickResumableThread(list.threads);
+            if (!newest) {
+                // Stay valid on the active output surface: NDJSON stream keeps compact
+                // lines; --json prints its one object; text goes to stderr.
+                const message = "claudexor: --resume found no threads to continue";
+                if (jsonStream)
+                    printJsonLine({ ok: false, exitCode: 1, error: message });
+                else if (json)
+                    printJson({ ok: false, exitCode: 1, error: message });
+                else
+                    process.stderr.write(`${message}\n`);
+                return 1;
+            }
+            threadId = newest.id;
+        }
+        catch (err) {
+            const message = `claudexor: --resume could not list threads: ${err instanceof Error ? err.message : String(err)}`;
+            if (jsonStream)
+                printJsonLine({ ok: false, exitCode: 1, error: message });
+            else if (json)
+                printJson({ ok: false, exitCode: 1, error: message });
+            else
+                process.stderr.write(`${message}\n`);
+            return 1;
+        }
+    }
+    let attachmentRefs;
+    try {
+        attachmentRefs = p.attachmentRequest
+            ? await Promise.all(p.attachmentRequest.map((attachment) => uploadLocalAttachment(addr, attachment)))
+            : undefined;
+    }
+    catch (err) {
+        if (json)
+            printJson({
+                ok: false,
+                exitCode: 1,
+                error: `claudexor: attachment upload failed: ${err instanceof Error ? err.message : String(err)}`,
+            });
+        else
+            process.stderr.write(`claudexor: attachment upload failed: ${err instanceof Error ? err.message : String(err)}\n`);
+        return 1;
     }
-}
-/**
- * DAEMON-TRACKED mutating run (the unified `agent`/`best-of`/`create` path, and an
- * `orchestrate` run with auto_safe/auto_full autonomy). Auto-starts
- * the daemon if needed, enqueues via the control API (so the run is registered
- * and the control-api can see/unblock it), streams its events to the TTY (text
- * mode) and resolves the runDir from the daemon (the run lives under the daemon
- * dir, not project-local) so apply/decision/inspect can find it. `--json` prints
- * exactly one object `{ runId, runDir, status }` — the SWE/TB benchmark runner
- * parses this to read <runDir>/final/patch.diff.
- */
-async function daemonAgentRun(args, json, p) {
-    // The run is always project-scoped (the cwd is its repo); execution is
-    // live in-place only under the explicit --in-place convergence path.
-    const inPlace = flagBool(args, "in-place");
     const body = {
         prompt: p.prompt,
-        ...(p.attachmentRequest ? { attachments: p.attachmentRequest } : {}),
+        ...(p.instructions ? { instructions: p.instructions } : {}),
+        ...(p.maxSeconds !== undefined ? { maxSeconds: p.maxSeconds } : {}),
+        ...(p.maxTurns !== undefined ? { maxTurns: p.maxTurns } : {}),
+        ...(p.denyPaths?.length ? { denyPaths: p.denyPaths } : {}),
+        ...(p.outputSchema !== undefined ? { outputSchema: p.outputSchema } : {}),
+        ...(attachmentRefs ? { attachments: attachmentRefs } : {}),
         mode: p.mode,
-        // Autonomy only governs the orchestrate executor; send it only for that mode.
+        ...(threadId ? { threadId } : {}),
         ...(p.mode === "orchestrate" && p.autonomy ? { autonomy: p.autonomy } : {}),
         scope: { kind: "project", root: process.cwd() },
         execution: { isolation: inPlace ? "live" : "envelope" },
-        ...(harnessList(args) ? { harnesses: harnessList(args) } : {}),
-        ...(flagStr(args, "primary-harness")
-            ? { primaryHarness: flagStr(args, "primary-harness") }
-            : {}),
-        ...(p.portfolio ? { portfolio: p.portfolio } : {}),
+        ...(p.resolvedHarnesses ? { harnesses: p.resolvedHarnesses } : {}),
+        ...(p.resolvedPrimaryHarness ? { primaryHarness: p.resolvedPrimaryHarness } : {}),
+        ...(p.routingGoal ? { routingGoal: p.routingGoal } : {}),
+        ...(p.credentialProfileId ? { credentialProfileId: p.credentialProfileId } : {}),
         ...(p.forced.race === true ? { n: p.nFlag ?? 2 } : p.nFlag !== undefined ? { n: p.nFlag } : {}),
         ...(p.attemptsFlag !== undefined ? { attempts: p.attemptsFlag } : {}),
         ...(flagBool(args, "until-clean") ? { untilClean: true } : {}),
@@ -488,11 +542,13 @@ async function daemonAgentRun(args, json, p) {
         ...(p.resolvedSynthesis ? { synthesis: p.resolvedSynthesis } : {}),
         ...(p.tests ? { tests: p.tests } : {}),
         ...(p.protectedPathApprovals ? { protectedPathApprovals: p.protectedPathApprovals } : {}),
-        ...(p.maxUsd !== undefined ? { maxUsd: p.maxUsd } : {}),
-        ...(p.mode === "orchestrate" && p.maxToolCalls !== undefined ? { maxToolCalls: p.maxToolCalls } : {}),
+        ...(p.paidBudget !== undefined ? { paidBudget: p.paidBudget } : {}),
+        ...(p.mode === "orchestrate" && p.maxToolCalls !== undefined
+            ? { maxToolCalls: p.maxToolCalls }
+            : {}),
         ...(p.resolvedAccess ? { access: p.resolvedAccess } : {}),
         ...(p.resolvedWebPolicy ? { web: p.resolvedWebPolicy } : {}),
-        ...(flagStr(args, "model") ? { model: flagStr(args, "model") } : {}),
+        ...(p.resolvedModel ? { model: p.resolvedModel } : {}),
         ...(p.resolvedEffort ? { effort: p.resolvedEffort } : {}),
         ...(p.reviewerPanel ? { reviewerPanel: p.reviewerPanel } : {}),
         ...(p.reviewerModels ? { reviewerModels: p.reviewerModels } : {}),
@@ -502,15 +558,63 @@ async function daemonAgentRun(args, json, p) {
         ...(p.specPath ? { specPath: p.specPath } : {}),
     };
     try {
-        const { client, addr } = await ensureDaemon();
+        if (jsonStream) {
+            // NDJSON machine surface (W13): an EARLY runId frame first, every run
+            // event as its own line (the shared follow pipeline in json mode), and
+            // the same terminal object --json prints as the LAST line. --json keeps
+            // its exactly-one-object contract untouched.
+            const started = await enqueueAndAwait(client, addr, body, { waitForTerminal: false });
+            if (!started.runId) {
+                // Even the early-failure path stays valid NDJSON (compact, one line).
+                printJsonLine({
+                    frame: "run.terminal",
+                    runId: "",
+                    runDir: started.runDir,
+                    status: runStatusForCli(started.status),
+                    jobId: started.jobId,
+                    mode: p.mode,
+                    ...(started.error ? { error: started.error } : {}),
+                });
+                return exitCodeForState(started.status);
+            }
+            printJsonLine({
+                frame: "run.started",
+                runId: started.runId,
+                runDir: started.runDir,
+                jobId: started.jobId,
+                mode: p.mode,
+            });
+            // Per-event lines: followRun(json=true) already writes one COMPACT object
+            // per event via print(JSON.stringify(ev)).
+            await followRun(started.runId, true);
+            const final = started.jobId ? await client.status(started.jobId) : null;
+            const status = final?.state ?? started.status;
+            const out = {
+                runId: started.runId,
+                runDir: final?.runDir ?? started.runDir,
+                status: runStatusForCli(status),
+                jobId: started.jobId,
+                error: final?.error ?? started.error,
+            };
+            const reason = daemonOutcomeSummary({ ...started, status, error: out.error });
+            const applyEligibility = await fetchApplyEligibility(addr, started.runId);
+            printJsonLine({
+                frame: "run.terminal",
+                runId: out.runId,
+                runDir: out.runDir,
+                status: out.status,
+                jobId: out.jobId,
+                mode: p.mode,
+                ...(out.error ? { error: out.error } : {}),
+                ...(reason ? { summary: reason } : {}),
+                ...(applyEligibility ? { applyEligibility } : {}),
+            });
+            return exitCodeForState(status);
+        }
         if (json) {
-            // Pure machine surface: enqueue, wait for the terminal outcome, print
-            // exactly one JSON object. No event printer, no TTY prompts.
+            // Pure machine surface: await the terminal outcome and print one JSON object.
             const out = await enqueueAndAwait(client, addr, body, { waitForTerminal: true });
-            // Keep the documented bench-parser keys {runId,runDir,status}; ADD `mode`,
-            // `error` (only for real errors), and `summary` (a machine-readable reason
-            // for EVERY non-success terminal incl. `blocked`, which carries no error)
-            // so this path matches the in-process one (P2: one machine surface).
+            // Preserve bench keys while adding mode and honest non-success detail.
             const reason = daemonOutcomeSummary(out);
             // ADD-ONLY key (bench contract keeps {runId,runDir,status}): the derived
             // apply-gate verdict, so machine callers act on truth instead of
@@ -519,7 +623,7 @@ async function daemonAgentRun(args, json, p) {
             printJson({
                 runId: out.runId,
                 runDir: out.runDir,
-                status: out.status,
+                status: runStatusForCli(out.status),
                 jobId: out.jobId,
                 mode: p.mode,
                 ...(out.error ? { error: out.error } : {}),
@@ -539,19 +643,15 @@ async function daemonAgentRun(args, json, p) {
         await followRun(started.runId, false);
         const final = started.jobId ? await client.status(started.jobId) : null;
         const status = final?.state ?? started.status;
+        const publicStatus = runStatusForCli(status);
         print("");
-        print(`run ${started.runId} [${status}]`);
+        print(`run ${started.runId} [${publicStatus}]`);
         print(`  artifacts: ${final?.runDir ?? started.runDir}`);
         if (status === "blocked") {
             print(`  blocked (needs human): unblock with \`claudexor decision ${started.runId} --accept-risk\` or rerun with \`claudexor decision ${started.runId} --rerun --feedback "..."\``);
         }
         else if (exitCodeForState(status) === 0) {
-            // Honest post-run hint: "apply with" is printed ONLY when the apply
-            // gate verifiably accepts the patch. A null verdict means no patch
-            // artifact (answer/no-op runs) or an unreachable detail endpoint —
-            // either way, promising `claudexor apply` would be a lie, so print the
-            // inspect handle instead. Ineligible runs get the honest unblock hint
-            // (ungated/review_not_run used to get a doomed apply command here).
+            // Offer apply only after a positive gate; otherwise print inspect/unblock guidance.
             const eligibility = await fetchApplyEligibility(addr, started.runId);
             if (eligibility?.eligible) {
                 print(`  apply with: claudexor apply ${started.runId}`);
@@ -595,7 +695,7 @@ async function decisionCommand(args, json) {
     const { action, body } = resolved;
     try {
         const { addr } = await ensureDaemon();
-        const res = await fetch(`${addr.baseUrl}/runs/${encodeURIComponent(runId)}/decision`, {
+        const res = await controlApiFetch(addr, `/runs/${encodeURIComponent(runId)}/decision`, {
             method: "POST",
             headers: { Authorization: `Bearer ${addr.token}`, "content-type": "application/json" },
             body: JSON.stringify(body),
@@ -639,9 +739,9 @@ async function decisionCommand(args, json) {
  * Resolve the ArtifactStore that owns a given run, regardless of the cwd the
  * CLI is invoked from. Order:
  *   1. the project store rooted at the current cwd (the common case);
- *   2. the user-level store (~/.claudexor/runs) used by no-project Ask runs;
+ *   2. the v2 user store (~/.claudexor/v2/runs) used by no-project Ask runs;
  *   3. a daemon-tracked run that started in ANOTHER project — agent/race/create
- *      runs live under `<thatProjectRoot>/.claudexor/runs/<runId>`, so we ask
+ *      runs live under that project's external runtime namespace, so we ask
  *      the daemon for the run's absolute runDir (GET /runs/:id ->
  *      summary.runDir) and rebuild a store whose runPaths(runId).root matches.
  * Returns null when no store can be located (the run does not exist anywhere
@@ -672,15 +772,15 @@ async function resolveRunStore(runId) {
         if (!conn)
             return null;
         const { addr } = conn;
-        const resp = await fetch(`${addr.baseUrl}/runs/${encodeURIComponent(runId)}`, {
+        const resp = await controlApiFetch(addr, `/runs/${encodeURIComponent(runId)}`, {
             headers: { Authorization: `Bearer ${addr.token}` },
         });
         if (resp.ok) {
             const detail = (await resp.json());
             const runDir = detail.summary?.runDir;
             if (runDir && existsSync(runDir)) {
-                // runDir = <repoRoot>/.claudexor/runs/<runId>; reconstruct a store whose
-                // runPaths(runId).root === runDir: runId -> runs -> .claudexor.
+                // Reconstruct a store from the daemon-authoritative absolute runDir:
+                // runId -> runs -> owned runtime root.
                 const claudexorDir = resolve(runDir, "..", "..");
                 const ds = new ArtifactStore(dirname(claudexorDir), { claudexorDir });
                 if (existsSync(ds.runPaths(runId).root))
@@ -740,79 +840,66 @@ async function specCommand(args, json) {
         return printUsageError(json, "claudexor spec: --harness/--n/--web/--effort/--max-usd/--reviewer-panel/--reviewer-model/--reviewer-effort control the grounding plan run and only apply when generating questions; drop them when re-running with --answers");
     }
     try {
-        const answers = answersPath ? readAnswers(answersPath) : null;
-        let planRunId = answers?.planRunId ?? "";
-        let planDir = answers?.planDir ?? "";
-        let planText = planDir ? (readTextSafe(join(planDir, "final", "plan.md")) ?? "") : "";
-        if (!planText) {
-            if (answersPath) {
-                throw new Error("answers file does not contain a usable planDir/final/plan.md; re-run without --answers to generate a fresh questions file");
-            }
-            const orch = new Orchestrator({
-                registry: buildRegistry(),
-                reviewerPanel: groundingReviewerPanel,
-                reviewerModels: groundingReviewerModels,
-                reviewerEfforts: groundingReviewerEfforts,
-            });
-            const plan = await orch.run({
-                repoRoot: process.cwd(),
-                prompt,
-                mode: "plan",
-                harnesses: groundingHarnesses,
-                n: groundingN,
-                access: "readonly",
-                web: groundingWeb,
-                effort: groundingEffort,
-                maxUsd: groundingMaxUsd ?? null,
-            });
-            planRunId = plan.runId;
-            planDir = plan.runDir;
-            planText = readTextSafe(join(plan.runDir, "final", "plan.md")) ?? plan.summary;
-        }
-        const questions = extractQuestionsFromPlan(planText);
+        const { addr } = await ensureDaemon();
+        await controlJson(addr, "/projects", {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({ root: process.cwd() }),
+        });
         if (!answersPath) {
-            const draftDir = join(process.cwd(), ".claudexor", "specs", "drafts", planRunId);
-            ensureDir(draftDir);
-            const questionsPath = join(draftDir, "questions.json");
-            writeJson(questionsPath, { prompt, planRunId, planDir, questions, answers: [] });
-            const result = {
-                status: "questions",
-                planRunId,
-                planDir,
-                questionsPath,
-                questions,
-            };
+            const session = ControlSpecSession.parse(await controlJson(addr, "/spec/sessions", {
+                method: "POST",
+                headers: { "content-type": "application/json" },
+                body: JSON.stringify({
+                    prompt,
+                    scope: { kind: "project", root: process.cwd(), context: "auto" },
+                    harnesses: groundingHarnesses,
+                    n: groundingN,
+                    effort: groundingEffort,
+                    paidBudget: groundingMaxUsd === undefined
+                        ? undefined
+                        : { kind: "finite", maxUsd: groundingMaxUsd },
+                    web: groundingWeb,
+                    reviewerPanel: groundingReviewerPanel,
+                    reviewerModels: groundingReviewerModels,
+                    reviewerEfforts: groundingReviewerEfforts,
+                }),
+            }));
             if (json)
-                printJson(result);
+                printJson(session);
             else {
-                print(`plan grounding run: ${planRunId}`);
-                print(`questions: ${questionsPath}`);
-                print(`answer with: claudexor spec ${JSON.stringify(prompt)} --answers ${questionsPath}`);
+                print(`durable spec session: ${session.sessionId}`);
+                print(`grounding run: ${session.planRunId ?? "pending"}`);
+                for (const question of session.questions)
+                    print(`- [${question.id}] ${question.prompt}`);
+                print("save `claudexor spec ... --json` output, fill its answers array, then pass it with --answers");
             }
-            return 0;
+            return session.state === "failed" || session.state === "interrupted_unknown" ? 1 : 0;
+        }
+        const answers = readAnswers(answersPath);
+        if (!answers.sessionId) {
+            throw new Error("answers file must contain sessionId from the durable spec session");
         }
-        const spec = await freezeSpecFromGrounding(prompt, planText, answers ?? readAnswers(answersPath));
-        const persisted = persistSpec(process.cwd(), spec, planText, loadPreviousSpec(flagStr(args, "previous")));
-        const specJsonPath = join(persisted.specDir, "spec.json");
-        const runHint = `claudexor best-of --spec ${JSON.stringify(specJsonPath)}`;
-        const result = {
-            status: "frozen",
-            planRunId,
-            planDir,
-            specId: spec.id,
-            specDir: persisted.specDir,
-            specHash: persisted.specHash,
-            runHint,
-            questions,
-            changes: persisted.changes,
-        };
+        const encodedId = encodeURIComponent(answers.sessionId);
+        await controlJson(addr, `/spec/sessions/${encodedId}/answers`, {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({
+                answers: answers.answers,
+                priorDecisions: answers.priorDecisions,
+            }),
+        });
+        const session = ControlSpecSession.parse(await controlJson(addr, `/spec/sessions/${encodedId}/freeze`, { method: "POST" }));
+        if (session.state !== "frozen" || !session.specPath || !session.specId || !session.specHash) {
+            throw new Error(`spec session ended as ${session.state}`);
+        }
+        const runHint = `claudexor best-of --spec ${JSON.stringify(session.specPath)}`;
         if (json)
-            printJson(result);
+            printJson({ ...session, status: "frozen", runHint });
         else {
-            print(`frozen SpecPack: ${spec.id} v${spec.version}`);
-            print(`  dir: ${persisted.specDir}`);
-            print(`  hash: ${persisted.specHash}`);
-            print(`  native projection: ${join(persisted.specDir, "PLANS.md")}`);
+            print(`frozen SpecPack: ${session.specId}`);
+            print(`  path: ${session.specPath}`);
+            print(`  hash: ${session.specHash}`);
             print(`run: ${runHint}`);
         }
         return 0;
@@ -831,6 +918,15 @@ async function specCommand(args, json) {
         return 1;
     }
 }
+async function controlJson(addr, path, init = {}) {
+    const response = await controlApiFetch(addr, path, init);
+    const text = await response.text();
+    const body = text ? JSON.parse(text) : {};
+    if (response.ok)
+        return body;
+    const detail = body && typeof body === "object" ? body : {};
+    throw new Error(String(detail["message"] ?? detail["error"] ?? `HTTP ${response.status}`));
+}
 function printPreflightError(args, json, error) {
     if (json && (args._[0] ?? "help") === "plugin") {
         printJson(pluginCommandErrorResult(args._[1], args._[2], flagBool(args, "dry-run"), 2, error));
@@ -892,6 +988,9 @@ async function main() {
         return runRepl(process.cwd());
     }
     const cwd = process.cwd();
+    const opsCommand = dispatchOpsCommand(cmd, args, json);
+    if (opsCommand)
+        return opsCommand;
     switch (cmd) {
         case "init": {
             const res = initProjectConfig(cwd);
@@ -901,77 +1000,8 @@ async function main() {
                 print(res.created ? `Created ${res.configPath}` : `Config already exists: ${res.configPath}`);
             return 0;
         }
-        case "doctor": {
-            const cfg = loadConfig(cwd);
-            const only = flagStr(args, "harness");
-            const onlyList = only
-                ? only
-                    .split(",")
-                    .map((s) => s.trim())
-                    .filter(Boolean)
-                : undefined;
-            const gateway = buildGateway({ includeFakes: flagBool(args, "all") });
-            // Scope discovery to the requested harness(es) (P14): a single-harness
-            // query no longer probes every adapter (incl. paid smokes) just to filter.
-            const statuses = await gateway.statusAll({ cwd }, onlyList);
-            // An explicit --harness typo must FAIL LOUDLY, not silently succeed over an
-            // empty list (the scoped probe returns nothing for an unknown id).
-            if (onlyList) {
-                const got = new Set(statuses.map((s) => s.id));
-                const unknown = onlyList.filter((id) => !got.has(id));
-                if (unknown.length)
-                    return printUsageError(json, `claudexor: unknown harness(es): ${unknown.join(", ")} (run \`claudexor harness list --all\`)`);
-            }
-            const filtered = statuses;
-            // a configured default model that the harness does not recognize must
-            // not be silently masked by a smoke that ran a DIFFERENT model. Validate
-            // each harness's configured default against its model truth source (live
-            // inventory or manifest hints via the shared harnessModels SSOT) and
-            // surface a violation honestly as INVALID (strict model truth — no "unverified").
-            const configuredChecks = new Map();
-            await Promise.all(filtered.map(async (s) => {
-                const configured = cfg.global.harnesses[s.id]?.default_model ?? null;
-                if (!configured)
-                    return;
-                const truth = await harnessModels(s.id, process.cwd(), true);
-                const check = validateModel(configured, truth.models.map((m) => m.id), truth.source === "api" ? "api" : "manifest");
-                configuredChecks.set(s.id, { configured, check });
-            }));
-            const modelNote = (s) => {
-                const entry = configuredChecks.get(s.id);
-                if (!entry || entry.check.status === "ok")
-                    return null;
-                return `    model: INVALID — ${entry.check.message}`;
-            };
-            if (json) {
-                printJson({
-                    harnesses: filtered.map((s) => ({
-                        ...s,
-                        configured_model: configuredChecks.get(s.id)?.configured ?? null,
-                        configured_model_check: configuredChecks.get(s.id)?.check ?? null,
-                    })),
-                    node_advisory: atRiskNodeAdvisory(),
-                });
-                return 0;
-            }
-            for (const s of filtered) {
-                const ver = s.manifest?.version ? ` ${s.manifest.version}` : "";
-                print(`${statusGlyph(s.status)} ${s.id}${ver}`);
-                if (s.enabledIntents.length)
-                    print(`    intents: ${s.enabledIntents.join(", ")}`);
-                print(`    auth sources: ${authSourceAvailability(s)}`);
-                print(`    checks: ${checksSummary(s)}`);
-                if (s.reasons.length)
-                    print(`    reasons: ${s.reasons.join(", ")}`);
-                const mn = modelNote(s);
-                if (mn)
-                    print(mn);
-            }
-            const advisory = atRiskNodeAdvisory();
-            if (advisory)
-                print(`advisory: ${advisory}`);
-            return 0;
-        }
+        case "project":
+            return projectCommand(args, json);
         case "agent": {
             const specStrategyError = "claudexor: --spec requires a gated strategy; use 'claudexor best-of --spec <file>' or 'claudexor agent --attempts N --spec <file>'";
             // ONE gate for both spellings: `agent --spec` and `agent --mode agent --spec`
@@ -1032,42 +1062,20 @@ async function main() {
         case "audit":
         case "map":
             return orchestrate(args, "audit", json);
-        case "daemon":
-            return daemonCommand(args, json);
         case "settings":
             return settingsCommand(args, json);
+        case "quota":
+            return quotaCommand(args, json);
         case "trust":
             return trustCommand(args, json);
-        case "auth":
-            return authCommand(args, json);
-        case "models":
-            return modelsCommand(args, json);
-        case "secrets":
-            return secretsCommand(args, json);
         case "mcp": {
-            if (args._[1] === "serve") {
-                // SDK-owned protocol core; mutating verbs are daemon-tracked, so a
-                // run started from an MCP host is visible/unblockable like a CLI run.
-                serveClaudexorMcp({
-                    version: CLAUDEXOR_VERSION,
-                    tools: defaultClaudexorTools(mcpSurfaceRunner()),
-                    transport: { read: process.stdin, write: process.stdout },
-                });
-                // Serve until stdin closes (the SDK handle owns the transport).
-                await new Promise((resolve) => process.stdin.once("close", resolve));
-                return 0;
-            }
+            if (args._[1] === "serve")
+                return serveMcpBridge();
             return printUsageError(json, "usage: claudexor mcp serve");
         }
         case "acp": {
-            if (args._[1] === "serve") {
-                await new AcpServer({
-                    version: CLAUDEXOR_VERSION,
-                    runner: orchestratorRunner(),
-                    transport: { read: process.stdin, write: process.stdout },
-                }).serve();
-                return 0;
-            }
+            if (args._[1] === "serve")
+                return serveAcpBridge();
             return printUsageError(json, "usage: claudexor acp serve");
         }
         case "follow": {
@@ -1077,6 +1085,10 @@ async function main() {
             }
             return followRun(runId, json);
         }
+        case "retry":
+            return retryCommand(args, json);
+        case "run-again":
+            return runAgainCommand(args, json);
         case "review":
             return reviewCommand(args, json);
         case "inspect": {
@@ -1159,17 +1171,42 @@ async function main() {
             }
             if (telemetry) {
                 print(`web: policy=${telemetry.external_context_policy} effective=${telemetry.effective_web_mode} required=${telemetry.web_required} evidence=${telemetry.web.status}`);
+                for (const requirement of telemetry.request_requirements.filter((item) => item.requested)) {
+                    print(`${requirement.capability}: harness=${requirement.harness_id} requested=true effective=${requirement.effective} reason=${requirement.reason}`);
+                }
             }
             else if (contract.success) {
                 print(`web: policy=${contract.data.external_context.policy} required=${contract.data.external_context.web_required} evidence=unavailable (no telemetry.yaml)`);
             }
             print(`output: ${outputReadyState}${primary ? ` ${primary.path}` : ""}`);
+            {
+                // Structured-output contract receipt (only present when the run was
+                // started with --output-schema); projected, never re-validated here.
+                const conformance = StructuredOutputConformance.safeParse(store.readYaml(join(paths.finalDir, "structured_output.yaml")));
+                if (conformance.success) {
+                    print(`structured output: ${conformance.data.status}${conformance.data.output_path ? ` ${conformance.data.output_path}` : ""}${conformance.data.reason ? ` (${conformance.data.reason})` : ""}`);
+                }
+            }
             if (parsedDecision.success) {
                 const vb = parsedDecision.data.verification_basis;
                 print(`decision: ${parsedDecision.data.status} outcome=${parsedDecision.data.outcome} apply=${parsedDecision.data.apply_recommendation}${vb !== "none" ? ` verified_by=${vb}` : ""}`);
                 const budget = parsedDecision.data.budget_summary;
                 print(`budget: spend=${budget.spend_usd ?? "unknown"}${budget.estimated ? " estimated" : ""}`);
             }
+            if (telemetry) {
+                const u = telemetry.usage_totals;
+                if (u.input_tokens !== null || u.output_tokens !== null || u.cached_input_tokens !== null) {
+                    print(`tokens: in=${u.input_tokens ?? "n/a"} out=${u.output_tokens ?? "n/a"} cached=${u.cached_input_tokens ?? "n/a"}`);
+                }
+                // Route receipt (INV-061 disclosure), projected verbatim from telemetry.
+                const route = telemetry.auth_route;
+                if (route) {
+                    print(`auth route: requested=${route.requested} effective=${route.effective ?? "undisclosed"} source=${route.source ?? "undisclosed"} reason=${route.reason}${route.harness_id ? ` (${route.harness_id}/${route.attempt_id ?? "?"})` : ""}`);
+                    if (route.model_mismatch) {
+                        print(`model mismatch: requested=${route.model_mismatch.requested} observed=${route.model_mismatch.observed}`);
+                    }
+                }
+            }
             if (telemetry && (telemetry.web.attempted || telemetry.web.required)) {
                 print(`web evidence: status=${telemetry.web.status} tool=${telemetry.web.tool ?? "none"} target=${telemetry.web.target ?? "none"}${telemetry.web.error_summary ? ` error=${telemetry.web.error_summary}` : ""}`);
             }
@@ -1203,127 +1240,43 @@ async function main() {
             if (!runId) {
                 return printUsageError(json, "usage: claudexor apply <run_id> [--mode apply|commit|branch|pr] [--dry-run]");
             }
-            // Resolve the owning store from any cwd (project / user Ask / daemon-tracked
-            // run in another project) before reading the patch artifact.
-            const resolved = await resolveRunStore(runId);
-            if (!resolved) {
-                if (json)
-                    printJson({ runId, error: `no such run ${runId}` });
-                else
-                    print(`no such run ${runId}`);
-                return 1;
-            }
-            const store = resolved.store;
-            const paths = store.runPaths(runId);
-            const patch = readTextSafe(join(paths.finalDir, "patch.diff"));
-            if (!patch || patch.trim().length === 0) {
-                if (json)
-                    printJson({ runId, error: `no patch found for run ${runId}` });
-                else
-                    print(`no patch found for run ${runId}`);
-                return 1;
-            }
-            if (containsSecretLikeToken(patch)) {
-                if (json)
-                    printJson({ runId, error: "patch contains secret-like token; refusing apply" });
-                else
-                    print("patch contains secret-like token; refusing apply");
-                return 1;
-            }
-            // Apply policy has ONE owner (delivery.validateApplyGate) shared with the
-            // Control API; the CLI only adapts artifact reads into it. No duplicated
-            // pre-checks here: a NEEDS_HUMAN run unblocked through the typed decision
-            // endpoint (arbitration/operator_decision.yaml, hash-bound) must apply
-            // identically from BOTH surfaces.
-            const applyDecision = DecisionRecord.safeParse(store.readYaml(join(paths.arbitrationDir, "decision.yaml")));
-            const workProduct = WorkProduct.safeParse(store.readYaml(join(paths.finalDir, "work_product.yaml")));
-            const contract = TaskContract.safeParse(store.readYaml(join(paths.contextDir, "task.yaml")));
-            const operatorDecisionRaw = store.readYaml(join(paths.arbitrationDir, "operator_decision.yaml"));
-            const operatorDecision = operatorDecisionRaw && typeof operatorDecisionRaw["action"] === "string"
-                ? {
-                    action: operatorDecisionRaw["action"],
-                    patch_sha256: typeof operatorDecisionRaw["patch_sha256"] === "string"
-                        ? operatorDecisionRaw["patch_sha256"]
-                        : undefined,
-                }
-                : null;
-            // The default apply target is the run's ORIGINAL project (from its contract),
-            // not the current working directory — so a daemon-tracked run resolved via
-            // the registry applies correctly from any cwd (namespace unification).
-            // Fall back to cwd only for a legacy run with no readable contract.
-            const applyRoot = contract.success ? contract.data.repo.root : process.cwd();
-            // Artifact-only path: the live daemon job state is unavailable, but the
-            // orchestrator records the terminal run status in work_product.meta.status.
-            // Feed it (mapped to daemon-state vocab) into the shared gate so the CLI
-            // enforces the SAME terminal-state bar the Control API does — e.g. a
-            // convergence run that persists decision.status=success but terminal
-            // not_converged (stale diff after a required review) is refused identically.
-            const recordedStatus = workProduct.success
-                ? workProduct.data.meta?.["status"]
-                : undefined;
-            const recordedState = recordedStatus
-                ? recordedStatus === "success"
-                    ? "succeeded"
-                    : recordedStatus
-                : null;
-            const gateError = validateApplyGate({
-                state: recordedState,
-                decision: applyDecision.success ? applyDecision.data : null,
-                workProduct: workProduct.success ? workProduct.data : null,
-                patch,
-                originalRepoRoot: contract.success ? contract.data.repo.root : null,
-                targetRepoRoot: applyRoot,
-                operatorDecision,
-            });
-            if (gateError) {
-                if (json)
-                    printJson({ runId, error: gateError });
-                else
-                    print(gateError);
-                return 1;
-            }
-            if (flagBool(args, "dry-run")) {
-                const r = await checkPatch(applyRoot, patch);
-                if (json)
-                    printJson({
-                        runId,
-                        dryRun: true,
-                        applies: r.ok,
-                        ...(r.ok ? {} : { error: r.stderr.trim() }),
-                    });
-                else
-                    print(r.ok ? "patch applies cleanly" : `patch does not apply: ${r.stderr.trim()}`);
-                return r.ok ? 0 : 1;
-            }
             const rawMode = flagStr(args, "mode") ?? "apply";
-            if (!DELIVER_MODES.has(rawMode)) {
+            if (!["apply", "commit", "branch", "pr"].includes(rawMode)) {
                 if (json)
                     printJson({ runId, error: `unsupported apply mode: ${rawMode}` });
                 else
                     print(`unsupported apply mode: ${rawMode}`);
                 return 2;
             }
-            // `apply` mutates the tree; `artifact_only` produces no mutation and the
-            // patch artifact was already emitted by the run — reject it here (it stays
-            // valid on the control-api for clients that want a dry materialization).
-            if (rawMode === "artifact_only") {
-                const msg = "apply --mode artifact_only is a no-op (the patch artifact already exists at <runDir>/final/patch.diff); use apply|branch|commit|pr to mutate, or read the artifact directly";
-                if (json)
-                    printJson({ runId, error: msg });
-                else
-                    print(msg);
-                return 2;
-            }
-            const mode = rawMode;
-            const res = await deliver(applyRoot, patch, { mode, message: `claudexor: apply ${runId}` });
+            const { addr } = await ensureDaemon();
+            const dryRun = flagBool(args, "dry-run");
+            const response = await controlApiFetch(addr, `/runs/${encodeURIComponent(runId)}/apply${dryRun ? "/check" : ""}`, {
+                method: "POST",
+                headers: { "content-type": "application/json" },
+                body: JSON.stringify(dryRun
+                    ? { target: { kind: "original_project" } }
+                    : {
+                        target: { kind: "original_project" },
+                        mode: rawMode,
+                        message: `claudexor: apply ${runId}`,
+                    }),
+            });
+            const text = await response.text();
+            const result = text ? JSON.parse(text) : {};
             if (json)
-                printJson(res);
+                printJson({ runId, ...(dryRun ? { dryRun: true } : {}), ...result });
+            else if (!response.ok)
+                print(String(result["message"] ?? result["error"] ?? text));
+            else if (dryRun)
+                print(result["ok"] === true ? "patch applies cleanly" : "patch does not apply");
             else
-                print(`${res.mode}: applied=${res.applied}` +
-                    (res.commit ? ` commit=${res.commit.slice(0, 8)}` : "") +
-                    (res.branch ? ` branch=${res.branch}` : "") +
-                    (res.detail ? ` (${res.detail})` : ""));
-            return res.applied ? 0 : 1;
+                print(`${String(result["mode"] ?? rawMode)}: applied=${String(result["applied"] ?? false)}` +
+                    (typeof result["commit"] === "string"
+                        ? ` commit=${result["commit"].slice(0, 8)}`
+                        : "") +
+                    (typeof result["branch"] === "string" ? ` branch=${result["branch"]}` : "") +
+                    (typeof result["detail"] === "string" ? ` (${result["detail"]})` : ""));
+            return response.ok && (dryRun ? result["ok"] === true : result["applied"] === true) ? 0 : 1;
         }
         case "decision":
             return decisionCommand(args, json);
@@ -1421,7 +1374,9 @@ async function main() {
                 print(`modes: ${catalog.modes.join(", ")}`);
                 print(`available harnesses: ${catalog.availableHarnesses.join(", ") || "(none)"}`);
                 for (const h of catalog.harnesses) {
-                    const model = h.configuredModel ? ` model=${h.configuredModel}${h.configuredModelValid === false ? " (REJECTED)" : ""}` : "";
+                    const model = h.configuredModel
+                        ? ` model=${h.configuredModel}${h.configuredModelValid === false ? " (REJECTED)" : ""}`
+                        : "";
                     print(`  ${statusGlyph(h.status)} ${h.id}: ${h.status}; intents=${h.enabledIntents.join(",") || "-"}; models=${h.models.count} (${h.models.source})${model}`);
                 }
                 print(`mcp tools: ${catalog.mcpTools.join(", ")}`);
@@ -1443,7 +1398,11 @@ async function main() {
             // exit 0 — scripts must not mistake a typo'd verb for success. --json
             // callers get the machine envelope on stdout (stdout purity contract).
             if (json) {
-                printJson({ ok: false, exitCode: 2, error: `claudexor: unknown command '${cmd}' (see \`claudexor help --json\`)` });
+                printJson({
+                    ok: false,
+                    exitCode: 2,
+                    error: `claudexor: unknown command '${cmd}' (see \`claudexor help --json\`)`,
+                });
                 return 2;
             }
             process.stderr.write(`claudexor: unknown command '${cmd}'\n\n${HELP}\n`);