cool-workflow 0.2.1 → 0.2.3

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,13 +25,22 @@
 // `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;
+exports.formatSearchResults = formatSearchResults;
 const capability_table_1 = require("../capability-table");
-/** src/orchestrator.ts:934-951 — the exact "More commands" token set, in
- *  this exact order (space-joined in the source, pipe-joined for display). */
-const MORE_COMMANDS_TOKENS = [
+/** src/orchestrator.ts:934-951 — the "More commands" token set, in the old
+ *  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. 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",
@@ -40,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",
-    "update", "fix",
+    "fix", "completion",
 ];
 const MORE_COMMANDS_WRAP_WIDTH = 76;
 /** src/orchestrator.ts:940-951 — greedily pack pipe-joined tokens into
@@ -124,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." },
@@ -205,16 +221,22 @@ const COMMAND_HELP_ROWS = {
 /** src/orchestrator.ts:899-933 — the top-level `cw help` text. Color is
  *  intentionally NOT applied here (this milestone's conformance runs pipe
  *  stdout, so NO_COLOR/non-TTY always wins); byte content matches the
- *  plain-text capture at SPEC/cli-help/_root.txt exactly. */
+ *  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), 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",
         "",
         '  -q "question" [-claude|-codex|-gemini|-deepseek]  Ask a question, get a report',
         '  -q "question" --link <url>                 Review a remote repo by URL',
         "  version                                   Show version",
-        "  update                                    Update to latest release",
         "  doctor                                    Check setup",
         "  fix                                       Show fix commands for setup issues",
         "",
@@ -229,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,
@@ -312,3 +336,21 @@ function formatInfo(appId, data) {
     lines.push(`  Run: cw quickstart ${appId} --repo . --question "..."`);
     return lines.join("\n");
 }
+/** `cw search <keyword>`'s human text — byte-exact to the milestone-1
+ *  carry-over's own formatSearchResults (moved here from cli/dispatch.ts
+ *  so the search capability-table row, which lives in core/, can render
+ *  its own text without core importing from cli/). */
+function formatSearchResults(keyword, results) {
+    if (results.length === 0) {
+        return `No workflows matched "${keyword}".\n  Tip: cw list for all available workflows.`;
+    }
+    const lines = [`${results.length} workflow${results.length === 1 ? "" : "s"} matching "${keyword}"`];
+    for (const r of results) {
+        lines.push(`  ${r.id} — ${r.title}`);
+        const cut = r.summary.length > 120 ? `${r.summary.slice(0, 119)}…` : r.summary;
+        lines.push(`    ${cut}`);
+    }
+    lines.push("");
+    lines.push("Use cw info <id> for full details.");
+    return lines.join("\n");
+}

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

@@ -36,6 +36,7 @@ exports.listComments = listComments;
 exports.distinctTargets = distinctTargets;
 exports.formatReviewStatus = formatReviewStatus;
 exports.formatCommentList = formatCommentList;
+const collate_1 = require("../util/collate");
 exports.COLLABORATION_SCHEMA_VERSION = 1;
 /** The single, honest stand-in for an absent identity. */
 exports.UNATTRIBUTED_ACTOR = {
@@ -213,7 +214,7 @@ function matchesAnyTarget(target, related) {
     return related.some((entry) => sameTarget(target, entry));
 }
 function compareByCreated(left, right) {
-    return left.createdAt.localeCompare(right.createdAt) || left.id.localeCompare(right.id);
+    return (0, collate_1.stableCompare)(left.createdAt, right.createdAt) || (0, collate_1.stableCompare)(left.id, right.id);
 }
 function disqualify(record, policy, selfIds) {
     const actor = record.actor;
@@ -414,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 +
@@ -453,7 +454,7 @@ function distinctTargets(state) {
         seen.set(targetKey(record.target), record.target);
     for (const record of state.handoffs)
         seen.set(targetKey(record.target), record.target);
-    return [...seen.values()].sort((left, right) => targetKey(left).localeCompare(targetKey(right)));
+    return [...seen.values()].sort((left, right) => (0, collate_1.stableCompare)(targetKey(left), targetKey(right)));
 }
 function formatReviewStatus(report) {
     const lines = [];

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

@@ -47,6 +47,7 @@ exports.summarizeBlackboard = summarizeBlackboard;
 exports.listBlackboardMessages = listBlackboardMessages;
 exports.listBlackboardArtifacts = listBlackboardArtifacts;
 exports.buildBlackboardGraph = buildBlackboardGraph;
+const collate_1 = require("../util/collate");
 exports.BLACKBOARD_SCHEMA_VERSION = 1;
 /** Dedup, SORTS. Coordinator-side sorting `unique` — byte-identical
  *  behavior to core/multi-agent/runtime.ts's own copy, kept as a
@@ -420,7 +421,7 @@ function summarizeBlackboard(runId, state, blackboardId, defaultIndexPath) {
     ].sort();
     const readyForFanin = Boolean(board && !openQuestions.length && !conflicts.length && artifacts.length > 0 && missingEvidence.length === 0);
     const latestSnapshot = scoped(state.snapshots)
-        .sort((left, right) => left.createdAt.localeCompare(right.createdAt))
+        .sort((left, right) => (0, collate_1.stableCompare)(left.createdAt, right.createdAt))
         .at(-1);
     return {
         runId,
@@ -442,24 +443,24 @@ 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
         .filter((message) => (!options.blackboardId || message.blackboardId === options.blackboardId) && (!options.topicId || message.topicId === options.topicId))
-        .sort((left, right) => left.createdAt.localeCompare(right.createdAt) || left.id.localeCompare(right.id));
+        .sort((left, right) => (0, collate_1.stableCompare)(left.createdAt, right.createdAt) || (0, collate_1.stableCompare)(left.id, right.id));
 }
 function listBlackboardArtifacts(state, options = {}) {
     return state.artifacts
         .filter((artifact) => (!options.blackboardId || artifact.blackboardId === options.blackboardId) && (!options.topicId || artifact.topicId === options.topicId))
-        .sort((left, right) => left.id.localeCompare(right.id));
+        .sort((left, right) => (0, collate_1.stableCompare)(left.id, right.id));
 }
 function buildBlackboardGraph(runId, state, recordPath, messagesPath) {
     const nodes = [];

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/commit-gate.js

@@ -20,6 +20,7 @@ exports.formatCommitId = formatCommitId;
 exports.gateFailureSeq = gateFailureSeq;
 const evidence_grounding_1 = require("../trust/evidence-grounding");
 const result_normalize_1 = require("./result-normalize");
+const collate_1 = require("../util/collate");
 /** The sandbox profile that accepted a candidate's worker output — the
  *  worker's own profile when present, else the backing task's. Pure port of
  *  the old build's src/gates.ts sandboxProfileForCandidate. */
@@ -97,7 +98,7 @@ function findSelectionNode(run, selectionId) {
 function latestSelectionForCandidate(run, candidateId) {
     return [...(run.candidateSelections || [])]
         .filter((s) => s.candidateId === candidateId)
-        .sort((a, b) => (b.selectedAt || "").localeCompare(a.selectedAt || ""))[0];
+        .sort((a, b) => (0, collate_1.stableCompare)(b.selectedAt || "", a.selectedAt || ""))[0];
 }
 function evidenceLocatorString(entry) {
     const ref = entry.locator || entry.path || entry.summary || entry.id;

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) {

package/dist/core/state/migrations.js

@@ -49,6 +49,7 @@ exports.RUN_STATE_MIGRATIONS = void 0;
 exports.findMigrationPath = findMigrationPath;
 exports.migrateRunState = migrateRunState;
 exports.reverseRunState = reverseRunState;
+exports.derivePhases = derivePhases;
 const path = __importStar(require("node:path"));
 const version_1 = require("../version");
 const schema_1 = require("./schema");
@@ -118,6 +119,12 @@ function findMigrationPath(steps, fromVersion, toVersion) {
     }
     return { reachable: false, path: [], error: `no migration path from schemaVersion ${fromVersion} to ${toVersion}` };
 }
+/** Shared by migrateRunState/reverseRunState: missing EITHER `workflow` OR
+ *  `paths` (or both) is the signal — a real run always has both together,
+ *  so a lone surviving one of the two is not proof the rest wasn't lost. */
+function computeSuspectedDataLoss(input) {
+    return !("workflow" in input) || !("paths" in input);
+}
 function migrateRunState(input, options = {}) {
     const report = {
         status: "current",
@@ -130,12 +137,14 @@ function migrateRunState(input, options = {}) {
         changes: [],
         warnings: [],
         errors: [],
+        suspectedDataLoss: false,
     };
     if (!isRecord(input)) {
         report.status = "unsupported";
         report.errors.push("Run state must be a JSON object.");
         return { run: {}, report };
     }
+    report.suspectedDataLoss = computeSuspectedDataLoss(input);
     if (report.detectedSchemaVersion < version_1.MIN_SUPPORTED_RUN_STATE_SCHEMA_VERSION) {
         report.status = "unsupported";
         report.errors.push(`Unsupported run-state schemaVersion ${schemaVersionDescription(input, report.detectedSchemaVersion)}.`);
@@ -185,12 +194,14 @@ function reverseRunState(input, targetSchemaVersion, options = {}) {
         changes: [],
         warnings: [],
         errors: [],
+        suspectedDataLoss: false,
     };
     if (!isRecord(input)) {
         report.status = "unsupported";
         report.errors.push("Run state must be a JSON object.");
         return { run: {}, report };
     }
+    report.suspectedDataLoss = computeSuspectedDataLoss(input);
     if (targetSchemaVersion < version_1.MIN_SUPPORTED_RUN_STATE_SCHEMA_VERSION) {
         report.status = "unsupported";
         report.errors.push(`Target schemaVersion ${targetSchemaVersion} is below the minimum supported ${version_1.MIN_SUPPORTED_RUN_STATE_SCHEMA_VERSION}.`);
@@ -428,7 +439,11 @@ function derivePhases(tasks) {
         const taskId = stringValue(task.id);
         if (!taskId)
             continue;
-        byPhase.set(phase, [...(byPhase.get(phase) || []), taskId]);
+        const taskIds = byPhase.get(phase);
+        if (taskIds)
+            taskIds.push(taskId);
+        else
+            byPhase.set(phase, [taskId]);
     }
     if (byPhase.size === 0)
         return [];