cool-workflow 0.2.2 → 0.2.3

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "cool-workflow",
   "description": "A workflow control plane and run-time you are able to check: it sends out jobs in TypeScript, makes certain of work against facts before it goes through, puts state into fixed records, orders jobs by time, runs jobs again and again, gets a group of agents to do their parts together, and talks MCP. It gives the doing of the work to outside agents — it never runs the models itself.",
-  "version": "0.2.2",
+  "version": "0.2.3",
   "author": {
     "name": "COOLWHITE LLC"
   },

package/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "cool-workflow",
-  "version": "0.2.2",
+  "version": "0.2.3",
   "description": "A workflow control plane and run-time you are able to check: it sends out jobs in TypeScript, makes certain of work against facts before it goes through, puts state into fixed records, orders jobs by time, runs jobs again and again, gets a group of agents to do their parts together, and talks MCP. It gives the doing of the work to outside agents — it never runs the models itself.",
   "author": {
     "name": "COOLWHITE LLC"

package/apps/architecture-review/app.json

@@ -3,7 +3,7 @@
   "id": "architecture-review",
   "title": "Architecture Review",
   "summary": "Map a repository architecture, assess risks, verify important findings, and synthesize an evidence-backed verdict.",
-  "version": "0.2.2",
+  "version": "0.2.3",
   "author": "COOLWHITE LLC",
   "inputs": [
     {

package/apps/architecture-review-fast/app.json

@@ -3,7 +3,7 @@
   "id": "architecture-review-fast",
   "title": "Architecture Review Fast",
   "summary": "Run a shorter architecture review with parallel map and assess phases for faster first results.",
-  "version": "0.2.2",
+  "version": "0.2.3",
   "author": "COOLWHITE LLC",
   "inputs": [
     {

package/apps/end-to-end-golden-path/app.json

@@ -3,7 +3,7 @@
   "id": "end-to-end-golden-path",
   "title": "End-to-End Golden Path",
   "summary": "Deterministic one-worker workflow app for proving the CW integration chain.",
-  "version": "0.2.2",
+  "version": "0.2.3",
   "author": "COOLWHITE LLC",
   "inputs": [
     {

package/apps/pr-review-fix-ci/app.json

@@ -3,7 +3,7 @@
   "id": "pr-review-fix-ci",
   "title": "PR Review Fix CI",
   "summary": "Review a pull request or branch, inspect CI failures, diagnose actionable issues, optionally patch, verify, and summarize with evidence.",
-  "version": "0.2.2",
+  "version": "0.2.3",
   "author": "COOLWHITE LLC",
   "inputs": [
     {

package/apps/release-cut/app.json

@@ -3,7 +3,7 @@
   "id": "release-cut",
   "title": "Release Cut",
   "summary": "Prepare a release with checklist discipline: version checks, changelog, tests, packaging, release notes, and final verification.",
-  "version": "0.2.2",
+  "version": "0.2.3",
   "author": "COOLWHITE LLC",
   "inputs": [
     {

package/apps/research-synthesis/app.json

@@ -3,7 +3,7 @@
   "id": "research-synthesis",
   "title": "Research Synthesis",
   "summary": "Split a research question into claims, investigate sources, cross-check evidence, verify claims, and synthesize a concise answer.",
-  "version": "0.2.2",
+  "version": "0.2.3",
   "author": "COOLWHITE LLC",
   "inputs": [
     {

package/dist/cli/dispatch.js

@@ -54,8 +54,14 @@ function renderCliResult(result, jsonMode, options) {
 /** Tries the capability table for `args`. Matches the row whose
  *  `cli.path` is `[command]` or `[command, positionals[0]]` (the only two
  *  path lengths any milestone-2 row uses); returns true when a table row
- *  handled the command. */
-function dispatchTable(args) {
+ *  handled the command. `await`ing the handler's result is a no-op for
+ *  the ~199 rows whose handler returns a plain CliHandlerResult (an
+ *  `await` on a non-Promise value just resolves on the next microtask,
+ *  invisible to any caller that itself awaits dispatch()) -- it only
+ *  matters for the live drive rows, which return a real Promise so their
+ *  round loop can actually stay interruptible (see shell/drive.ts's
+ *  driveAsync). */
+async function dispatchTable(args) {
     const candidates = [[args.command]];
     if (args.positionals.length > 0)
         candidates.push([args.command, args.positionals[0]]);
@@ -68,7 +74,7 @@ function dispatchTable(args) {
             positionals: args.positionals.slice(consumed),
             options: args.options,
         };
-        const result = row.cli.handler(cliArgs);
+        const result = await row.cli.handler(cliArgs);
         renderCliResult(result, row.cli.jsonMode, args.options);
         return true;
     }
@@ -161,8 +167,8 @@ function dispatchLegacy(args) {
  *
  *  Tries the capability table FIRST (real rows always win), then falls
  *  back to the milestone-1 legacy switch for verbs not yet migrated. */
-function dispatch(args) {
-    if (dispatchTable(args))
+async function dispatch(args) {
+    if (await dispatchTable(args))
         return;
     dispatchLegacy(args);
 }

package/dist/cli/entry.js

@@ -33,6 +33,9 @@ const io_1 = require("./io");
  *  comes from core/format/help.ts either way. */
 function printVersion() {
     const row = (0, capability_table_1.findCapability)("version");
+    // `version`'s own handler is a pure, synchronous projection (never one of
+    // the live drive rows) -- safe to read `.text` straight off it rather than
+    // route through the generic (possibly-async) dispatch path.
     const result = row?.cli?.handler({ positionals: [], options: {} });
     process.stdout.write(result?.text ?? "");
 }
@@ -88,6 +91,21 @@ async function runCli(argv = process.argv.slice(2)) {
         process.env.CW_NO_COLOR = "1";
     if (args.options.full)
         process.env.CW_OUTPUT = "full";
+    // --quiet is a documented CLI spelling of the existing CW_DRIVE_PROGRESS=0
+    // env var (shell/drive.ts's emitProgress) — it only silences the terse
+    // "[drive] " progress lines, not the end-of-run summary or any other
+    // Rule of Silence gate point (SPEC/reporting-ux.md's 3 gate points are
+    // each independent; --verbose/--full don't touch them either). It also
+    // does NOT reach two OTHER TTY-gated narration channels a user might
+    // reasonably expect it to quiet: live raw agent stderr streaming
+    // (shell/execution-backend/agent.ts's shouldStreamAgentStderr, gated by
+    // CW_AGENT_STREAM/CW_NO_STREAM/isTTY) and the local backend's
+    // "● Running…"/"✓ Done" lines (shell/execution-backend/local.ts, gated
+    // by isTTY with no env override at all). Folding those in is a larger,
+    // separate change — this flag's help text says "not agent output" on
+    // purpose so the scope is clear without reading this comment.
+    if (args.options.quiet)
+        process.env.CW_DRIVE_PROGRESS = "0";
     // `cw <verb> --help` / `-h` -> per-command help
     // (src/cli/command-surface.ts:80-83).
     if ((args.options.help || args.options.h) && args.command && !args.command.startsWith("-")) {
@@ -103,13 +121,35 @@ async function runCli(argv = process.argv.slice(2)) {
     else if (!args.command && typeof args.options.question === "string") {
         args.command = "quickstart";
     }
-    (0, dispatch_1.dispatch)(args);
+    await (0, dispatch_1.dispatch)(args);
+}
+/** Broken pipe (`cw ... --json | head`): when the reader at the other end
+ *  of a pipe goes away early, a write to stdout gives an async 'error'
+ *  event that no promise .catch can see — without a listener node comes
+ *  down hard with a stack trace. Raw writes are all over the CLI (help,
+ *  version, printJson, human text), so ONE process-level listener here
+ *  covers every write point: EPIPE says "the reader has all it needs",
+ *  so stop quietly with code 0. Any other stream error is thrown again
+ *  and still comes up as an uncaughtException, same as before. */
+function exitQuietOnEpipe(stream) {
+    stream.on("error", (error) => {
+        if (error && error.code === "EPIPE")
+            process.exit(0);
+        throw error;
+    });
 }
 /** Top-level run wrapper matching src/cli.ts's catch shape byte-for-byte:
  *  `cw: <message>\n` then, only when a hint matches, `  Try: <hint>\n` on
  *  stderr; `process.exitCode = 1` (never a hard `process.exit`). */
 function main(argv = process.argv.slice(2)) {
+    exitQuietOnEpipe(process.stdout);
+    exitQuietOnEpipe(process.stderr);
     return runCli(argv).catch((error) => {
+        // On some platforms a broken-pipe write throws EPIPE in the write call
+        // itself (not as a stream 'error' event) — same broken pipe, same quiet
+        // exit 0, never a `cw: write EPIPE` line.
+        if (error?.code === "EPIPE")
+            return;
         const message = error instanceof Error ? error.message : String(error);
         process.stderr.write(`${(0, term_1.bold)("cw:", process.stderr)} ${(0, term_1.red)(message, process.stderr)}\n`);
         const hint = recoveryHint(message);

package/dist/cli/io.js

@@ -16,6 +16,7 @@ exports.optionalArg = optionalArg;
 exports.printJson = printJson;
 exports.wantsJson = wantsJson;
 const help_1 = require("../core/format/help");
+const safe_json_1 = require("../core/format/safe-json");
 const term_1 = require("../shell/term");
 /** Bold ONLY the fixed "Cool Workflow" header line of `formatHelp()`'s
  *  plain text. */
@@ -34,9 +35,12 @@ function required(value, label) {
 function optionalArg(value) {
     return typeof value === "string" && value.trim() ? value.trim() : undefined;
 }
-/** Machine payload to stdout (stdout = data; never colored, never chrome). */
+/** Machine payload to stdout (stdout = data; never colored, never chrome).
+ *  Byte-capped via safeJsonStringify — an aggregate result too large to be
+ *  useful (or large enough to blow V8's string limit) prints a small
+ *  overflow notice instead of hundreds of MB. */
 function printJson(value) {
-    process.stdout.write(`${JSON.stringify(value, null, 2)}\n`);
+    process.stdout.write(`${(0, safe_json_1.safeJsonStringify)(value)}\n`);
 }
 /** True when the caller asked for JSON output (`--json` or `--format json`). */
 function wantsJson(options) {

package/dist/cli/parseargv.js

@@ -116,6 +116,7 @@ exports.KNOWN_COMMANDS = new Set([
     "topology", "summary", "blackboard", "coordinator", "metrics", "operator",
     "sched", "gc", "telemetry", "migration", "demo", "workbench", "approve",
     "reject", "comment", "handoff", "graph", "eval", "version", "fix",
+    "completion",
 ]);
 /** Levenshtein edit distance between two strings. */
 function levenshtein(a, b) {

package/dist/core/capability-data.js

@@ -153,6 +153,7 @@ exports.MCP_TOOL_DATA = [
     { tool: "cw_coordinator_decision", capability: "coordinator.decision", requiredArgs: ["runId"], properties: ["runId", "cwd", "id", "kind", "outcome", "reason", "subject", "evidence", "artifact", "message"], description: "Record a coordinator decision." },
     { tool: "cw_audit_summary", capability: "audit.summary", requiredArgs: ["runId"], properties: ["runId", "cwd"], description: "Read the trust/audit summary." },
     { tool: "cw_audit_verify", capability: "audit.verify", requiredArgs: ["runId"], properties: ["runId", "cwd", "expectHead", "expectCount"], description: "Re-prove a run's trust-audit hash chain (fail-closed exit)." },
+    { tool: "cw_audit_repair", capability: "audit.repair", requiredArgs: ["runId"], properties: ["runId", "cwd", "write", "expectHead", "expectCount"], description: "Repair a torn trailing write in a run's trust-audit event log (dry-run unless write is set; fails closed if the corruption is not confined to the trailing line, or if expectHead/expectCount is given and not met)." },
     { tool: "cw_audit_worker", capability: "audit.worker", requiredArgs: ["runId"], properties: ["runId", "cwd", "workerId"], description: "Read trust/audit for one worker." },
     { tool: "cw_audit_provenance", capability: "audit.provenance", requiredArgs: ["runId"], properties: ["runId", "cwd", "workerId", "worker", "candidateId", "candidate", "commitId", "commit"], description: "Inspect evidence provenance." },
     { tool: "cw_audit_multi_agent", capability: "audit.multi-agent", requiredArgs: ["runId"], properties: ["runId", "cwd"], description: "Read the multi-agent trust/policy/provenance audit." },

package/dist/core/format/completion.js

@@ -0,0 +1,68 @@
+"use strict";
+// core/format/completion.ts — formatCompletionScript.
+//
+// Pure function of already-loaded data (MORE_COMMANDS_TOKENS from
+// help.ts). No new command list to hand-maintain: the completion word
+// list is the SAME token set formatHelp()'s "More commands" section
+// displays, plus the two top-level verbs that list doesn't carry
+// ("help" and "doctor" — see help.ts's formatHelp comment on why "help"
+// is absent from both places). Deliberately shallow: completes only
+// TOP-LEVEL command names, not subcommands or flags — a v1 scope that
+// still covers the single most common completion need (typing the verb)
+// without hand-maintaining a second, deeper copy of the capability
+// table's subcommand shape.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.completionWords = completionWords;
+exports.formatCompletionScript = formatCompletionScript;
+const help_1 = require("./help");
+/** The full top-level completion word list: `help`/`doctor` (absent from
+ *  MORE_COMMANDS_TOKENS — see help.ts) plus every token formatHelp's
+ *  "More commands" section lists (already includes `version`/`fix`). */
+function completionWords() {
+    return ["help", "doctor", ...help_1.MORE_COMMANDS_TOKENS];
+}
+function bashScript(words) {
+    return [
+        "# cw bash completion — generated by `cw completion bash`.",
+        "# Install: eval \"$(cw completion bash)\"  (e.g. in ~/.bashrc)",
+        "_cw_complete() {",
+        '  local cur="${COMP_WORDS[COMP_CWORD]}"',
+        "  if [ \"$COMP_CWORD\" -eq 1 ]; then",
+        `    COMPREPLY=( $(compgen -W "${words.join(" ")}" -- "$cur") )`,
+        "  fi",
+        "}",
+        "complete -F _cw_complete cw",
+        "",
+    ].join("\n");
+}
+function zshScript(words) {
+    return [
+        "#compdef cw",
+        "# cw zsh completion — generated by `cw completion zsh`.",
+        "# Install: cw completion zsh > \"${fpath[1]}/_cw\"  (then restart the shell)",
+        `_arguments '1: :(${words.join(" ")})'`,
+        "",
+    ].join("\n");
+}
+function fishScript(words) {
+    return [
+        "# cw fish completion — generated by `cw completion fish`.",
+        "# Install: cw completion fish > ~/.config/fish/completions/cw.fish",
+        `complete -c cw -n "__fish_use_subcommand" -a "${words.join(" ")}"`,
+        "",
+    ].join("\n");
+}
+/** `cw completion <bash|zsh|fish>` — a static completion script for the
+ *  top-level command word list. Throws on an unrecognized shell name
+ *  (the CLI layer turns that into the standard `cw: <message>` /
+ *  `Try:` shape, same as every other input-validation error). */
+function formatCompletionScript(shell) {
+    const words = completionWords();
+    if (shell === "bash")
+        return bashScript(words);
+    if (shell === "zsh")
+        return zshScript(words);
+    if (shell === "fish")
+        return fishScript(words);
+    throw new Error(`Unknown shell: ${shell}\n  Try: cw completion bash|zsh|fish`);
+}

package/dist/core/format/help.js

@@ -25,6 +25,7 @@
 // `tools/list` round-trip read the SAME table rows for any capability
 // wired into both.
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.MORE_COMMANDS_TOKENS = void 0;
 exports.formatHelp = formatHelp;
 exports.formatCommandHelp = formatCommandHelp;
 exports.formatInfo = formatInfo;
@@ -34,8 +35,12 @@ const capability_table_1 = require("../capability-table");
  *  build's order (space-joined in the source, pipe-joined for display).
  *  One change from the old capture: `update` is gone. The verb had no code
  *  behind it in this build (`cw update` said "Unknown command"), so the
- *  help must not offer it. See parseargv.ts KNOWN_COMMANDS. */
-const MORE_COMMANDS_TOKENS = [
+ *  help must not offer it. See parseargv.ts KNOWN_COMMANDS. Exported (only
+ *  as a read-only source list, `formatHelp` below still owns the byte-
+ *  pinned display format) so `core/format/completion.ts` can build a
+ *  shell-completion word list from the SAME data instead of a third
+ *  hand-maintained copy. */
+exports.MORE_COMMANDS_TOKENS = [
     "list", "search", "info", "init", "plan", "status", "next", "dispatch",
     "result", "state", "commit", "report", "app", "sandbox", "backend",
     "contract", "node", "feedback", "worker", "audit", "candidate", "review",
@@ -44,7 +49,7 @@ const MORE_COMMANDS_TOKENS = [
     "summary", "blackboard", "coordinator", "metrics", "operator", "sched",
     "gc", "telemetry", "migration", "demo", "workbench", "approve", "reject",
     "comment", "handoff", "ledger", "graph", "eval", "man", "version",
-    "fix",
+    "fix", "completion",
 ];
 const MORE_COMMANDS_WRAP_WIDTH = 76;
 /** src/orchestrator.ts:940-951 — greedily pack pipe-joined tokens into
@@ -128,7 +133,14 @@ const COMMAND_HELP_ROWS = {
         { command: "cw sched complete", summary: "Complete a held lease (terminal success)." },
         { command: "cw sched reclaim", summary: "Reclaim expired leases (each counts a failed attempt)." },
         { command: "cw sched reset", summary: "Reset a parked entry to ready (operator recovery)." },
-        { command: "cw sched policy", summary: "Show or set the scheduling policy (concurrency/attempts/backoff/TTL)." },
+        // Two rows for one command string, on purpose — SPEC/cli-probe.md's
+        // "Odd things a rebuild must copy or fix on purpose" item 5 names
+        // `sched policy` as one of the show/set pairs a rebuild's help
+        // printer must keep doubled; this single merged row was a regression
+        // that lost the doubling (docs/rebuild/SPEC/cli-help/sched.txt has
+        // both), restored here with the old ground truth's exact wording.
+        { command: "cw sched policy", summary: "Show the scheduling policy (file or default)." },
+        { command: "cw sched policy", summary: "Set scheduling policy fields (concurrency/attempts/backoff/TTL)." },
     ],
     registry: [
         { command: "cw registry refresh", summary: "Recompute and persist the derived run registry index." },
@@ -211,9 +223,14 @@ const COMMAND_HELP_ROWS = {
  *  stdout, so NO_COLOR/non-TTY always wins); byte content matches the
  *  plain-text capture at SPEC/cli-help/_root.txt, but for the dead
  *  `update` lines, which were taken out on purpose (no code was behind
- *  the verb — see MORE_COMMANDS_TOKENS note above). */
+ *  the verb — see MORE_COMMANDS_TOKENS note above), for a `--json`
+ *  Flags row, added because the old build's capture predates the ~68
+ *  capability-table rows that now support `--json`/`--format json`
+ *  (io.ts's wantsJson) — the flag existed but was never documented here —
+ *  and for a `--quiet` Flags row, a new CLI spelling of the existing
+ *  CW_DRIVE_PROGRESS=0 env var (see cli/entry.ts). */
 function formatHelp() {
-    const moreCommandsLines = wrapPipeJoined(MORE_COMMANDS_TOKENS, MORE_COMMANDS_WRAP_WIDTH);
+    const moreCommandsLines = wrapPipeJoined(exports.MORE_COMMANDS_TOKENS, MORE_COMMANDS_WRAP_WIDTH);
     const lines = [
         "Cool Workflow",
         "",
@@ -234,6 +251,8 @@ function formatHelp() {
         "  --verbose              Show full agent narration live (default: compact)",
         "  --full                 Verbose, plus the report printed inline at the end",
         "  --no-color             Disable ANSI color (also honors NO_COLOR / FORCE_COLOR)",
+        "  --json                 Print JSON for commands that support it",
+        "  --quiet                Suppress [drive] progress lines (not agent output)",
         "",
         "More commands",
         ...moreCommandsLines,

package/dist/core/format/safe-json.js

@@ -0,0 +1,73 @@
+"use strict";
+// core/format/safe-json.ts — a byte-capped JSON.stringify shared by the CLI's
+// `--json` output (cli/io.ts) and the MCP `tools/call` result (mcp/server.ts).
+//
+// Both surfaces JSON.stringify a caller-selected result with no size limit.
+// An aggregate/dashboard capability (e.g. cw_workbench_view, cw comment
+// list --json on a run with thousands of comments) can grow to hundreds of
+// MB: a useless dump for a calling agent's context window at best, and at
+// worst a RangeError ("Invalid string length") once the string crosses
+// V8's per-string ceiling (~256M UTF-16 code units) — the same failure
+// class PR #316 fixed for batch stdout reconciliation, here on the output
+// side instead. Both `--json` and MCP callers already catch a thrown error
+// and report it cleanly (cli/entry.ts's top-level catch; mcp/server.ts's
+// tools/call try/catch), so this is not a crash fix so much as a "return
+// something useful instead of a cryptic RangeError, or an unusable giant
+// payload" fix.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAX_JSON_OUTPUT_BYTES = void 0;
+exports.safeJsonStringify = safeJsonStringify;
+/** Generous but bounded: comfortably above any real cw result today, far
+ *  below V8's ~256M-UTF-16-code-unit ceiling. */
+exports.MAX_JSON_OUTPUT_BYTES = 10 * 1024 * 1024;
+/** Overflow-notice `detail` (a caught error's message) is truncated to this
+ *  many characters — the notice itself must stay small and predictable
+ *  regardless of how large the underlying error's message was (e.g. an
+ *  error wrapping a huge stored blackboard-message body), both so the
+ *  notice can never itself approach any cap, and so JSON.stringify-ing the
+ *  notice can never itself throw. */
+const MAX_DETAIL_CHARS = 500;
+/** JSON.stringify `value` the same way `JSON.stringify(value, null, 2)`
+ *  always has. If that would exceed `maxBytes` (or throws — e.g. a
+ *  RangeError from a value so large stringify itself blows V8's string
+ *  ceiling), returns a small, valid JSON string describing the overflow
+ *  instead of the real payload. Byte-identical to the un-capped form for
+ *  every result under the cap — the common case is untouched.
+ *
+ *  `JSON.stringify` returns the actual value `undefined` (not a string,
+ *  despite its `string` return-type declaration) for `undefined`, a
+ *  function, or a Symbol — never throws for those. That is passed through
+ *  unchanged (matching the un-capped form's pre-existing behavior for this
+ *  edge case: `content[0].text`/`printJson`'s `${text}` end up printing
+ *  literally `undefined`) rather than measured as a byte length. */
+function safeJsonStringify(value, maxBytes = exports.MAX_JSON_OUTPUT_BYTES) {
+    let text;
+    try {
+        text = JSON.stringify(value, null, 2);
+    }
+    catch (error) {
+        return JSON.stringify(overflowPayload(undefined, maxBytes, error), null, 2);
+    }
+    if (typeof text !== "string")
+        return text;
+    const bytes = Buffer.byteLength(text, "utf8");
+    if (bytes <= maxBytes)
+        return text;
+    return JSON.stringify(overflowPayload(bytes, maxBytes), null, 2);
+}
+function overflowPayload(bytes, maxBytes, error) {
+    const rawDetail = error instanceof Error ? error.message : error !== undefined ? String(error) : undefined;
+    const detail = rawDetail !== undefined
+        ? rawDetail.length > MAX_DETAIL_CHARS
+            ? `${rawDetail.slice(0, MAX_DETAIL_CHARS)}… (truncated)`
+            : rawDetail
+        : undefined;
+    return {
+        error: "result-too-large",
+        message: `This result is too large to return in full (${bytes !== undefined ? `${bytes} bytes` : "exceeds the size limit while serializing"}, ` +
+            `cap is ${maxBytes} bytes). Narrow the query (a --limit/--status/--since filter, or a more specific tool/verb) and try again.`,
+        capBytes: maxBytes,
+        ...(bytes !== undefined ? { actualBytes: bytes } : {}),
+        ...(detail ? { detail } : {}),
+    };
+}

package/dist/core/format/state-explosion-text.js

@@ -156,7 +156,7 @@ function stateExplosionReportLines(report) {
         lines.push(`  - ${reason}`);
     if (report.compactGraph.collapsedNodeCount > 0) {
         lines.push(`- Graph compacted: ${report.compactGraph.collapsedNodeCount} nodes collapsed into ${report.compactGraph.syntheticNodes.length} summary nodes`);
-        lines.push(`  - Use: \`node scripts/cw.js multi-agent graph ${report.runId} --view full --json\``);
+        lines.push(`  - Use: \`cw multi-agent graph ${report.runId} --view full --json\``);
     }
     if (report.hiddenSourceRecords.length) {
         for (const hidden of report.hiddenSourceRecords) {

package/dist/core/multi-agent/candidate-scoring.js

@@ -123,7 +123,11 @@ function detectTies(candidates) {
     const groups = new Map();
     for (const candidate of candidates) {
         const key = String(candidate.normalized);
-        groups.set(key, [...(groups.get(key) || []), candidate.candidateId]);
+        const group = groups.get(key);
+        if (group)
+            group.push(candidate.candidateId);
+        else
+            groups.set(key, [candidate.candidateId]);
     }
     return Array.from(groups.values()).filter((group) => group.length > 1);
 }

package/dist/core/multi-agent/collaboration.js

@@ -415,16 +415,16 @@ function buildTimeline(state) {
 function buildNextActions(runId, states, policy) {
     const actions = [];
     if (!policy) {
-        actions.push(`node scripts/cw.js review policy ${runId} --requiredApprovals 1 --authorizedRoles reviewer --appliesTo commit`);
+        actions.push(`cw review policy ${runId} --requiredApprovals 1 --authorizedRoles reviewer --appliesTo commit`);
         return actions;
     }
     for (const state of states) {
         if (state.status === "pending" || state.status === "blocked" || state.status === "unattributed") {
-            actions.push(`node scripts/cw.js approve ${state.target.kind} ${runId} ${state.target.id} --role <authorized-role> --actor <id> --attested`);
+            actions.push(`cw approve ${state.target.kind} ${runId} ${state.target.id} --role <authorized-role> --actor <id> --attested`);
         }
     }
     if (!actions.length)
-        actions.push(`node scripts/cw.js review status ${runId} --json`);
+        actions.push(`cw review status ${runId} --json`);
     return actions;
 }
 /** Self ids for a candidate/selection target: its producing worker +

package/dist/core/multi-agent/coordinator.js

@@ -443,14 +443,14 @@ function summarizeBlackboard(runId, state, blackboardId, defaultIndexPath) {
 }
 function nextAction(runId, board, openQuestions, conflicts, artifacts) {
     if (!board)
-        return `node scripts/cw.js blackboard topic create ${runId} --id <topic-id> --title "<title>"`;
+        return `cw blackboard topic create ${runId} --id <topic-id> --title "<title>"`;
     if (conflicts.length)
-        return `node scripts/cw.js coordinator decision ${runId} --kind conflict-resolution --outcome accepted --subject ${conflicts[0].id} --reason "<reason>"`;
+        return `cw coordinator decision ${runId} --kind conflict-resolution --outcome accepted --subject ${conflicts[0].id} --reason "<reason>"`;
     if (openQuestions.length)
-        return `node scripts/cw.js blackboard message post ${runId} --topic ${openQuestions[0].topicId} --body "<answer with evidence>"`;
+        return `cw blackboard message post ${runId} --topic ${openQuestions[0].topicId} --body "<answer with evidence>"`;
     if (!artifacts.length)
-        return `node scripts/cw.js blackboard artifact add ${runId} --path <path> --kind <kind>`;
-    return `node scripts/cw.js blackboard snapshot ${runId}`;
+        return `cw blackboard artifact add ${runId} --path <path> --kind <kind>`;
+    return `cw blackboard snapshot ${runId}`;
 }
 function listBlackboardMessages(state, options = {}) {
     return state.messages

package/dist/core/multi-agent/runtime.js

@@ -841,15 +841,15 @@ function summarizeMultiAgent(run) {
 function nextMultiAgentAction(run, blockedReasons) {
     const state = ensureMultiAgentState(run);
     if (!state.runs.length)
-        return `node scripts/cw.js multi-agent run ${run.id} --id <multi-agent-run-id>`;
+        return `cw multi-agent run ${run.id} --id <multi-agent-run-id>`;
     if (blockedReasons.length)
-        return `node scripts/cw.js multi-agent fanin ${run.id} --group <group-id> --fanout <fanout-id>`;
+        return `cw multi-agent fanin ${run.id} --group <group-id> --fanout <fanout-id>`;
     const running = state.memberships.find((membership) => membership.status === "running");
     if (running?.workerId)
-        return `node scripts/cw.js worker manifest ${run.id} ${running.workerId}`;
+        return `cw worker manifest ${run.id} ${running.workerId}`;
     const groupWithoutFanin = state.groups.find((group) => group.membershipIds.length && !group.faninIds.length);
     if (groupWithoutFanin)
-        return `node scripts/cw.js multi-agent fanin ${run.id} --group ${groupWithoutFanin.id}`;
+        return `cw multi-agent fanin ${run.id} --group ${groupWithoutFanin.id}`;
     return undefined;
 }
 function buildMultiAgentGraph(run) {

package/dist/core/multi-agent/topology.js

@@ -244,9 +244,9 @@ function topologyRunId(definition, taskIds, runId, sequence, hash) {
 }
 function nextActionsFor(runId, topologyRunId, fanoutId) {
     return [
-        `node scripts/cw.js dispatch ${runId} --multi-agent-fanout ${fanoutId}`,
-        `node scripts/cw.js multi-agent fanin ${runId} ${topologyRunId}-fanin --fanout ${fanoutId}`,
-        `node scripts/cw.js topology summary ${runId}`,
+        `cw dispatch ${runId} --multi-agent-fanout ${fanoutId}`,
+        `cw multi-agent fanin ${runId} ${topologyRunId}-fanin --fanout ${fanoutId}`,
+        `cw topology summary ${runId}`,
     ];
 }
 function statusToNodeStatus(status) {

package/dist/core/pipeline/dispatch.js

@@ -20,7 +20,14 @@ exports.formatDispatchId = formatDispatchId;
  *  everything after it (`null`). */
 function firstRunnablePhase(run) {
     for (const phase of run.phases) {
-        const phaseTasks = run.tasks.filter((task) => phase.taskIds.includes(task.id));
+        // A Set lookup, not `taskIds.includes()` re-scanned per task: this loop is
+        // O(phases x tasks), not O(phases x tasks x taskIds-per-phase) -- the
+        // latter degrades to O(tasks^2) since total taskIds across phases scales
+        // with total tasks, and this function is called several times per drive
+        // hop (once per hop directly, again inside selectDriveTask, again inside
+        // driveConcurrentRound), compounding to O(tasks^3) over a whole run.
+        const taskIds = new Set(phase.taskIds);
+        const phaseTasks = run.tasks.filter((task) => taskIds.has(task.id));
         if (phaseTasks.some((task) => task.status === "running"))
             return phase;
         if (phaseTasks.some((task) => task.status === "pending"))
@@ -34,7 +41,8 @@ function firstRunnablePhase(run) {
  *  running when some task is running or completed, else pending. */
 function updatePhaseStatuses(run) {
     for (const phase of run.phases) {
-        const phaseTasks = run.tasks.filter((task) => phase.taskIds.includes(task.id));
+        const taskIds = new Set(phase.taskIds);
+        const phaseTasks = run.tasks.filter((task) => taskIds.has(task.id));
         if (phaseTasks.length > 0 && phaseTasks.every((task) => task.status === "completed")) {
             phase.status = "completed";
         }
@@ -69,12 +77,18 @@ function formatDispatchTask(task) {
     };
 }
 /** `nextDispatchTasks(run, limit?)` — pending tasks of the first runnable
- *  phase, capped, mapped through formatDispatchTask. */
+ *  phase, capped, mapped through formatDispatchTask. `??`, not `||`: an
+ *  explicit `limit: 0` (or a configured `maxConcurrentAgents: 0`) means
+ *  "dispatch nothing", not "no limit was given" — `0 || fallback` used to
+ *  silently replace a real zero with the fallback. Negative numbers are
+ *  clamped to 0 before reaching `.slice()`, which otherwise treats a
+ *  negative end index as "drop that many from the end" instead of "cap at
+ *  this many". */
 function nextDispatchTasks(run, limit) {
     const runnablePhase = firstRunnablePhase(run);
     if (!runnablePhase)
         return [];
-    const max = Number(limit || run.workflow.limits.maxConcurrentAgents || 4);
+    const max = Math.max(0, Math.floor(limit ?? run.workflow.limits.maxConcurrentAgents ?? 4));
     const runnableTaskIds = new Set(runnablePhase.taskIds);
     return run.tasks
         .filter((task) => task.status === "pending" && runnableTaskIds.has(task.id))

package/dist/core/pipeline/drive-decide.js

@@ -45,7 +45,8 @@ function selectDriveTask(run) {
     const phase = (0, dispatch_1.firstRunnablePhase)(run);
     if (!phase)
         return undefined;
-    const phaseTasks = run.tasks.filter((task) => phase.taskIds.includes(task.id));
+    const taskIds = new Set(phase.taskIds);
+    const phaseTasks = run.tasks.filter((task) => taskIds.has(task.id));
     return phaseTasks.find((task) => task.status === "running") || phaseTasks.find((task) => task.status === "pending");
 }
 function countCompleted(run) {