cool-workflow 0.1.85 → 0.1.87

package/dist/capability-core.js

@@ -179,8 +179,8 @@ function compactOperatorStatus(status) {
 // functions so `cw <cmd> --json` is byte-identical to `cw_<tool>`. Each accepts
 // the raw CLI options OR the raw MCP arguments and normalizes them identically,
 // then calls the single RunRegistry method. The registry is constructed from the
-// same resolved cwd on both surfaces (CLI: --cwd|process.cwd(); MCP chdir'd to
-// args.cwd), so repo/home roots line up.
+// same resolved cwd on both surfaces (CLI: --cwd|process.cwd(); MCP passes a
+// resolved cwd and scopes the runner), so repo/home roots line up.
 function runRegistryFor(args, planner) {
     return new run_registry_1.RunRegistry(String(args.cwd || process.cwd()), planner);
 }
@@ -545,6 +545,8 @@ exports.QUICKSTART_DEFAULT_APP = "architecture-review";
 function quickstart(runner, args) {
     const appId = String(args.appId || args.app || args.workflowId || exports.QUICKSTART_DEFAULT_APP);
     const agentConfigured = Boolean((0, agent_config_1.resolveAgentConfig)(args).command || (0, agent_config_1.resolveAgentConfig)(args).endpoint);
+    if (isTrue(args.check))
+        return quickstartCheck(runner, appId, args, agentConfigured);
     // `--resume`: a discoverability flag over the existing continuation. With no
     // `--run`, advance exactly ONE step (reuse the `--once` path) and print a
     // copy-pasteable continue line; with `--run <id>`, continue that run to
@@ -623,7 +625,7 @@ function quickstart(runner, args) {
     }
     else if (result.status === "in-progress") {
         hint = resume
-            ? `one step advanced — continue: cw quickstart ${appId} --run ${result.runId} --resume`
+            ? `one step advanced — continue: cw quickstart ${appId} --run ${result.runId} --resume${wantsBundle ? " --bundle" : ""}`
             : `one step advanced (--once) — continue: cw quickstart ${appId} --run ${result.runId} --once`;
     }
     // --bundle on a run that didn't complete is a NO-OP, not silence: tell the operator
@@ -655,6 +657,132 @@ function quickstart(runner, args) {
         ...(bundle ? { bundle } : {})
     };
 }
+function quickstartCheck(runner, appId, args, agentConfigured) {
+    const base = invocationCwd(args);
+    const repoArg = optionalString(args.repo) || base;
+    const repo = node_path_1.default.resolve(base, repoArg);
+    const checks = [];
+    try {
+        runner.showApp(appId);
+        checks.push({ name: "app", status: "ok", detail: `Workflow app ${appId} is available.` });
+    }
+    catch (error) {
+        checks.push({
+            name: "app",
+            status: "blocked",
+            detail: `Workflow app ${appId} is not available.`,
+            fix: "Run `cw app list` and choose one of the listed app ids."
+        });
+    }
+    let repoReadable = false;
+    let repoStateWritable = false;
+    try {
+        const stat = node_fs_1.default.statSync(repo);
+        repoReadable = stat.isDirectory();
+        if (!repoReadable)
+            throw new Error("not a directory");
+        node_fs_1.default.accessSync(repo, node_fs_1.default.constants.R_OK);
+        checks.push({ name: "repo", status: "ok", detail: `Repository path is readable (${repo}).` });
+    }
+    catch (error) {
+        checks.push({
+            name: "repo",
+            status: "blocked",
+            detail: `Repository path is not readable (${repo}).`,
+            fix: "Pass --repo PATH for a readable repository directory."
+        });
+    }
+    try {
+        const cwDir = node_path_1.default.join(repo, ".cw");
+        node_fs_1.default.accessSync(node_fs_1.default.existsSync(cwDir) ? cwDir : repo, node_fs_1.default.constants.W_OK);
+        repoStateWritable = repoReadable;
+        checks.push({ name: "repo-state", status: "ok", detail: "Run state location is writable." });
+    }
+    catch (error) {
+        checks.push({
+            name: "repo-state",
+            status: "blocked",
+            detail: "Run state location is not writable.",
+            fix: "Use a writable repo, fix directory permissions, or pass --repo to a writable checkout."
+        });
+    }
+    if (optionalString(args.question)) {
+        checks.push({ name: "question", status: "ok", detail: "Question is set." });
+    }
+    else {
+        checks.push({
+            name: "question",
+            status: "blocked",
+            detail: "Question is missing.",
+            fix: "Pass --question TEXT."
+        });
+    }
+    if (agentConfigured) {
+        checks.push({ name: "agent", status: "ok", detail: "Agent backend is configured." });
+    }
+    else {
+        checks.push({
+            name: "agent",
+            status: "blocked",
+            detail: "No agent backend is configured.",
+            fix: "Pass --agent-command \"claude -p\", set $CW_AGENT_COMMAND, or use --agent-command builtin:claude."
+        });
+    }
+    if (flag(args.bundle) === true) {
+        const trustKey = optionalString(args["with-trust-key"] || args.withTrustKey || args.trustKey || args.pubkey) || process.env.CW_AGENT_ATTEST_PUBKEY;
+        if (trustKey) {
+            checks.push({ name: "bundle-trust-key", status: "ok", detail: "Bundle trust public key is configured." });
+        }
+        else if (Boolean(args["strict-signatures"] || args.strictSignatures || args.strictSigs)) {
+            checks.push({
+                name: "bundle-trust-key",
+                status: "blocked",
+                detail: "Strict signature verification needs a public trust key.",
+                fix: "Pass --with-trust-key PATH or set $CW_AGENT_ATTEST_PUBKEY."
+            });
+        }
+        else {
+            checks.push({
+                name: "bundle-trust-key",
+                status: "warn",
+                detail: "No public trust key is configured; unsigned or unkeyed bundles may verify with reduced signature proof.",
+                fix: "Pass --with-trust-key PATH to embed the public key."
+            });
+        }
+    }
+    const ok = checks.every((check) => check.status !== "blocked") && repoStateWritable;
+    return {
+        schemaVersion: 1,
+        mode: "check",
+        ok,
+        appId,
+        repo,
+        checks,
+        nextCommand: quickstartNextCommand(appId, repo, args)
+    };
+}
+function quickstartNextCommand(appId, repo, args) {
+    const parts = ["cw", "quickstart", shellWord(appId), "--repo", shellWord(repo)];
+    const question = optionalString(args.question);
+    if (question)
+        parts.push("--question", shellWord(question));
+    const command = optionalString(args.agentCommand || args["agent-command"]);
+    if (command)
+        parts.push("--agent-command", shellWord(command));
+    if (flag(args.bundle) === true)
+        parts.push("--bundle");
+    const trustKey = optionalString(args["with-trust-key"] || args.withTrustKey || args.trustKey);
+    if (trustKey)
+        parts.push("--with-trust-key", shellWord(trustKey));
+    if (Boolean(args["strict-signatures"] || args.strictSignatures || args.strictSigs))
+        parts.push("--strict-signatures");
+    return parts.join(" ");
+}
+function shellWord(value) {
+    if (/^[A-Za-z0-9_./:@%+=,-]+$/.test(value))
+        return value;
+    return `'${value.replace(/'/g, "'\\''")}'`;
+}
 /** Read-only, deterministic projection of the effective agent config (secret-stripped). */
 function backendAgentConfigShow(args) {
     return (0, agent_config_1.agentConfigShow)(args);

package/dist/capability-registry.js

@@ -31,11 +31,13 @@ exports.mcpCapabilityForId = mcpCapabilityForId;
 exports.mcpRequiredArgsForTool = mcpRequiredArgsForTool;
 exports.mcpToolDefinition = mcpToolDefinition;
 exports.declaredCliTokens = declaredCliTokens;
+exports.declaredCliHelpTokens = declaredCliHelpTokens;
 exports.requiresReason = requiresReason;
 exports.isPayloadProbeOptOut = isPayloadProbeOptOut;
 exports.payloadIdenticalCapabilities = payloadIdenticalCapabilities;
 exports.payloadProbeTargets = payloadProbeTargets;
 exports.deferredPayloadProbeCapabilities = deferredPayloadProbeCapabilities;
+exports.buildPayloadProbePlan = buildPayloadProbePlan;
 exports.payloadProbePlan = payloadProbePlan;
 exports.buildParityReport = buildParityReport;
 // ---------------------------------------------------------------------------
@@ -59,6 +61,30 @@ const BUILTIN_CAPABILITIES = [
         cli: { path: ["list"], jsonMode: "default" },
         mcp: { tool: "cw_list" }
     },
+    {
+        capability: "info",
+        summary: "Show what a workflow app does: title, description, inputs, sandbox, phases, and a runnable example.",
+        entry: "showApp",
+        surface: "cli-only",
+        cli: { path: ["info"], jsonMode: "flag" },
+        reason: "Human-focused workflow discovery tool (like Homebrew's `brew info`). MCP agents discover workflows via cw_list and cw_app_show tools."
+    },
+    {
+        capability: "search",
+        summary: "Search workflow apps by keyword (title, description, id).",
+        entry: "listApps",
+        surface: "cli-only",
+        cli: { path: ["search"], jsonMode: "flag" },
+        reason: "Human-focused workflow discovery (like Homebrew's `brew search`). MCP agents discover workflows via cw_list tool."
+    },
+    {
+        capability: "man",
+        summary: "Show a man page from docs/ (e.g. cw man release-tooling).",
+        entry: "n/a",
+        surface: "cli-only",
+        cli: { path: ["man"], jsonMode: "human" },
+        reason: "Human documentation viewer. MCP agents read docs/ directly via file tools."
+    },
     {
         capability: "doctor",
         summary: "Diagnose the host for setup problems (Node version, agent backend, agent binary on PATH, git, writable home/repo state) and print an actionable fix per check.",
@@ -351,7 +377,7 @@ const BUILTIN_CAPABILITIES = [
     { capability: "run.drive.step", summary: "Drive a run by delegating each worker to the agent backend (plan->dispatch->fulfill->accept->commit; --once for one step).", entry: "runDrive", surface: "both", cli: { path: ["run", "drive"], caseTokens: ["run", "drive"], jsonMode: "default" }, mcp: { tool: "cw_run_drive_step" }, payloadIdentical: false, reason: "Mutating: advances the run by spawning the external agent per worker and recording attested output — not a read probe. CLI (--drive/--step) and MCP route through the same drive() core." },
     {
         capability: "quickstart",
-        summary: "ONE-COMMAND quickstart: plan(app, default architecture-review) -> run --drive -> report in a single invocation (--preview for a read-only dry run; --bundle [--with-trust-key K] seals a completed run into a self-verified portable bundle).",
+        summary: "ONE-COMMAND quickstart: --check preflights without writes; otherwise plan(app, default architecture-review) -> run --drive -> report in a single invocation (--preview for a read-only dry run; --bundle [--with-trust-key K] seals a completed run into a self-verified portable bundle).",
         entry: "quickstart",
         surface: "cli-only",
         cli: { path: ["quickstart"], caseTokens: ["quickstart", "audit-run"], jsonMode: "default" },
@@ -458,34 +484,63 @@ const RUN_PAYLOAD_PROBE_CAPABILITIES = [
     "gc.plan",
     "gc.verify"
 ];
+const SCENARIO_PAYLOAD_PROBE_CAPABILITIES = [
+    "plan",
+    "app.show",
+    "app.validate",
+    "app.package",
+    "topology.show",
+    "topology.validate",
+    "topology.apply",
+    "topology.summary",
+    "topology.graph",
+    "summary.refresh",
+    "summary.show",
+    "sandbox.show",
+    "sandbox.validate",
+    "sandbox.choose",
+    "sandbox.resolve",
+    "approve",
+    "reject",
+    "comment.add",
+    "handoff",
+    "review.policy",
+    "worker.list",
+    "worker.show",
+    "worker.manifest",
+    "worker.output",
+    "worker.fail",
+    "worker.validate",
+    "candidate.list",
+    "candidate.show",
+    "candidate.register",
+    "candidate.score",
+    "candidate.rank",
+    "candidate.select",
+    "candidate.reject",
+    "feedback.list",
+    "feedback.show",
+    "feedback.collect",
+    "feedback.task",
+    "feedback.resolve",
+    "node.show",
+    "node.snapshot",
+    "node.diff",
+    "node.replay",
+    "node.replay.verify"
+];
 const PAYLOAD_PROBE_DEFERRED_GROUPS = [
     {
         reason: "Not safe for the deterministic bootstrap parity probe yet: this capability needs extra target ids/files, mutates durable state, depends on external state, or needs a dedicated fixture beyond cwd/runId.",
         capabilities: [
             "init",
-            "plan",
             "dispatch",
             "result",
-            "app.show",
-            "app.validate",
             "app.init",
-            "app.package",
             "app.run",
-            "node.show",
-            "node.snapshot",
-            "node.diff",
-            "node.replay",
-            "node.replay.verify",
             "migration.list",
             "migration.check",
             "migration.prove",
-            "topology.show",
-            "topology.validate",
-            "topology.apply",
-            "topology.summary",
-            "topology.graph",
-            "summary.refresh",
-            "summary.show",
             "multi-agent.run",
             "multi-agent.status",
             "multi-agent.step",
@@ -542,30 +597,8 @@ const PAYLOAD_PROBE_DEFERRED_GROUPS = [
             "audit.judge",
             "audit.attest",
             "audit.decision",
-            "sandbox.show",
-            "sandbox.validate",
-            "sandbox.choose",
-            "sandbox.resolve",
             "backend.show",
             "backend.probe",
-            "worker.list",
-            "worker.show",
-            "worker.manifest",
-            "worker.output",
-            "worker.fail",
-            "worker.validate",
-            "candidate.list",
-            "candidate.show",
-            "candidate.register",
-            "candidate.score",
-            "candidate.rank",
-            "candidate.select",
-            "candidate.reject",
-            "feedback.list",
-            "feedback.show",
-            "feedback.collect",
-            "feedback.task",
-            "feedback.resolve",
             "schedule.create",
             "schedule.list",
             "schedule.delete",
@@ -607,12 +640,7 @@ const PAYLOAD_PROBE_DEFERRED_GROUPS = [
             "sched.policy.show",
             "sched.policy.set",
             "telemetry.verify",
-            "history",
-            "approve",
-            "reject",
-            "comment.add",
-            "handoff",
-            "review.policy"
+            "history"
         ]
     }
 ];
@@ -665,6 +693,24 @@ function declaredCliTokens() {
     }
     return [...tokens].sort();
 }
+/** The top-level CLI commands that should be visible in `cw help`. Subcommands
+ *  are intentionally collapsed to their first token; aliases such as audit-run
+ *  stay visible. */
+function declaredCliHelpTokens() {
+    const tokens = new Set();
+    for (const cap of exports.CAPABILITY_REGISTRY) {
+        if (!cap.cli)
+            continue;
+        const subcommandTokens = new Set(cap.cli.path.slice(1));
+        tokens.add(cap.cli.path[0]);
+        for (const token of cap.cli.caseTokens || []) {
+            if (!subcommandTokens.has(token))
+                tokens.add(token);
+        }
+    }
+    tokens.delete("help");
+    return [...tokens].sort();
+}
 /** Whether a descriptor MUST carry a reason (surface-specific or divergent). */
 function requiresReason(cap) {
     if (cap.surface !== "both")
@@ -699,27 +745,31 @@ function payloadIdenticalCapabilities() {
 function payloadProbeTargets() {
     return [
         ...GLOBAL_PAYLOAD_PROBE_CAPABILITIES.map((capability) => ({ capability, kind: "global" })),
-        ...RUN_PAYLOAD_PROBE_CAPABILITIES.map((capability) => ({ capability, kind: "run" }))
+        ...RUN_PAYLOAD_PROBE_CAPABILITIES.map((capability) => ({ capability, kind: "run" })),
+        ...SCENARIO_PAYLOAD_PROBE_CAPABILITIES.map((capability) => ({ capability, kind: "scenario" }))
     ];
 }
 function deferredPayloadProbeCapabilities() {
     return PAYLOAD_PROBE_DEFERRED_GROUPS.flatMap((group) => group.capabilities.map((capability) => ({ capability, reason: group.reason })));
 }
-function payloadProbePlan() {
+function buildPayloadProbePlan(targets, deferred) {
     const candidateIds = new Set(payloadIdenticalCapabilities().map((cap) => cap.capability));
     const counts = new Map();
-    const classified = [...payloadProbeTargets().map((entry) => entry.capability), ...deferredPayloadProbeCapabilities().map((entry) => entry.capability)];
+    const classified = [...targets.map((entry) => entry.capability), ...deferred.map((entry) => entry.capability)];
     for (const capability of classified)
         counts.set(capability, (counts.get(capability) || 0) + 1);
     const classifiedIds = new Set(classified);
     return {
-        targets: payloadProbeTargets(),
-        deferred: deferredPayloadProbeCapabilities(),
+        targets,
+        deferred,
         unclassified: [...candidateIds].filter((capability) => !classifiedIds.has(capability)).sort(),
         duplicateClassifications: [...counts.entries()].filter(([, count]) => count > 1).map(([capability]) => capability).sort(),
         invalidClassifications: [...classifiedIds].filter((capability) => !candidateIds.has(capability)).sort()
     };
 }
+function payloadProbePlan() {
+    return buildPayloadProbePlan(payloadProbeTargets(), deferredPayloadProbeCapabilities());
+}
 function lintRegistry() {
     const issues = [];
     const seenCaps = new Set();
@@ -755,10 +805,14 @@ function buildParityReport(input) {
     const actualTools = new Set(input.mcpTools);
     const declaredTokens = new Set(declaredCliTokens());
     const actualTokens = new Set(input.cliTokens);
+    const declaredHelpTokens = new Set(declaredCliHelpTokens());
+    const actualHelpTokens = new Set(input.helpTokens || []);
     const missingMcpTools = [...declaredTools].filter((tool) => !actualTools.has(tool)).sort();
     const undeclaredMcpTools = [...actualTools].filter((tool) => !declaredTools.has(tool)).sort();
     const missingCliTokens = [...declaredTokens].filter((token) => !actualTokens.has(token)).sort();
     const undeclaredCliTokens = [...actualTokens].filter((token) => !declaredTokens.has(token)).sort();
+    const helpMissingCliTokens = input.helpTokens ? [...declaredHelpTokens].filter((token) => !actualHelpTokens.has(token)).sort() : [];
+    const helpUndeclaredCliTokens = input.helpTokens ? [...actualHelpTokens].filter((token) => !declaredHelpTokens.has(token)).sort() : [];
     const reasonlessExceptions = exports.CAPABILITY_REGISTRY.filter((cap) => requiresReason(cap) && !(cap.reason && cap.reason.trim()))
         .map((cap) => cap.capability)
         .sort();
@@ -768,6 +822,8 @@ function buildParityReport(input) {
         undeclaredMcpTools.length === 0 &&
         missingCliTokens.length === 0 &&
         undeclaredCliTokens.length === 0 &&
+        helpMissingCliTokens.length === 0 &&
+        helpUndeclaredCliTokens.length === 0 &&
         reasonlessExceptions.length === 0 &&
         payloadPlan.unclassified.length === 0 &&
         payloadPlan.duplicateClassifications.length === 0 &&
@@ -780,6 +836,8 @@ function buildParityReport(input) {
         undeclaredMcpTools,
         missingCliTokens,
         undeclaredCliTokens,
+        helpMissingCliTokens,
+        helpUndeclaredCliTokens,
         reasonlessExceptions,
         payloadProbeUnclassified: payloadPlan.unclassified,
         payloadProbeDuplicateClassifications: payloadPlan.duplicateClassifications,

package/dist/cli/command-surface.js

@@ -22,6 +22,8 @@ const multi_agent_eval_1 = require("../multi-agent-eval");
 const state_explosion_1 = require("../state-explosion");
 const evidence_reasoning_1 = require("../evidence-reasoning");
 const doctor_1 = require("../doctor");
+const orchestrator_2 = require("../orchestrator");
+const term_1 = require("../term");
 async function runCli(argv = process.argv.slice(2)) {
     const args = (0, orchestrator_1.parseArgv)(argv);
     const runner = new orchestrator_1.CoolWorkflowRunner({
@@ -37,10 +39,61 @@ async function runCli(argv = process.argv.slice(2)) {
         case "list":
             printJson(runner.listWorkflows());
             return;
+        case "search": {
+            const keyword = args.positionals.join(" ");
+            if (!keyword.trim())
+                throw new Error("Missing search keyword.\n  Tip: cw search architecture to find workflows about architecture.");
+            const apps = runner.listApps();
+            const lower = keyword.toLowerCase();
+            const results = apps.filter((a) => a.title.toLowerCase().includes(lower) || a.summary.toLowerCase().includes(lower) || a.id.toLowerCase().includes(lower)).map((a) => ({ id: a.id, title: a.title, summary: a.summary }));
+            if (wantsJson(args.options))
+                printJson(results);
+            else
+                process.stdout.write(`${(0, orchestrator_2.formatSearchResults)(keyword, results)}\n`);
+            return;
+        }
+        case "man": {
+            const [topic] = args.positionals;
+            if (!topic)
+                throw new Error("Missing topic.\n  Tip: cw man release-tooling for the release tooling manual.");
+            const docsDir = node_path_1.default.resolve(runner.pluginRoot, "docs");
+            const candidates = [
+                node_path_1.default.join(docsDir, `${topic}.7.md`),
+                node_path_1.default.join(docsDir, `${topic}.md`),
+                node_path_1.default.join(docsDir, `${topic}`)
+            ];
+            let found;
+            for (const c of candidates) {
+                try {
+                    if (node_fs_1.default.statSync(c).isFile()) {
+                        found = c;
+                        break;
+                    }
+                }
+                catch { /* keep looking */ }
+            }
+            if (!found)
+                throw new Error(`Man page not found: ${topic}.\n  Tip: cw list for workflow topics, or browse docs/ for manuals.`);
+            process.stdout.write(node_fs_1.default.readFileSync(found, "utf8"));
+            return;
+        }
+        case "info": {
+            const [appId] = args.positionals;
+            if (!appId)
+                throw new Error("Missing workflow app id.\n  Tip: list apps with \"cw list\", then \"cw info <id>\" for details");
+            const data = runner.showApp(appId);
+            if (wantsJson(args.options))
+                printJson(data);
+            else
+                process.stdout.write(`${(0, orchestrator_2.formatInfo)(appId, data)}\n`);
+            return;
+        }
         case "doctor": {
             const report = (0, doctor_1.runDoctor)(args.options, process.env, String(args.options.cwd || process.cwd()));
             if (wantsJson(args.options))
                 printJson(report);
+            else if (args.options.fix)
+                process.stdout.write(`${(0, doctor_1.formatDoctorFixes)(report)}\n`);
             else
                 process.stdout.write(`${(0, doctor_1.formatDoctorReport)(report)}\n`);
             if (!report.ok)
@@ -50,7 +103,7 @@ async function runCli(argv = process.argv.slice(2)) {
         case "init": {
             const [workflowId] = args.positionals;
             if (!workflowId)
-                throw new Error("Missing workflow id. Example: cw.js init my-workflow");
+                throw new Error("Missing workflow id.\n  Tip: create one with \"cw init my-workflow\" or list with \"cw list\"");
             printJson(runner.init(workflowId, args.options));
             return;
         }
@@ -93,6 +146,18 @@ async function runCli(argv = process.argv.slice(2)) {
             const runId = optionalArg(args.options.run) || optionalArg(args.options.runId);
             const qs = (0, capability_core_1.quickstart)(runner, { ...args.options, ...(appId ? { appId } : {}), ...(runId ? { runId } : {}) });
             printJson(qs);
+            const qr = qs;
+            if (typeof qr.runId === "string" && typeof qr.reportPath === "string") {
+                (0, term_1.printSuccessSummary)({
+                    runId: qr.runId,
+                    reportPath: qr.reportPath,
+                    status: String(qr.status || ""),
+                    bundle: Boolean(args.options.bundle)
+                });
+            }
+            if (qs.mode === "check" && qs.ok === false) {
+                process.exitCode = 1;
+            }
             // Fail closed: if --bundle produced an artifact that does not self-verify, exit
             // non-zero so `cw quickstart ... --bundle && send-to-client` cannot ship a report
             // whose bundle a client could not verify. Mirrors `report bundle`.
@@ -104,7 +169,7 @@ async function runCli(argv = process.argv.slice(2)) {
         case "plan": {
             const [workflowId] = args.positionals;
             if (!workflowId)
-                throw new Error("Missing workflow id. Example: cw.js plan architecture-review");
+                throw new Error("Missing workflow id.\n  Tip: plan an architecture review with \"cw plan architecture-review\"");
             printJson((0, capability_core_1.planSummary)(runner, workflowId, args.options));
             return;
         }
@@ -118,8 +183,10 @@ async function runCli(argv = process.argv.slice(2)) {
             }
             else if (wantsJson(args.options))
                 printJson(runner.status(args.positionals[0]));
-            else
-                process.stdout.write(`${(0, operator_ux_1.formatOperatorStatus)(runner.operatorStatus(args.positionals[0]))}\n`);
+            else {
+                const summary = runner.operatorStatus(args.positionals[0]);
+                process.stdout.write(`${(args.options.summary || args.options.brief ? (0, operator_ux_1.formatOperatorSummary)(summary) : (0, operator_ux_1.formatOperatorStatus)(summary))}\n`);
+            }
             return;
         case "next":
             printJson(runner.next(required(args.positionals[0], "run id"), args.options));
@@ -201,8 +268,10 @@ async function runCli(argv = process.argv.slice(2)) {
                 case "status":
                     if (wantsJson(args.options))
                         printJson(runner.operatorStatus(required(runId, "run id")));
-                    else
-                        process.stdout.write(`${(0, operator_ux_1.formatOperatorStatus)(runner.operatorStatus(required(runId, "run id")))}\n`);
+                    else {
+                        const summary = runner.operatorStatus(required(runId, "run id"));
+                        process.stdout.write(`${(args.options.summary || args.options.brief ? (0, operator_ux_1.formatOperatorSummary)(summary) : (0, operator_ux_1.formatOperatorStatus)(summary))}\n`);
+                    }
                     return;
                 case "report":
                     if (wantsJson(args.options))
@@ -1047,7 +1116,9 @@ async function runCli(argv = process.argv.slice(2)) {
                     driveArgs.runId = runId;
                 else
                     driveArgs.appId = target;
-                printJson((0, capability_core_1.runDrive)(runner, driveArgs));
+                const dr = (0, capability_core_1.runDrive)(runner, driveArgs);
+                printJson(dr);
+                (0, term_1.printSuccessSummary)({ runId: dr.runId, reportPath: dr.reportPath, status: dr.status });
                 return;
             }
             const registry = (0, capability_core_1.runRegistryFor)(args.options, runner);
@@ -1059,7 +1130,9 @@ async function runCli(argv = process.argv.slice(2)) {
                         const driveArgs = { ...args.options };
                         if (id)
                             driveArgs.runId = id;
-                        printJson((0, capability_core_1.runDrive)(runner, driveArgs));
+                        const dr = (0, capability_core_1.runDrive)(runner, driveArgs);
+                        printJson(dr);
+                        (0, term_1.printSuccessSummary)({ runId: dr.runId, reportPath: dr.reportPath, status: dr.status });
                         return;
                     }
                     printJson((0, capability_core_1.runDrivePreview)(runner, { ...args.options, runId: required(id, "run id") }));
@@ -1329,12 +1402,12 @@ async function runCli(argv = process.argv.slice(2)) {
             }
         }
         default:
-            throw new Error(`Unknown command: ${args.command}`);
+            throw new Error(`Unknown command: ${args.command}${((0, orchestrator_1.suggestCommand)(String(args.command || "")) ? `. Did you mean: ${(0, orchestrator_1.suggestCommand)(String(args.command))}?` : "")}`);
     }
 }
 function required(value, label) {
     if (!value)
-        throw new Error(`Missing ${label}. Run "cw.js help" for usage.`);
+        throw new Error(`Missing ${label}.\n  Tip: find run ids with "cw run list" or create one with "cw quickstart"`);
     return value;
 }
 function optionalArg(value) {

package/dist/cli.js

@@ -2,8 +2,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const command_surface_1 = require("./cli/command-surface");
+const term_1 = require("./term");
 (0, command_surface_1.runCli)(process.argv.slice(2)).catch((error) => {
     const message = error instanceof Error ? error.message : String(error);
-    process.stderr.write(`cw: ${message}\n`);
+    process.stderr.write(`${(0, term_1.bold)("cw:")} ${(0, term_1.red)(message)}\n`);
     process.exitCode = 1;
 });