cool-workflow 0.1.92 → 0.1.94

package/dist/cli/handlers/run.js

@@ -0,0 +1,153 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleRun = handleRun;
+const capability_core_1 = require("../../capability-core");
+const run_registry_1 = require("../../run-registry");
+const run_summary_1 = require("../run-summary");
+const io_1 = require("../io");
+/** `cw run <app> --drive [--once]` (Agent Delegation Drive) + the run-registry verbs
+ *  (drive/search/list/show/resume/archive/rerun/export/import/verify-import/inspect-archive/restore). */
+function handleRun(args, runner) {
+    // Agent Delegation Drive (v0.1.38): `cw run <app> --drive [--once]` drives a
+    // run end-to-end by delegating each worker to the agent backend. Distinct from
+    // the run-REGISTRY verbs below. `--preview` (or the `run drive <run-id>` form)
+    // is the read-only, deterministic next-step preview.
+    //
+    // A run-REGISTRY subcommand keyword (resume/show/...) must NOT be intercepted
+    // here just because it carries a --drive flag of its own — e.g.
+    // `run resume <id> --drive` is the resume verb's opt-in continuation, not
+    // `run <app=resume> --drive`. Fall through to the switch for those keywords.
+    const runRegistrySubcommand = new Set([
+        "drive", "search", "list", "show", "resume", "archive", "rerun", "export", "import", "verify-import", "inspect-archive", "restore"
+    ]);
+    if (args.options.drive && !runRegistrySubcommand.has(String(args.positionals[0] || ""))) {
+        const target = args.positionals[0];
+        const runId = (0, io_1.optionalArg)(args.options.run) || (0, io_1.optionalArg)(args.options.runId);
+        if (args.options.preview) {
+            (0, io_1.printJson)((0, capability_core_1.runDrivePreview)(runner, { ...args.options, runId: runId || target }));
+            return;
+        }
+        const driveArgs = { ...args.options };
+        if (runId)
+            driveArgs.runId = runId;
+        else
+            driveArgs.appId = target;
+        const dr = (0, capability_core_1.runDrive)(runner, driveArgs);
+        (0, io_1.printJson)(dr);
+        if (!(0, io_1.wantsJson)(args.options)) {
+            (0, run_summary_1.emitRunSummary)(runner, args.options, {
+                runId: dr.runId,
+                reportPath: dr.reportPath,
+                status: dr.status,
+                statePath: dr.statePath,
+                completedWorkers: dr.completedWorkers,
+                plannedWorkers: dr.plannedWorkers,
+                agentConfigured: dr.agentConfigured
+            });
+        }
+        return;
+    }
+    const registry = (0, capability_core_1.runRegistryFor)(args.options, runner);
+    const [subcommand, id] = args.positionals;
+    switch (subcommand) {
+        case "drive": {
+            // `run drive <run-id>` = read-only preview; `--step [--once]` = mutating drive.
+            if (args.options.step) {
+                const driveArgs = { ...args.options };
+                if (id)
+                    driveArgs.runId = id;
+                const dr = (0, capability_core_1.runDrive)(runner, driveArgs);
+                (0, io_1.printJson)(dr);
+                if (!(0, io_1.wantsJson)(args.options)) {
+                    (0, run_summary_1.emitRunSummary)(runner, args.options, {
+                        runId: dr.runId,
+                        reportPath: dr.reportPath,
+                        status: dr.status,
+                        statePath: dr.statePath,
+                        completedWorkers: dr.completedWorkers,
+                        plannedWorkers: dr.plannedWorkers,
+                        agentConfigured: dr.agentConfigured
+                    });
+                }
+                return;
+            }
+            (0, io_1.printJson)((0, capability_core_1.runDrivePreview)(runner, { ...args.options, runId: (0, io_1.required)(id, "run id") }));
+            return;
+        }
+        case "search": {
+            const result = (0, capability_core_1.runSearch)(registry, args.options);
+            if ((0, io_1.wantsJson)(args.options))
+                (0, io_1.printJson)(result);
+            else
+                process.stdout.write(`${(0, run_registry_1.formatRunSearch)(result)}\n`);
+            return;
+        }
+        case "list": {
+            const result = (0, capability_core_1.runList)(registry, args.options);
+            if ((0, io_1.wantsJson)(args.options))
+                (0, io_1.printJson)(result);
+            else
+                process.stdout.write(`${(0, run_registry_1.formatRunSearch)(result)}\n`);
+            return;
+        }
+        case "show": {
+            const result = (0, capability_core_1.runShow)(registry, (0, io_1.required)(id, "run id"), args.options);
+            if ((0, io_1.wantsJson)(args.options))
+                (0, io_1.printJson)(result);
+            else
+                process.stdout.write(`${(0, run_registry_1.formatRunShow)(result)}\n`);
+            return;
+        }
+        case "resume": {
+            const result = (0, capability_core_1.runResume)(registry, runner, (0, io_1.required)(id, "run id"), args.options);
+            if ((0, io_1.wantsJson)(args.options))
+                (0, io_1.printJson)(result);
+            else
+                process.stdout.write(`${(0, run_registry_1.formatResume)(result)}\n`);
+            return;
+        }
+        case "archive":
+            (0, io_1.printJson)((0, capability_core_1.runArchive)(registry, id, args.options));
+            return;
+        case "rerun":
+            (0, io_1.printJson)((0, capability_core_1.runRerun)(registry, (0, io_1.required)(id, "run id"), args.options));
+            return;
+        case "export":
+            (0, io_1.printJson)((0, capability_core_1.runExportArchive)(runner, (0, io_1.required)(id || (0, io_1.optionalArg)(args.options.runId || args.options.run), "run id"), args.options));
+            return;
+        case "import":
+            (0, io_1.printJson)((0, capability_core_1.runImportArchive)(runner, { ...args.options, archive: id || args.options.archive || args.options.path }));
+            return;
+        case "verify-import": {
+            const result = (0, capability_core_1.runVerifyImport)(runner, (0, io_1.required)(id || (0, io_1.optionalArg)(args.options.runId || args.options.run), "run id"), args.options);
+            (0, io_1.printJson)(result);
+            // Fail-closed ONLY behind --strict, so the default exit stays 0
+            // (byte-identical). With --strict, any failed restore check — including
+            // the new trust-audit row — exits 1 for `verify-import && restore`.
+            if (Boolean(args.options.strict) && !result.ok)
+                process.exitCode = 1;
+            return;
+        }
+        case "inspect-archive": {
+            const result = (0, capability_core_1.runInspectArchive)(runner, { ...args.options, archive: id || args.options.archive || args.options.path });
+            (0, io_1.printJson)(result);
+            // Read-only diagnostic: exit 1 when the archive fails any integrity check,
+            // so `cw run inspect-archive <path> && restore` stops on a bad archive.
+            if (!result.ok)
+                process.exitCode = 1;
+            return;
+        }
+        case "restore": {
+            const result = (0, capability_core_1.runRestoreArchive)(runner, { ...args.options, archive: id || args.options.archive || args.options.path });
+            (0, io_1.printJson)(result);
+            // Fail-closed: exit 1 when inspect OR verify failed, so a tampered or
+            // unverifiable archive never reports a made-up success (mirrors the
+            // inspect-archive exit-1 pattern).
+            if (!result.ok)
+                process.exitCode = 1;
+            return;
+        }
+        default:
+            throw new Error("Usage: cw.js run search|list|show|resume|archive|rerun|drive|export|import|verify-import|inspect-archive|restore [run-id|archive] [--scope repo|home] [--json]  |  cw.js run <app> --drive [--once] [--incremental] [--repo R --question Q]");
+    }
+}

package/dist/cli/handlers/scheduling.js

@@ -0,0 +1,126 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleSchedule = handleSchedule;
+exports.handleRoutine = handleRoutine;
+exports.handleSched = handleSched;
+// `cw schedule` / `cw routine` / `cw sched` handlers — the scheduling command
+// family, carved out of the command-surface god-dispatch. Three sibling verbs:
+//   schedule — desktop scheduler (create/list/.../daemon) over the Scheduler
+//   routine  — routine triggers (create/list/delete/fire/events) over the bridge
+//   sched    — durable run-queue scheduling (plan/lease/release/.../policy)
+const node_fs_1 = __importDefault(require("node:fs"));
+const daemon_1 = require("../../daemon");
+const capability_core_1 = require("../../capability-core");
+const io_1 = require("../io");
+/** `cw schedule create|list|delete|due|complete|pause|resume|run-now|history|daemon`. */
+async function handleSchedule(args, scheduler) {
+    const [subcommand, id] = args.positionals;
+    switch (subcommand) {
+        case "create":
+            (0, io_1.printJson)(scheduler.create(args.options));
+            return;
+        case "list":
+            (0, io_1.printJson)(scheduler.list(args.options.status ? String(args.options.status) : undefined));
+            return;
+        case "delete":
+            (0, io_1.printJson)(scheduler.delete((0, io_1.required)(id, "schedule id")));
+            return;
+        case "due":
+            (0, io_1.printJson)(scheduler.due());
+            return;
+        case "complete":
+            (0, io_1.printJson)(scheduler.complete((0, io_1.required)(id, "schedule id"), args.options));
+            return;
+        case "pause":
+            (0, io_1.printJson)(scheduler.pause((0, io_1.required)(id, "schedule id")));
+            return;
+        case "resume":
+            (0, io_1.printJson)(scheduler.resume((0, io_1.required)(id, "schedule id")));
+            return;
+        case "run-now":
+            (0, io_1.printJson)(scheduler.runNow((0, io_1.required)(id, "schedule id")));
+            return;
+        case "history":
+            (0, io_1.printJson)(scheduler.history(id));
+            return;
+        case "daemon": {
+            const daemon = new daemon_1.DesktopSchedulerDaemon({
+                cwd: String(args.options.cwd || process.cwd()),
+                intervalSeconds: Number(args.options.intervalSeconds || args.options.interval || 60)
+            });
+            if (args.options.once) {
+                (0, io_1.printJson)(daemon.tick());
+                return;
+            }
+            await daemon.run();
+            return;
+        }
+        default:
+            throw new Error("Usage: cw.js schedule create|list|delete|due|complete|pause|resume|run-now|history|daemon");
+    }
+}
+/** `cw routine create|list|delete|fire|events`. */
+function handleRoutine(args, triggers) {
+    const [subcommand, idOrKind, payloadPath] = args.positionals;
+    switch (subcommand) {
+        case "create":
+            (0, io_1.printJson)(triggers.create(args.options));
+            return;
+        case "list":
+            (0, io_1.printJson)(triggers.list(args.options.kind ? String(args.options.kind) : undefined));
+            return;
+        case "delete":
+            (0, io_1.printJson)(triggers.delete((0, io_1.required)(idOrKind, "trigger id")));
+            return;
+        case "fire": {
+            const kind = (0, io_1.required)(idOrKind, "trigger kind");
+            const payload = payloadPath ? JSON.parse(node_fs_1.default.readFileSync(payloadPath, "utf8")) : args.options;
+            (0, io_1.printJson)(triggers.fire(kind, payload));
+            return;
+        }
+        case "events":
+            (0, io_1.printJson)(triggers.events(idOrKind));
+            return;
+        default:
+            throw new Error("Usage: cw.js routine create|list|delete|fire|events");
+    }
+}
+/** `cw sched plan|lease|release|complete|reclaim|reset|policy [show|set]` — durable run-queue. */
+function handleSched(args, runner) {
+    const registry = (0, capability_core_1.runRegistryFor)(args.options, runner);
+    const [subcommand, idArg] = args.positionals;
+    switch (subcommand) {
+        case "plan":
+            (0, io_1.printJson)((0, capability_core_1.schedPlan)(registry, args.options));
+            return;
+        case "lease":
+            (0, io_1.printJson)((0, capability_core_1.schedLease)(registry, args.options));
+            return;
+        case "release":
+            (0, io_1.printJson)((0, capability_core_1.schedRelease)(registry, { ...args.options, leaseId: args.options.leaseId || idArg }));
+            return;
+        case "complete":
+            (0, io_1.printJson)((0, capability_core_1.schedComplete)(registry, { ...args.options, leaseId: args.options.leaseId || idArg }));
+            return;
+        case "reclaim":
+            (0, io_1.printJson)((0, capability_core_1.schedReclaim)(registry, args.options));
+            return;
+        case "reset":
+            (0, io_1.printJson)((0, capability_core_1.schedReset)(registry, { ...args.options, id: args.options.id || idArg }));
+            return;
+        case "policy": {
+            const [, action] = args.positionals;
+            if (action === "set") {
+                (0, io_1.printJson)((0, capability_core_1.schedPolicySet)(registry, args.options));
+                return;
+            }
+            (0, io_1.printJson)((0, capability_core_1.schedPolicyShow)(registry));
+            return;
+        }
+        default:
+            throw new Error("Usage: cw.js sched plan|lease|release|complete|reclaim|reset|policy [show|set] [id] [--maxConcurrent N --maxAttempts N ...]");
+    }
+}

package/dist/cli/handlers/workbench.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleWorkbench = handleWorkbench;
+const workbench_1 = require("../../workbench");
+const workbench_host_1 = require("../../workbench-host");
+const format_1 = require("../format");
+const io_1 = require("../io");
+/** `cw workbench serve [--port N] [--once] | view <run-id> [--json]` — the optional
+ *  read-only, localhost-only workbench. Behaviour-identical to the former inline case. */
+async function handleWorkbench(args, runner) {
+    const [subcommand, runId] = args.positionals;
+    switch (subcommand) {
+        case "view": {
+            // Read-only five-panel view of one run. Same core entry as cw_workbench_view.
+            const view = (0, workbench_1.buildWorkbenchRunView)(runner, (0, io_1.required)(runId, "run id"));
+            if ((0, io_1.wantsJson)(args.options))
+                (0, io_1.printJson)(view);
+            else
+                process.stdout.write(`${(0, format_1.formatWorkbenchView)(view)}\n`);
+            return;
+        }
+        case "serve": {
+            // The OPTIONAL localhost host. `--once`/`--json` emit the descriptor only
+            // (no server); the default starts the read-only, localhost-only host.
+            if (args.options.once || (0, io_1.wantsJson)(args.options)) {
+                (0, io_1.printJson)((0, workbench_1.buildWorkbenchServeDescriptor)(runner, { ...args.options, once: true }));
+                return;
+            }
+            const host = new workbench_host_1.WorkbenchHost({
+                runner,
+                cwd: String(args.options.cwd || process.cwd()),
+                port: Number(args.options.port) || undefined,
+                scope: args.options.scope === "repo" ? "repo" : "home"
+            });
+            await host.run();
+            return;
+        }
+        default:
+            throw new Error("Usage: cw.js workbench serve [--port N] [--once] | view <run-id> [--json]");
+    }
+}

package/dist/cli/handlers/worker.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleWorker = handleWorker;
+const operator_ux_1 = require("../../operator-ux");
+const io_1 = require("../io");
+/** `cw worker list|summary|show|manifest|output|fail|validate <run-id> [worker-id] [result-file]`. */
+function handleWorker(args, runner) {
+    const [subcommand, runId, workerId, resultPath] = args.positionals;
+    switch (subcommand) {
+        case "list":
+            (0, io_1.printJson)(runner.listWorkers((0, io_1.required)(runId, "run id"), args.options));
+            return;
+        case "summary": {
+            const summary = runner.summarizeWorkerRecords((0, io_1.required)(runId, "run id"));
+            if ((0, io_1.wantsJson)(args.options))
+                (0, io_1.printJson)(summary);
+            else
+                process.stdout.write(`${(0, operator_ux_1.formatWorkerSummary)(summary)}\n`);
+            return;
+        }
+        case "show":
+            (0, io_1.printJson)(runner.showWorker((0, io_1.required)(runId, "run id"), (0, io_1.required)(workerId, "worker id")));
+            return;
+        case "manifest":
+            (0, io_1.printJson)(runner.showWorkerManifest((0, io_1.required)(runId, "run id"), (0, io_1.required)(workerId, "worker id")));
+            return;
+        case "output":
+            (0, io_1.printJson)(runner.recordWorkerOutput((0, io_1.required)(runId, "run id"), (0, io_1.required)(workerId, "worker id"), (0, io_1.required)(resultPath, "result file"), args.options));
+            return;
+        case "fail":
+            (0, io_1.printJson)(runner.recordWorkerFailure((0, io_1.required)(runId, "run id"), (0, io_1.required)(workerId, "worker id"), String(args.options.message || (0, io_1.required)(resultPath, "failure message")), args.options));
+            return;
+        case "validate": {
+            // Non-null = a boundary violation: a validate verb must report an invalid
+            // verdict through its exit code, not just print it and exit 0.
+            const violation = runner.validateWorker((0, io_1.required)(runId, "run id"), (0, io_1.required)(workerId, "worker id"), resultPath);
+            (0, io_1.printJson)(violation);
+            if (violation)
+                process.exitCode = 1;
+            return;
+        }
+        default:
+            throw new Error("Usage: cw.js worker list|summary|show|manifest|output|fail|validate <run-id> [worker-id] [result-file]");
+    }
+}

package/dist/cli/io.js

@@ -0,0 +1,27 @@
+"use strict";
+// Shared CLI input/output helpers, extracted from command-surface.ts so the
+// dispatcher and per-command handler modules import ONE copy instead of carrying
+// these in the god-object. Pure + zero-dep: arg coercion + JSON stdout.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.required = required;
+exports.optionalArg = optionalArg;
+exports.printJson = printJson;
+exports.wantsJson = wantsJson;
+/** Require a positional/option value or fail with a copy-pasteable recovery tip. */
+function required(value, label) {
+    if (!value)
+        throw new Error(`Missing ${label}.\n  Tip: find run ids with "cw run list" or create one with "cw quickstart"`);
+    return value;
+}
+/** Normalize an optional CLI arg to a trimmed non-empty string, else undefined. */
+function optionalArg(value) {
+    return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+/** Machine payload to stdout (stdout = data; never colored, never chrome). */
+function printJson(value) {
+    process.stdout.write(`${JSON.stringify(value, null, 2)}\n`);
+}
+/** True when the caller asked for JSON output (`--json` or `--format json`). */
+function wantsJson(options) {
+    return Boolean(options.json || options.format === "json");
+}

package/dist/cli/run-summary.js

@@ -0,0 +1,45 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.emitRunSummary = emitRunSummary;
+// Shared calm end-of-run summary helper, lifted out of command-surface.ts so the
+// `audit-run`/`quickstart` path (still in the dispatcher) AND the carved `run`
+// drive paths (src/cli/handlers/run.ts) emit ONE identical summary — no copy.
+// Stderr/human-side ONLY: stdout (the `--json` payload) stays byte-exact.
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const capability_core_1 = require("../capability-core");
+const reporter_1 = require("../reporter");
+/** Emit the calm end-of-run summary (stderr, TTY-gated inside the reporter): the COMPACT findings
+ *  table re-parsed from each completed worker's `cw:result`, the report path, where the per-worker
+ *  transcripts live, and — under `--full` — the report inline. Stderr/human-side ONLY: stdout (the
+ *  `--json` payload printed just before this) stays byte-exact. Shared by the quickstart and the
+ *  two `run --drive` paths so all three render an identical summary. */
+function emitRunSummary(runner, options, fields) {
+    // Anchor run reads to the run's OWN repo (a drive/quickstart may run cross-directory): the run
+    // dir is <repo>/.cw/runs/<id>/, holding each worker's transcript.md next to its result.md.
+    const runDir = typeof fields.statePath === "string" ? node_path_1.default.dirname(fields.statePath) : undefined;
+    const baseDir = runDir ? node_path_1.default.resolve(runDir, "..", "..", "..") : undefined;
+    const findings = (0, capability_core_1.collectRunFindings)(runner, fields.runId, baseDir);
+    // --full ALSO prints the report inline at run end (the compact table stays the default summary).
+    let fullReport;
+    if (options.full && fields.reportPath && node_fs_1.default.existsSync(fields.reportPath)) {
+        try {
+            fullReport = node_fs_1.default.readFileSync(fields.reportPath, "utf8");
+        }
+        catch { /* best-effort inline */ }
+    }
+    reporter_1.reporter.runSummary({
+        runId: fields.runId,
+        reportPath: fields.reportPath,
+        status: fields.status,
+        completedWorkers: fields.completedWorkers,
+        plannedWorkers: fields.plannedWorkers,
+        agentConfigured: fields.agentConfigured,
+        findings,
+        runDir,
+        fullReport
+    });
+}

package/dist/commit.js

@@ -80,11 +80,6 @@ function commitState(run, input) {
         candidateId: gate.candidateId,
         selectionId: gate.selectionId,
         evidence,
-        // Partial commit (v0.1.59): operator commits only specified tasks.
-        // Failed/pending tasks remain active for later retry. The verifier gate
-        // still applies per-task; partial is about scope, not about skipping gates.
-        partial: Array.isArray(options.partialTaskIds) && options.partialTaskIds.length > 0 || undefined,
-        partialTaskIds: options.partialTaskIds?.length ? options.partialTaskIds : undefined,
         acceptanceRationale: gate.rationale
             ? {
                 ...gate.rationale,

package/dist/execution-backend.js

@@ -34,18 +34,15 @@ exports.backendIds = backendIds;
 exports.isBackendId = isBackendId;
 exports.getBackendDescriptor = getBackendDescriptor;
 exports.resolveBackendSelection = resolveBackendSelection;
-exports.backendSelectionFrom = backendSelectionFrom;
 exports.requiredSandboxDimensions = requiredSandboxDimensions;
 exports.attestSandbox = attestSandbox;
 exports.probeBackend = probeBackend;
 exports.runBackend = runBackend;
 exports.createExecutionBackend = createExecutionBackend;
-exports.listExecutionBackends = listExecutionBackends;
 exports.backendListPayload = backendListPayload;
 exports.backendShowPayload = backendShowPayload;
 exports.backendProbePayload = backendProbePayload;
 exports.buildChildEnv = buildChildEnv;
-exports.clearProbeCache = clearProbeCache;
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
 const node_child_process_1 = require("node:child_process");
@@ -265,10 +262,6 @@ function resolveBackendSelection(requested, env = process.env) {
     }
     return { backendId: exports.DEFAULT_BACKEND_ID, source: "default" };
 }
-function backendSelectionFrom(args, env = process.env) {
-    const requested = (0, util_1.firstString)(args.backend, args.backendId, args.executionBackend);
-    return resolveBackendSelection(requested, env);
-}
 // ---------------------------------------------------------------------------
 // Sandbox dimension mapping + attestation. The sandbox profile is the contract.
 // ---------------------------------------------------------------------------
@@ -852,9 +845,6 @@ function createExecutionBackend(id) {
         run: (request) => runBackend({ ...request, backendId: id })
     };
 }
-function listExecutionBackends() {
-    return backendIds().map(createExecutionBackend);
-}
 // ---- inspection payloads (shared by CLI + MCP via the orchestrator) --------
 function backendListPayload() {
     return { schemaVersion: 1, default: exports.DEFAULT_BACKEND_ID, backends: listBackendDescriptors() };
@@ -916,4 +906,3 @@ function cachedProbeBackend(id, context) {
     _probeCache.set(key, { result, at: Date.now() });
     return result;
 }
-function clearProbeCache() { _probeCache.clear(); }

package/dist/mcp/tool-call.js

@@ -364,6 +364,8 @@ function callTool(name, args) {
             return (0, capability_core_1.runVerifyImport)(runner, String(args.runId || ""), args);
         case "cw_run_inspect_archive":
             return (0, capability_core_1.runInspectArchive)(runner, args);
+        case "cw_run_restore":
+            return (0, capability_core_1.runRestoreArchive)(runner, args);
         case "cw_report_verify_bundle":
             return (0, capability_core_1.runVerifyReportBundle)(runner, args);
         case "cw_report_bundle":

package/dist/mcp/tool-definitions.js

@@ -837,6 +837,14 @@ function toolDefinitions() {
             file: stringSchema("Alias for archive"),
             cwd: stringSchema("Invocation workspace")
         }),
+        capabilityTool("run.restore", "Fail-closed restore of a portable run archive in one step: integrity-inspect the bundle first (writes nothing), import it, then verify the imported run. Reports ok:true only when both inspect and verify pass; refuses (ok:false, exit 1) a tampered or unverifiable bundle, importing nothing. Peer of `cw run restore`.", {
+            archive: stringSchema("Archive path"),
+            path: stringSchema("Alias for archive"),
+            file: stringSchema("Alias for archive"),
+            target: stringSchema("Restore target repo directory"),
+            repo: stringSchema("Alias for target"),
+            cwd: stringSchema("Invocation workspace")
+        }),
         capabilityTool("report.verify-bundle", "Offline, self-contained verify of a portable run bundle: proves the archive bytes, the telemetry hash chain, the trust-audit chain, and (with the bundle's embedded public key) the ed25519 signatures — no source repo, no pre-existing .cw tree, no out-of-band key. Restores into a throwaway tmpdir and writes nothing. A forged or edited bundle fails it. Peer of `cw report verify-bundle`.", {
             archive: stringSchema("Bundle (.cwrun.json) path"),
             path: stringSchema("Alias for archive"),