cool-workflow 0.1.85 → 0.1.87

package/dist/orchestrator.js

@@ -36,8 +36,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CoolWorkflowRunner = void 0;
+exports.KNOWN_COMMANDS = exports.CoolWorkflowRunner = void 0;
 exports.parseArgv = parseArgv;
+exports.suggestCommand = suggestCommand;
+exports.formatSearchResults = formatSearchResults;
+exports.formatInfo = formatInfo;
 exports.formatHelp = formatHelp;
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
@@ -68,6 +71,7 @@ const feedbackOps = __importStar(require("./orchestrator/feedback-operations"));
 const topologyOps = __importStar(require("./orchestrator/topology-operations"));
 const lifecycleOps = __importStar(require("./orchestrator/lifecycle-operations"));
 const migrationOps = __importStar(require("./orchestrator/migration-operations"));
+const term_1 = require("./term");
 // CoolWorkflowRunner — the single FACADE both surfaces (cli.ts and the MCP server)
 // call through. It is deliberately WIDE but THIN: each method either
 //   (a) loads the run's durable state and delegates to a domain function in
@@ -178,7 +182,7 @@ class CoolWorkflowRunner {
             return {
                 valid: false,
                 appId: target,
-                appPath: node_path_1.default.resolve(target),
+                appPath: this.resolveFromBase(target),
                 issues
             };
         }
@@ -188,7 +192,7 @@ class CoolWorkflowRunner {
         if (!id)
             throw new Error("App id must include at least one letter or digit");
         const title = String(options.title || titleize(id));
-        const destinationDir = node_path_1.default.resolve(String(options.directory || options.output || node_path_1.default.join(this.appsDir, id)));
+        const destinationDir = this.resolveFromBase(String(options.directory || options.output || node_path_1.default.join(this.appsDir, id)));
         const manifestPath = node_path_1.default.join(destinationDir, "app.json");
         const entrypointPath = node_path_1.default.join(destinationDir, "workflow.js");
         if (!options.force && (node_fs_1.default.existsSync(manifestPath) || node_fs_1.default.existsSync(entrypointPath))) {
@@ -205,8 +209,7 @@ class CoolWorkflowRunner {
     }
     packageApp(appId, options = {}) {
         const record = this.loadWorkflowAppById(appId);
-        const destination = node_path_1.default.resolve(String(options.output ||
-            node_path_1.default.join(process.cwd(), ".cw", "packages", `${record.app.id}-${record.app.version}.cwapp.json`)));
+        const destination = this.resolveFromBase(String(options.output || node_path_1.default.join(".cw", "packages", `${record.app.id}-${record.app.version}.cwapp.json`)));
         node_fs_1.default.mkdirSync(node_path_1.default.dirname(destination), { recursive: true });
         (0, state_1.writeJson)(destination, {
             schemaVersion: 1,
@@ -221,7 +224,7 @@ class CoolWorkflowRunner {
         if (!id)
             throw new Error("Workflow id must include at least one letter or digit");
         const title = String(options.title || titleize(id));
-        const destination = node_path_1.default.resolve(String(options.output || node_path_1.default.join(this.workflowsDir, `${id}.workflow.js`)));
+        const destination = this.resolveFromBase(String(options.output || node_path_1.default.join(this.workflowsDir, `${id}.workflow.js`)));
         if (node_fs_1.default.existsSync(destination) && !options.force) {
             throw new Error(`Refusing to overwrite existing workflow: ${destination}`);
         }
@@ -248,7 +251,7 @@ class CoolWorkflowRunner {
         return lifecycleOps.dispatch(this.loadRun(runId), options);
     }
     recordResult(runId, taskId, resultPath, options = {}) {
-        return lifecycleOps.recordResult(this.loadRun(runId), taskId, resultPath, options);
+        return lifecycleOps.recordResult(this.loadRun(runId), taskId, this.resolveFromBase(resultPath), options);
     }
     listWorkers(runId, options = {}) {
         return (0, worker_isolation_1.listWorkerScopes)(this.loadRun(runId), {
@@ -272,13 +275,13 @@ class CoolWorkflowRunner {
         return (0, worker_isolation_1.writeWorkerManifest)(run, worker);
     }
     recordWorkerOutput(runId, workerId, resultPath, options = {}) {
-        return lifecycleOps.recordWorkerOutput(this.loadRun(runId), workerId, resultPath, options);
+        return lifecycleOps.recordWorkerOutput(this.loadRun(runId), workerId, this.resolveFromBase(resultPath), options);
     }
     recordWorkerFailure(runId, workerId, message, options = {}) {
         return lifecycleOps.recordWorkerFailure(this.loadRun(runId), workerId, message, options);
     }
     validateWorker(runId, workerId, targetPath) {
-        return (0, worker_isolation_1.validateWorkerBoundary)(this.loadRun(runId), workerId, targetPath ? { path: targetPath } : {});
+        return (0, worker_isolation_1.validateWorkerBoundary)(this.loadRun(runId), workerId, targetPath ? { path: this.resolveFromBase(targetPath) } : {});
     }
     // Audit domain — delegated to ./orchestrator/audit-operations (v0.1.40 P3
     // router pattern). The runner stays the routing surface; the logic lives in the
@@ -314,13 +317,13 @@ class CoolWorkflowRunner {
         return auditOps.recordAuditDecision(this.loadRun(runId), workerId, options);
     }
     listSandboxProfiles(options = {}) {
-        return (0, sandbox_profile_1.listBundledSandboxProfiles)((0, sandbox_profile_1.sandboxContextForValidation)(String(options.cwd || process.cwd())));
+        return (0, sandbox_profile_1.listBundledSandboxProfiles)((0, sandbox_profile_1.sandboxContextForValidation)(String(options.cwd || this.invocationCwd())));
     }
     showSandboxProfile(profileId, options = {}) {
-        return (0, sandbox_profile_1.showBundledSandboxProfile)(profileId, (0, sandbox_profile_1.sandboxContextForValidation)(String(options.cwd || process.cwd())));
+        return (0, sandbox_profile_1.showBundledSandboxProfile)(profileId, (0, sandbox_profile_1.sandboxContextForValidation)(String(options.cwd || this.invocationCwd())));
     }
     validateSandboxProfile(profileFile, options = {}) {
-        return (0, sandbox_profile_1.validateSandboxProfileFile)(profileFile, (0, sandbox_profile_1.sandboxContextForValidation)(String(options.cwd || process.cwd())));
+        return (0, sandbox_profile_1.validateSandboxProfileFile)(this.resolveFromBase(profileFile), (0, sandbox_profile_1.sandboxContextForValidation)(String(options.cwd || this.invocationCwd())));
     }
     listBackends(options = {}) {
         void options;
@@ -331,7 +334,7 @@ class CoolWorkflowRunner {
         return (0, execution_backend_1.backendShowPayload)(backendId);
     }
     probeBackend(backendId, options = {}) {
-        return (0, execution_backend_1.backendProbePayload)(backendId, { cwd: String(options.cwd || process.cwd()) });
+        return (0, execution_backend_1.backendProbePayload)(backendId, { cwd: String(options.cwd || this.invocationCwd()) });
     }
     // Candidate domain — delegated to ./orchestrator/candidate-operations.
     listCandidates(runId, options = {}) {
@@ -716,6 +719,12 @@ class CoolWorkflowRunner {
     loadRun(runId) {
         return (0, state_1.loadRunFromCwd)(runId, this.baseDir);
     }
+    invocationCwd() {
+        return this.baseDir || process.cwd();
+    }
+    resolveFromBase(target) {
+        return node_path_1.default.resolve(this.invocationCwd(), target);
+    }
     loadWorkflowAppById(appId) {
         const record = this.loadWorkflowApps().find((candidate) => candidate.app.id === appId);
         if (!record)
@@ -725,7 +734,7 @@ class CoolWorkflowRunner {
     loadWorkflowAppTarget(target) {
         if (!target)
             throw new Error("Missing workflow app path or id");
-        const resolved = node_path_1.default.resolve(target);
+        const resolved = this.resolveFromBase(target);
         if (node_fs_1.default.existsSync(resolved)) {
             const stat = node_fs_1.default.statSync(resolved);
             if (stat.isDirectory())
@@ -811,83 +820,177 @@ function parseArgv(argv) {
     }
     return { command, positionals, options };
 }
+/** All known top-level CW commands. Used for "did you mean?" suggestions. */
+exports.KNOWN_COMMANDS = new Set([
+    "help", "list", "doctor", "info", "search", "man", "init", "quickstart", "plan", "status", "next",
+    "dispatch", "result", "state", "commit", "report", "app", "sandbox",
+    "backend", "contract", "node", "feedback", "worker", "audit", "candidate",
+    "review", "loop", "schedule", "routine", "registry", "run", "queue",
+    "history", "audit-run", "multi-agent", "topology", "summary", "blackboard",
+    "coordinator", "metrics", "operator", "sched", "gc", "telemetry",
+    "migration", "demo", "workbench", "approve", "reject", "comment", "handoff",
+    "graph", "eval"
+]);
+/** Levenshtein distance between two short strings. */
+function levenshtein(a, b) {
+    const m = a.length;
+    const n = b.length;
+    let prev = Array.from({ length: n + 1 }, (_, j) => j);
+    let curr = new Array(n + 1);
+    for (let i = 1; i <= m; i++) {
+        curr[0] = i;
+        for (let j = 1; j <= n; j++) {
+            curr[j] = Math.min(prev[j] + 1, curr[j - 1] + 1, prev[j - 1] + (a[i - 1] === b[j - 1] ? 0 : 1));
+        }
+        [prev, curr] = [curr, prev];
+    }
+    return prev[n];
+}
+/** Suggest the closest known command for a typo. Returns undefined if no match
+ *  within half the length of the input (avoiding wild guesses on short strings). */
+function suggestCommand(input) {
+    if (!input || input.length < 2)
+        return undefined;
+    const lower = input.toLowerCase();
+    let best = "";
+    let bestDist = Infinity;
+    for (const cmd of exports.KNOWN_COMMANDS) {
+        const dist = levenshtein(lower, cmd);
+        if (dist < bestDist) {
+            best = cmd;
+            bestDist = dist;
+        }
+    }
+    // Threshold: distance must be <= half the input length AND <= 3
+    if (bestDist <= 3 && bestDist <= lower.length / 2)
+        return best;
+    return undefined;
+}
+function formatSearchResults(keyword, results) {
+    if (!results.length)
+        return `No workflows matched "${keyword}".\n  Tip: cw list for all available workflows.`;
+    return [
+        (0, term_1.bold)(`${results.length} workflow${results.length !== 1 ? "s" : ""} matching "${keyword}"`),
+        ...results.map((r) => `  ${r.id} — ${r.title}\n    ${(0, term_1.dim)(r.summary.slice(0, 120))}${r.summary.length > 120 ? "…" : ""}`),
+        "",
+        (0, term_1.dim)("Use cw info <id> for full details.")
+    ].join("\n");
+}
+function formatInfo(appId, data) {
+    const app = (data.app || {});
+    const inputs = (Array.isArray(data.inputs) ? data.inputs : []);
+    const phases = (Array.isArray(data.phases) ? data.phases : []);
+    const lines = [(0, term_1.bold)(`cw info ${appId}`)];
+    if (data.title)
+        lines.push(`  Title: ${data.title}`);
+    if (data.version)
+        lines.push(`  Version: ${data.version}`);
+    if (data.summary)
+        lines.push(`  Summary: ${data.summary}`);
+    if (data.author)
+        lines.push(`  Author: ${typeof data.author === "object" ? data.author.name : data.author}`);
+    if (data.compatible !== undefined)
+        lines.push(`  Compatible: ${data.compatible ? "yes" : "no"}`);
+    if (inputs.length > 0) {
+        lines.push("  Inputs:");
+        for (const input of inputs) {
+            const name = input.name || "";
+            const type = input.type || "string";
+            const required = input.required ? ", required" : "";
+            const def = input.default ? `, default: ${input.default}` : "";
+            const desc = input.description ? ` — ${input.description}` : "";
+            lines.push(`    - ${name} (${type}${required}${def})${desc}`);
+        }
+    }
+    if (Array.isArray(data.sandboxProfiles) && data.sandboxProfiles.length > 0) {
+        lines.push(`  Sandbox: ${data.sandboxProfiles.join(", ")}`);
+    }
+    const taskCount = data.taskCount || 0;
+    if (phases.length > 0) {
+        lines.push(`  Phases: ${phases.length} phase${phases.length !== 1 ? "s" : ""}, ${taskCount} task${taskCount !== 1 ? "s" : ""}`);
+    }
+    lines.push(`  Run: cw quickstart ${appId} --repo . --question "..."`);
+    return lines.join("\n");
+}
 function formatHelp() {
     return [
-        "Cool Workflow",
+        (0, term_1.bold)("Cool Workflow"),
+        "",
+        "  Quick start (one command — plan → drive → report):",
+        "    cw quickstart [app] --repo . --question \"...\" --agent-command builtin:claude",
+        "      (--preview for a dry run without an agent; --bundle for a portable sealed report)",
+        "",
+        (0, term_1.bold)("Getting Started"),
+        "  list                          List available workflow apps",
+        "  search <keyword>              Search workflows by title or description",
+        "  info <app-id> [--json]         Show what a workflow app does and how to run it",
+        "  doctor [--json] [--onramp] [--fix]  Check setup (--fix for consolidated fix commands)",
+        "  init <id> [--title T]         Create a new workflow app",
+        "  quickstart [app] [...]        Plan → drive → report in one command",
+        "  demo tamper|bundle            Prove trust checks work (30s, no agent needed)",
+        "  man <topic>                   Show a man page (e.g. cw man release-tooling)",
+        "",
+        (0, term_1.bold)("Run Management"),
+        "  plan <id> [--repo P] [--question Q]   Create a new run plan",
+        "  quickstart|audit-run [app] [...]       Plan → drive → report in one command",
+        "  status <run-id> [--json] [--brief]    Show run status (--brief for compact summary)",
+        "  next <run-id> [--limit N]             Show pending dispatch tasks",
+        "  dispatch <run-id> [--limit N]         Dispatch tasks to workers",
+        "  result <run-id> <task-id> <file>      Record a task result",
+        "  state check <run-id> [--write]        Validate run state",
+        "  commit <run-id> <mode> [...]          Record a gated commit",
+        "  report <run-id> [--show|--summary]    Show the report (or bundle/verify-bundle)",
+        "  graph <run-id> [--json]               Show operator graph",
+        "",
+        (0, term_1.bold)("Inspection & Diagnostics"),
+        "  operator status|report <run-id> [--json]   Human-friendly operator panel",
+        "  metrics show|summary <run-id> [--json]     Cost and usage metrics",
+        "  telemetry verify <run-id> [--pubkey P]     Verify tamper-evident telemetry",
+        "  migration list|check|prove [target]        Schema migration tools",
+        "  gc plan|run|verify [run-id]                Garbage collection",
+        "",
+        (0, term_1.bold)("Audit & Trust"),
+        "  audit summary|worker|provenance|multi-agent|... <run-id>   Trust audit operations",
+        "  candidate list|register|score|rank|select|reject <run-id>  Candidate management",
+        "  node list|show|graph|snapshot|diff|replay|verify <run-id>  State-node inspection",
+        "  eval snapshot|replay|compare|score|gate|report             Eval/replay harness",
+        "",
+        (0, term_1.bold)("Multi‑Agent & Collaboration"),
+        "  multi-agent run|status|step|blackboard|score|... <run-id>   Multi-agent coordination",
+        "  topology list|show|validate|apply|summary|graph              Topology management",
+        "  blackboard summary|graph|resolve|topic|message|... <run-id>  Blackboard workspace",
+        "  coordinator summary|decision <run-id>                        Coordinator interface",
+        "  summary refresh|show <run-id>                                State explosion summaries",
+        "  approve|reject|comment <kind> <run-id> <id> [--reason T]    Team approval actions",
+        "  handoff <kind> <run-id> <id> [--to ROLE]                    Team handoff",
+        "  review status|policy <run-id> [--json]                      Review status",
+        "",
+        (0, term_1.bold)("Run Registry & Scheduling"),
+        "  run search|list|show|resume|archive|export|import <id>   Cross-repo run management",
+        "  registry refresh|show [--scope repo|home] [--json]       Run registry index",
+        "  queue add|list|drain|show [queue-id]                     Work queue operations",
+        "  history [--scope repo|home] [--json]                     Run history",
+        "  schedule create|list|due|complete|...                    Scheduled tasks",
+        "  routine create|fire|list|events|delete                   Event-driven triggers",
+        "  sched plan|lease|release|complete|...                    Lease-based scheduling",
+        "  loop --prompt T [--interval-minutes N]                   Continuous loop runner",
         "",
-        "Quick start (ONE command — plan -> drive -> report):",
-        "  quickstart [architecture-review] --repo PATH --question TEXT --agent-command \"claude -p\"",
-        "    (delegates each worker to YOUR configured agent backend; --preview for a dry run)",
+        (0, term_1.bold)("Developer & Workspace"),
+        "  app list|show|validate|init|package|run [id|path]    Workflow app management",
+        "  sandbox list|show|validate|choose|resolve [id]       Sandbox profiles",
+        "  backend list|show|probe [id]                         Agent execution backends",
+        "  contract show <run-id> [id]                          Run contract view",
+        "  worker list|summary|show|manifest|output|... <id>    Worker operations",
+        "  feedback list|show|summary|collect|task|resolve <id> Feedback loop",
+        "  workbench serve [--port N] | view <run-id>           Optional localhost workbench",
         "",
-        "Commands:",
-        "  list",
-        "  doctor [--json]   (check your setup: Node, agent backend, git, writable state)",
-        "  init <workflow-id> [--title TEXT] [--output PATH]",
-        "  quickstart [app-id] [--repo PATH] [--question TEXT] [--agent-command CMD] [--once] [--preview]",
-        "  plan <workflow-id> [--repo PATH] [--question TEXT] [--invariant TEXT]",
-        "  status <run-id> [--json|--format json]",
-        "  next <run-id> [--limit N]",
-        "  graph <run-id> [--json]",
-        "  dispatch <run-id> [--limit N] [--sandbox PROFILE] [--backend node|bun|shell|container|remote|ci]",
-        "  result <run-id> <task-id> <result-file>",
-        "  state check <run-id> [--state PATH] [--write]",
-        "  commit <run-id> --verifier <node-id> [--reason TEXT]",
-        "  commit <run-id> --candidate <candidate-id> [--reason TEXT]",
-        "  commit <run-id> --selection <selection-id> [--reason TEXT]",
-        "  commit <run-id> --allow-unverified-checkpoint [--reason TEXT]",
-        "  commit summary <run-id> [--json]",
-        "  report <run-id> [--show|--summary]",
-        "  app list|show|validate|init|package",
-        "  sandbox list|show|validate",
-        "  backend list|show|probe [backend-id]",
-        "  contract show <run-id> [contract-id]",
-        "  node list|show|graph <run-id>",
-        "  feedback list|summary|show|collect|task|resolve <run-id>",
-        "  worker list|summary|show|manifest|output|fail|validate <run-id>",
-        "  audit summary <run-id>",
-        "  audit worker <run-id> <worker-id>",
-        "  audit provenance <run-id> [--worker ID|--candidate ID|--commit ID]",
-        "  audit multi-agent <run-id> [--json]",
-        "  audit policy <run-id> [--json]",
-        "  audit role <run-id> <role-id> [--json]",
-        "  audit blackboard <run-id> [--json]",
-        "  audit judge <run-id> [--json]",
-        "  audit attest <run-id> [--worker ID] [--hostEnforced true] [--env NAME]",
-        "  audit decision <run-id> <worker-id> [--path PATH|--command CMD|--network TARGET|--env NAME]",
-        "  candidate list|summary|register|score|rank|select|reject <run-id>",
-        "  eval snapshot|replay|compare|score|gate|report",
-        "  summary refresh|show <run-id> [--json]",
-        "  blackboard summary|summarize|graph|resolve <run-id>",
-        "  blackboard topic create <run-id> --id <topic-id> --title TEXT",
-        "  blackboard message post|list <run-id>",
-        "  blackboard context put <run-id>",
-        "  blackboard artifact add|list <run-id>",
-        "  blackboard snapshot <run-id>",
-        "  coordinator summary <run-id>",
-        "  coordinator decision <run-id> --kind KIND --outcome OUTCOME --reason TEXT",
-        "  multi-agent run|status|step|blackboard|score|select|summary|summarize|graph|dependencies|failures|evidence <run-id>",
-        "  multi-agent graph <run-id> --view full|compact|critical-path|failures|evidence|trust|topology|blackboard|candidate|commit-gate [--focus ID] [--depth N]",
-        "  topology list|show|validate|apply|summary|graph",
-        "  schedule create|list|due|complete|pause|resume|run-now|history|daemon|delete",
-        "  routine create|fire|list|events|delete",
-        "  registry refresh|show [--scope repo|home] [--json]",
-        "  run search|list|show|resume|archive|rerun|export|import|verify-import [run-id|archive] [--scope repo|home] [--json]",
-        "  queue add|list|drain|show [queue-id] [--repo PATH] [--priority N]",
-        "  history [--scope repo|home] [--app ID] [--status STATE] [--json]",
-        "  audit-run <app-id> [--repo PATH] [--question TEXT] [--agent-command CMD]",
-        "  metrics show|summary <run-id> [--scope repo|home] [--json]",
-        "  telemetry verify <run-id> [--pubkey PEM|PATH] [--json]",
-        "  gc plan|run|verify [run-id] [--json]",
-        "  sched plan|lease|release|complete|reclaim|reset|policy [--json]",
-        "  migration list|check|prove [target] [--json]",
-        "  operator status|report <run-id> [--json]",
-        "  review status|policy <run-id> [--json]",
-        "  approve|reject|comment <kind> <run-id> <target-id> [--reason TEXT]",
-        "  handoff <kind> <run-id> <target-id> [--to ROLE]",
-        "  loop --prompt TEXT [--interval-minutes N]",
-        "  demo tamper",
-        "  workbench view <run-id> [--json]",
-        "  workbench serve [--port N] [--scope repo|home] [--once|--json]",
+        (0, term_1.bold)("Common Flags"),
+        "  --json, --format json     Machine-readable JSON output",
+        "  --repo PATH               Target repository path",
+        "  --question TEXT           The task or question to answer",
+        "  --agent-command CMD       Agent backend (e.g. builtin:claude, builtin:codex)",
+        "  --scope repo|home         Scope for cross-repo operations",
+        "  --cwd PATH                Working directory override",
         ""
     ].join("\n");
 }

package/dist/term.js

@@ -0,0 +1,93 @@
+"use strict";
+// src/term.ts — zero-dependency terminal styling.
+//
+// Provides TTY-gated ANSI formatting for human-readable output. When output is
+// piped (non-TTY), styled calls return plain text. This keeps data channels
+// (stdout) and diagnostics (stderr) clean — never adds escape codes to pipes.
+//
+// Used by: doctor, help, error messages, status summaries.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bold = bold;
+exports.dim = dim;
+exports.green = green;
+exports.yellow = yellow;
+exports.red = red;
+exports.cyan = cyan;
+exports.doctorGlyph = doctorGlyph;
+exports.cwLabel = cwLabel;
+exports.indent = indent;
+exports.printSuccessSummary = printSuccessSummary;
+function isTTY(stream = process.stderr) {
+    return Boolean(stream.isTTY);
+}
+// ---- ansi codes ----
+const ansi = {
+    reset: "\x1b[0m",
+    bold: "\x1b[1m",
+    dim: "\x1b[2m",
+    green: "\x1b[32m",
+    yellow: "\x1b[33m",
+    red: "\x1b[31m",
+    cyan: "\x1b[36m",
+};
+// ---- styled text ----
+function style(code, text, stream) {
+    if (!isTTY(stream))
+        return text;
+    return `${code}${text}${ansi.reset}`;
+}
+function bold(text, stream) {
+    return style(ansi.bold, text, stream);
+}
+function dim(text, stream) {
+    return style(ansi.dim, text, stream);
+}
+function green(text, stream) {
+    return style(ansi.green, text, stream);
+}
+function yellow(text, stream) {
+    return style(ansi.yellow, text, stream);
+}
+function red(text, stream) {
+    return style(ansi.red, text, stream);
+}
+function cyan(text, stream) {
+    return style(ansi.cyan, text, stream);
+}
+// ---- semantic helpers ----
+/** Returns the styled glyph + label for a doctor check severity. */
+function doctorGlyph(status, stream) {
+    const glyph = { ok: "✓", warn: "!", fail: "✗" };
+    const color = {
+        ok: green,
+        warn: yellow,
+        fail: red,
+    };
+    return color[status](`${glyph[status]}`, stream);
+}
+/** "cw:" prefix with bold and optional color. */
+function cwLabel(stream) {
+    return bold("cw:", stream);
+}
+/** Render a multi-line block with consistent 2-space indentation. */
+function indent(text, spaces = 2) {
+    const prefix = " ".repeat(spaces);
+    return text.split("\n").map((line) => `${prefix}${line}`).join("\n");
+}
+/** Print a success summary to stderr (TTY-gated). Shows the report path and a
+ *  suggested next command. Pipe-friendly: silent when stderr is not a TTY. */
+function printSuccessSummary(fields, stream) {
+    if (!isTTY(stream))
+        return;
+    const s = stream || process.stderr;
+    s.write(`\n${green("✓")} Report: ${fields.reportPath}\n`);
+    if (fields.status === "complete") {
+        s.write(`  Next: cw status ${fields.runId} --brief\n`);
+        if (fields.bundle !== false) {
+            s.write(`  Bundle: cw report bundle ${fields.runId}\n`);
+        }
+    }
+    else {
+        s.write(`  ${yellow("!")} Status: ${fields.status}. Next: cw status ${fields.runId}\n`);
+    }
+}

package/dist/version.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MIN_SUPPORTED_RUN_STATE_SCHEMA_VERSION = exports.LEGACY_RUN_STATE_SCHEMA_VERSION = exports.CURRENT_RUN_STATE_SCHEMA_VERSION = exports.WORKFLOW_APP_SCHEMA_VERSION = exports.CURRENT_COOL_WORKFLOW_VERSION = void 0;
-exports.CURRENT_COOL_WORKFLOW_VERSION = "0.1.85";
+exports.CURRENT_COOL_WORKFLOW_VERSION = "0.1.87";
 exports.WORKFLOW_APP_SCHEMA_VERSION = 1;
 exports.CURRENT_RUN_STATE_SCHEMA_VERSION = 1;
 exports.LEGACY_RUN_STATE_SCHEMA_VERSION = 0;

package/dist/workbench-host.js

@@ -99,14 +99,7 @@ class WorkbenchHost {
             }
             const runMatch = /^\/api\/run\/([^/]+)$/.exec(route);
             if (runMatch) {
-                const previousCwd = process.cwd();
-                process.chdir(this.cwd);
-                try {
-                    return this.send(res, 200, (0, workbench_1.buildWorkbenchRunView)(this.runner, runMatch[1]));
-                }
-                finally {
-                    process.chdir(previousCwd);
-                }
+                return this.send(res, 200, (0, workbench_1.buildWorkbenchRunView)(this.runner.withBaseDir(this.cwd), runMatch[1]));
             }
             this.send(res, 404, { error: `no such read-only view: ${route}` });
         }

package/docs/agent-delegation-drive.7.md

@@ -128,6 +128,7 @@ node dist/cli.js backend agent config            # show the effective config (se
 node dist/cli.js backend probe agent --json      # ready iff configured, else unverified
 
 # drive a real repo end-to-end (zero hand-written result.md)
+node dist/cli.js quickstart architecture-review --check --repo /path/to/repo --question "Is the design sound?" --agent-command "node $(pwd)/scripts/agents/claude-p-agent.js {{input}} {{result}}"
 node dist/cli.js run architecture-review --drive --repo /path/to/repo --question "Is the design sound?"
 node dist/cli.js run architecture-review --drive --once --repo /path/to/repo --question "..."   # one step
 node dist/cli.js run drive <run-id> --json       # read-only preview of the next step
@@ -135,12 +136,22 @@ node dist/cli.js run drive <run-id> --json       # read-only preview of the next
 # quickstart --resume: a guided stop-then-resume a newcomer can WITNESS in <5 min
 node dist/cli.js quickstart --resume --repo /path/to/repo --question "..."   # advances ONE step, prints a continue line
 node dist/cli.js quickstart --run <run-id> --resume                          # continues that run to completion
+node dist/cli.js quickstart --run <run-id> --resume --bundle                  # continues, then seals a completed run
 ```
 
+`quickstart --check` is a zero-write preflight. It does not make a run, write
+`.cw/`, call the agent, write a report, or commit. It checks the app id, repo,
+question, agent config, and (with `--bundle`) the trust-key shape, then gives the
+next command to run. A blocked check exits non-zero, so scripts may use it as a
+gate before a real run.
+
 `quickstart --resume` with no `--run` drives a single step and prints a
 copy-pasteable `cw quickstart --run <id> --resume` continue line; run it again with
 the `--run <id>` to finish. The continuing invocation echoes `resumedFrom: <id>`.
 Bare `quickstart` (no `--resume`) is unchanged — it drives straight to the end.
+When `--bundle` is present on the fresh resume step, no bundle is sealed until
+the run is complete; the continue line keeps `--bundle` so the second command
+finishes and seals the report.
 
 For faster first results, use the opt-in fast app in place of changing the full
 review contract:
@@ -171,9 +182,15 @@ an Assess cache hit. A cache hit still goes through `recordWorkerOutput`
 validation; a corrupt cached result parks/fails closed rather than spawning a
 quiet fallback.
 
+Verify and Verdict also get the source-context instruction so they do not have to
+start by scanning the repo again. They are not result-cached; they still have to
+cite evidence and make the final check from the accepted Map and Assess work.
+
 `--metrics` is diagnostic and opt-in. It adds elapsed milliseconds, step counts,
-agent-spawn counts, and `result-cache` hit counts to the wrapper JSON payload;
-without it, the wrapper's default output shape stays unchanged.
+agent-spawn counts, `result-cache` hit counts, source-context bytes/digest, and
+one row per driven task with phase, task id, elapsed time, and spawn/cache state
+to the wrapper JSON payload; without it, the wrapper's default output shape stays
+unchanged.
 
 `{{manifest}}`, `{{input}}`, `{{result}}`, `{{workerDir}}`, `{{model}}`, and
 `{{prompt}}` are put into DISCRETE argv elements (never a shell-interpreted
@@ -187,13 +204,15 @@ A drive can show the agent's activity live, without touching the evidence
 contract, when the operator opts in with `CW_AGENT_STREAM=1`:
 
 - **Default stays buffered.** Without `CW_AGENT_STREAM=1`, the bundled wrapper
-  keeps the legacy `--output-format json` path and forwards claude's JSON stdout
-  word for word after writing `result.md`.
+  keeps the buffered path and writes one JSON report to stdout after writing
+  `result.md`.
 - **The opt-in wrapper renders; stderr only.** With `CW_AGENT_STREAM=1`, the
-  bundled wrapper runs claude in `--output-format stream-json` and renders a short
-  human trace (tool uses, assistant text, per-turn summaries) to its
-  **stderr** — diagnostics, never data. It builds the single
-  `{model, usage, result}` object for stdout again only on that opt-in path.
+  bundled Claude wrapper runs claude in `--output-format stream-json`, and the
+  bundled Codex wrapper runs `codex exec --json --output-last-message`.
+  Each wrapper renders a short human trace (tool uses, assistant text, per-turn
+  summaries where present) to its **stderr** — diagnostics, never data. It builds
+  the single `{model, usage, result}` object for stdout after the final answer is
+  captured.
 - **Core forwards, never parses.** `runAgentProcess` passes the agent child's
   stderr straight through to the operator's terminal (`stdio` inherit) only when
   `CW_AGENT_STREAM=1`, CW's own stderr is a TTY, and `CW_NO_STREAM` is not set.
@@ -202,6 +221,18 @@ contract, when the operator opts in with `CW_AGENT_STREAM=1`:
 - **Determinism intact.** The backend evidence triple hashes stdout only, so
   the live stderr stream never changes recorded evidence or replay.
 
+The built-in templates are:
+
+```text
+--agent-command builtin:claude
+--agent-command builtin:codex
+```
+
+Gemini, OpenCode, DeepSeek, and GLM stay as external agent commands or HTTP
+endpoints until their stream format is proven by a local, deterministic wrapper
+smoke. DeepSeek and GLM are best reached through OpenCode or an HTTP agent
+adapter first; CW still imports no model SDK.
+
 ## Compatibility
 
 Agent Delegation Drive comes in first in CW v0.1.38. Adding the `agent` row leaves
@@ -272,3 +303,9 @@ Loaders fail closed on corrupt state; store writes are made safe under more than
 No other change to this page in v0.1.84.
 
 0.1.85
+
+0.1.86
+
+## 0.1.87 (v0.1.87)
+
+npm test parallel, 4-vendor wrappers (Claude/Codex/Gemini/OpenCode), Homebrew-style CLI UX (colors/did-you-mean/categorized help/error tips/cw info/cw search/cw man/doctor --fix), post-success summaries, agent execution timing