cool-workflow 0.2.2 → 0.2.3

package/dist/shell/multi-agent-host.js

@@ -294,27 +294,27 @@ function hostNextActions(run, state, active, requiredHostAction, readyForCommit)
     const runId = run.id;
     switch (state) {
         case "needs-run":
-            return [{ command: `node scripts/cw.js multi-agent run ${runId} --topology map-reduce`, reason: "Materialize a host-facing multi-agent topology.", priority: "high" }];
+            return [{ command: `cw multi-agent run ${runId} --topology map-reduce`, reason: "Materialize a host-facing multi-agent topology.", priority: "high" }];
         case "ready-for-dispatch":
-            return [{ command: `node scripts/cw.js multi-agent step ${runId}`, reason: "Create the next dispatch manifest without spawning workers.", priority: "high" }];
+            return [{ command: `cw multi-agent step ${runId}`, reason: "Create the next dispatch manifest without spawning workers.", priority: "high" }];
         case "awaiting-worker-output":
-            return [{ command: `node scripts/cw.js worker output ${runId} <worker-id> <result.md>`, reason: "A host-executed worker must report result evidence.", priority: "high" }];
+            return [{ command: `cw worker output ${runId} <worker-id> <result.md>`, reason: "A host-executed worker must report result evidence.", priority: "high" }];
         case "ready-for-fanin":
-            return [{ command: `node scripts/cw.js multi-agent step ${runId}`, reason: "Collect fanin once required worker evidence is present.", priority: "high" }];
+            return [{ command: `cw multi-agent step ${runId}`, reason: "Collect fanin once required worker evidence is present.", priority: "high" }];
         case "ready-for-scoring":
-            return [{ command: `node scripts/cw.js multi-agent score ${runId} --candidate <candidate-id> --criterion correctness=1 --evidence <path-or-ref>`, reason: "Score a candidate with explicit evidence.", priority: "high" }];
+            return [{ command: `cw multi-agent score ${runId} --candidate <candidate-id> --criterion correctness=1 --evidence <path-or-ref>`, reason: "Score a candidate with explicit evidence.", priority: "high" }];
         case "ready-for-selection":
-            return [{ command: `node scripts/cw.js multi-agent select ${runId} --candidate <candidate-id> --reason "<rationale>"`, reason: "Select a scored candidate after verifier gates pass.", priority: "high" }];
+            return [{ command: `cw multi-agent select ${runId} --candidate <candidate-id> --reason "<rationale>"`, reason: "Select a scored candidate after verifier gates pass.", priority: "high" }];
         case "ready-for-commit": {
             const ready = readyForCommit[0];
-            return [{ command: `node scripts/cw.js commit ${runId} --selection ${ready.selectionId} --reason "<verified rationale>"`, reason: "Create a verifier-gated CW state commit.", priority: "high" }];
+            return [{ command: `cw commit ${runId} --selection ${ready.selectionId} --reason "<verified rationale>"`, reason: "Create a verifier-gated CW state commit.", priority: "high" }];
         }
         case "complete":
-            return [{ command: `node scripts/cw.js report ${runId} --show`, reason: "Review the completed run report.", priority: "normal" }];
+            return [{ command: `cw report ${runId} --show`, reason: "Review the completed run report.", priority: "normal" }];
         case "failed":
         case "blocked":
         default:
-            return [{ command: `node scripts/cw.js multi-agent status ${runId}`, reason: active.length > 1 ? "Resolve ambiguous active topology state." : "Inspect specific blocked reasons.", priority: "high" }];
+            return [{ command: `cw multi-agent status ${runId}`, reason: active.length > 1 ? "Resolve ambiguous active topology state." : "Inspect specific blocked reasons.", priority: "high" }];
     }
 }
 function envelope(run, command, options = {}) {

package/dist/shell/multi-agent-operator-ux.js

@@ -106,13 +106,13 @@ function summarizeMultiAgentOperator(run) {
         multiAgent.nextAction ||
         blackboard.nextAction ||
         readyCommitCommand(run) ||
-        `node scripts/cw.js multi-agent status ${run.id} --json`;
+        `cw multi-agent status ${run.id} --json`;
     return {
         schemaVersion: 1,
         runId: run.id,
-        activeMultiAgentRunIds: [...activeMultiAgentRunIds, ...((state.runs || []).filter((entry) => !isTerminal(entry.status)).map((entry) => entry.id))].filter(uniqueFilter),
+        activeMultiAgentRunIds: [...new Set([...activeMultiAgentRunIds, ...((state.runs || []).filter((entry) => !isTerminal(entry.status)).map((entry) => entry.id))])],
         topologyRunIds: [...activeTopologyIds],
-        topologyIds: topologies.active.map((entry) => entry.topologyId).filter(uniqueFilter),
+        topologyIds: [...new Set(topologies.active.map((entry) => entry.topologyId))],
         groups: (state.groups || []).map((entry) => entry.id).sort(),
         roles: (state.roles || []).map((entry) => entry.id).sort(),
         memberships: (state.memberships || []).map((entry) => entry.id).sort(),
@@ -261,7 +261,7 @@ function deriveDependencies(run) {
     for (const fanin of state.fanins || []) {
         add(fanin.fanoutId ? `${run.id}:multi-agent:fanout:${fanin.fanoutId}` : `${run.id}:multi-agent:group:${fanin.groupId}`, `${run.id}:multi-agent:fanin:${fanin.id}`, "fanin");
         for (const coverage of fanin.evidenceCoverage || []) {
-            add(`${run.id}:multi-agent:membership:${coverage.membershipId}`, `${run.id}:multi-agent:fanin:${fanin.id}`, coverage.complete ? "adopted-by" : "blocks", coverage.complete ? "ready" : "blocked", coverage.complete ? undefined : "membership has not reported required evidence", `node scripts/cw.js worker manifest ${run.id} ${coverage.workerId || "<worker-id>"}`);
+            add(`${run.id}:multi-agent:membership:${coverage.membershipId}`, `${run.id}:multi-agent:fanin:${fanin.id}`, coverage.complete ? "adopted-by" : "blocks", coverage.complete ? "ready" : "blocked", coverage.complete ? undefined : "membership has not reported required evidence", `cw worker manifest ${run.id} ${coverage.workerId || "<worker-id>"}`);
         }
     }
     for (const candidate of candidatesOf(run)) {
@@ -276,7 +276,7 @@ function deriveDependencies(run) {
     for (const commit of commitsOf(run)) {
         add(commit.selectionId ? `${run.id}:selection:${commit.selectionId}` : undefined, String(commit.stateNodeId || `${run.id}:commit:${commit.id}`), "commits", commit.verifierGated ? "committed" : "checkpoint");
     }
-    return rows.filter(uniqueById).sort((left, right) => (0, collate_1.stableCompare)(left.from, right.from) || (0, collate_1.stableCompare)(left.to, right.to));
+    return uniqueById(rows).sort((left, right) => (0, collate_1.stableCompare)(left.from, right.from) || (0, collate_1.stableCompare)(left.to, right.to));
 }
 function deriveFailures(run, dependencies) {
     const rows = [];
@@ -284,61 +284,74 @@ function deriveFailures(run, dependencies) {
         rows.push({ id, kind, status, owner, linked, reason, nextCommand });
     };
     const state = maOf(run);
+    // Grouped/indexed once instead of re-filtering/re-scanning the whole
+    // memberships/workers array per role/membership below (O(roles x
+    // memberships) and O(memberships x workers) otherwise -- the same
+    // array-scan-per-item shape 024b007 fixed for phase/task selection).
+    const membershipsByRole = new Map();
+    for (const entry of state.memberships || []) {
+        const list = membershipsByRole.get(entry.roleId);
+        if (list)
+            list.push(entry);
+        else
+            membershipsByRole.set(entry.roleId, [entry]);
+    }
+    const workersById = new Map(workersOf(run).map((entry) => [entry.id, entry]));
     for (const role of state.roles || []) {
-        const memberships = (state.memberships || []).filter((entry) => entry.roleId === role.id);
+        const memberships = membershipsByRole.get(role.id) || [];
         if (!memberships.length && role.status !== "completed" && role.status !== "cancelled") {
-            add(role.id, "missing-role-coverage", role.status, `role ${role.id} has no membership`, `node scripts/cw.js multi-agent step ${run.id}`, role.id);
+            add(role.id, "missing-role-coverage", role.status, `role ${role.id} has no membership`, `cw multi-agent step ${run.id}`, role.id);
         }
         if (role.status === "blocked" || role.status === "cancelled")
-            add(role.id, "agent-role", role.status, `role ${role.id} is ${role.status}`, `node scripts/cw.js multi-agent status ${run.id} --json`, role.id);
+            add(role.id, "agent-role", role.status, `role ${role.id} is ${role.status}`, `cw multi-agent status ${run.id} --json`, role.id);
     }
     for (const membership of state.memberships || []) {
-        const worker = membership.workerId ? workersOf(run).find((entry) => entry.id === membership.workerId) : undefined;
+        const worker = membership.workerId ? workersById.get(membership.workerId) : undefined;
         if (membership.status === "failed" || membership.status === "cancelled")
-            add(membership.id, "agent-membership", membership.status, `membership ${membership.id} is ${membership.status}`, `node scripts/cw.js multi-agent membership ${run.id} ${membership.id}`, membership.roleId, membership.workerId);
+            add(membership.id, "agent-membership", membership.status, `membership ${membership.id} is ${membership.status}`, `cw multi-agent membership ${run.id} ${membership.id}`, membership.roleId, membership.workerId);
         if (!membership.workerId)
-            add(membership.id, "missing-worker", membership.status, `membership ${membership.id} has no worker`, `node scripts/cw.js multi-agent step ${run.id}`, membership.roleId, membership.taskId);
+            add(membership.id, "missing-worker", membership.status, `membership ${membership.id} has no worker`, `cw multi-agent step ${run.id}`, membership.roleId, membership.taskId);
         if (worker && (worker.status === "failed" || worker.status === "rejected"))
-            add(String(worker.id), "worker", String(worker.status), worker.errors?.[0]?.message || `worker ${worker.id} is ${worker.status}`, `node scripts/cw.js worker show ${run.id} ${worker.id}`, membership.roleId, membership.id);
+            add(String(worker.id), "worker", String(worker.status), worker.errors?.[0]?.message || `worker ${worker.id} is ${worker.status}`, `cw worker show ${run.id} ${worker.id}`, membership.roleId, membership.id);
         if (worker && (worker.status === "allocated" || worker.status === "running"))
-            add(String(worker.id), "worker-output", String(worker.status), `worker ${worker.id} has not reported output`, `node scripts/cw.js worker manifest ${run.id} ${worker.id}`, membership.roleId, membership.id);
+            add(String(worker.id), "worker-output", String(worker.status), `worker ${worker.id} has not reported output`, `cw worker manifest ${run.id} ${worker.id}`, membership.roleId, membership.id);
     }
     for (const fanin of state.fanins || []) {
         for (const reason of fanin.blockedReasons || [])
-            add(fanin.id, "fanin", fanin.status, reason, `node scripts/cw.js multi-agent failures ${run.id}`, fanin.groupId, fanin.fanoutId);
+            add(fanin.id, "fanin", fanin.status, reason, `cw multi-agent failures ${run.id}`, fanin.groupId, fanin.fanoutId);
         for (const roleId of fanin.missingRoleIds || [])
-            add(`${fanin.id}:${roleId}`, "missing-role-evidence", "missing", `fanin ${fanin.id} is missing role ${roleId}`, `node scripts/cw.js multi-agent step ${run.id}`, roleId, fanin.id);
+            add(`${fanin.id}:${roleId}`, "missing-role-evidence", "missing", `fanin ${fanin.id} is missing role ${roleId}`, `cw multi-agent step ${run.id}`, roleId, fanin.id);
         for (const membershipId of fanin.missingMembershipIds || [])
-            add(`${fanin.id}:${membershipId}`, "missing-membership-evidence", "missing", `fanin ${fanin.id} is missing membership ${membershipId}`, `node scripts/cw.js multi-agent membership ${run.id} ${membershipId}`, membershipId, fanin.id);
+            add(`${fanin.id}:${membershipId}`, "missing-membership-evidence", "missing", `fanin ${fanin.id} is missing membership ${membershipId}`, `cw multi-agent membership ${run.id} ${membershipId}`, membershipId, fanin.id);
     }
     for (const topology of topologyRunsOf(run)) {
         for (const missing of topology.missingEvidence || [])
-            add(`${topology.id}:${missing}`, "missing-topology-evidence", "missing", missing, topology.nextActions?.[0] || `node scripts/cw.js topology summary ${run.id}`, String(topology.id));
+            add(`${topology.id}:${missing}`, "missing-topology-evidence", "missing", missing, topology.nextActions?.[0] || `cw topology summary ${run.id}`, String(topology.id));
         if (topology.status === "blocked" || topology.status === "failed")
-            add(String(topology.id), "topology", String(topology.status), `topology ${topology.id} is ${topology.status}`, `node scripts/cw.js topology summary ${run.id}`, String(topology.id));
+            add(String(topology.id), "topology", String(topology.status), `topology ${topology.id} is ${topology.status}`, `cw topology summary ${run.id}`, String(topology.id));
     }
     for (const feedback of feedbackOf(run)) {
         if (feedback.status === "open" || feedback.status === "tasked")
-            add(String(feedback.id), String(feedback.classification), String(feedback.status), String(feedback.message), `node scripts/cw.js feedback show ${run.id} ${feedback.id}`, feedback.taskId, feedback.nodeId);
+            add(String(feedback.id), String(feedback.classification), String(feedback.status), String(feedback.message), `cw feedback show ${run.id} ${feedback.id}`, feedback.taskId, feedback.nodeId);
     }
     for (const candidate of candidatesOf(run)) {
         const scores = candidate.scores || [];
         if (candidate.status === "rejected" || candidate.status === "failed")
-            add(String(candidate.id), "candidate", String(candidate.status), candidate.feedbackIds?.[0] || `candidate ${candidate.id} is ${candidate.status}`, `node scripts/cw.js candidate show ${run.id} ${candidate.id}`, candidate.workerId, candidate.taskId);
+            add(String(candidate.id), "candidate", String(candidate.status), candidate.feedbackIds?.[0] || `candidate ${candidate.id} is ${candidate.status}`, `cw candidate show ${run.id} ${candidate.id}`, candidate.workerId, candidate.taskId);
         if (!scores.length && candidate.status !== "rejected" && candidate.status !== "failed")
-            add(String(candidate.id), "candidate-score-gap", String(candidate.status), `candidate ${candidate.id} has no score`, `node scripts/cw.js multi-agent score ${run.id} --candidate ${candidate.id} --evidence <path-or-ref>`, candidate.workerId, candidate.taskId);
+            add(String(candidate.id), "candidate-score-gap", String(candidate.status), `candidate ${candidate.id} has no score`, `cw multi-agent score ${run.id} --candidate ${candidate.id} --evidence <path-or-ref>`, candidate.workerId, candidate.taskId);
         if (!candidate.verifierNodeId)
-            add(`${candidate.id}:verifier`, "candidate-verifier-gap", String(candidate.status), `candidate ${candidate.id} has no verifier gate`, `node scripts/cw.js candidate show ${run.id} ${candidate.id}`, candidate.workerId, candidate.taskId);
+            add(`${candidate.id}:verifier`, "candidate-verifier-gap", String(candidate.status), `candidate ${candidate.id} has no verifier gate`, `cw candidate show ${run.id} ${candidate.id}`, candidate.workerId, candidate.taskId);
     }
     if (candidatesOf(run).some((candidate) => (candidate.scores || []).length) && !selectionsOf(run).length) {
-        add("selection-gap", "selection", "missing", "scored candidates exist but no selection is recorded", `node scripts/cw.js multi-agent select ${run.id} --candidate <candidate-id> --reason "<rationale>"`);
+        add("selection-gap", "selection", "missing", "scored candidates exist but no selection is recorded", `cw multi-agent select ${run.id} --candidate <candidate-id> --reason "<rationale>"`);
     }
     for (const dep of dependencies.filter((entry) => entry.status === "blocked"))
-        add(dep.id, "ambiguous-dependency", dep.status, dep.reason || "dependency is blocked", dep.nextCommand || `node scripts/cw.js multi-agent status ${run.id} --json`);
-    const readySelection = selectionsOf(run).find((selection) => !commitsOf(run).some((commit) => commit.selectionId === selection.id && commit.verifierGated));
+        add(dep.id, "ambiguous-dependency", dep.status, dep.reason || "dependency is blocked", dep.nextCommand || `cw multi-agent status ${run.id} --json`);
+    const readySelection = firstUngatedSelection(run);
     if (readySelection)
-        add(String(readySelection.id), "commit-gate", "not-ready", `selection ${readySelection.id} has no verifier-gated commit`, `node scripts/cw.js commit ${run.id} --selection ${readySelection.id} --reason "<verified rationale>"`, readySelection.candidateId);
-    return rows.filter(uniqueByFailure).sort((left, right) => (0, collate_1.stableCompare)(left.kind, right.kind) || (0, collate_1.stableCompare)(left.id, right.id));
+        add(String(readySelection.id), "commit-gate", "not-ready", `selection ${readySelection.id} has no verifier-gated commit`, `cw commit ${run.id} --selection ${readySelection.id} --reason "<verified rationale>"`, readySelection.candidateId);
+    return uniqueByFailure(rows).sort((left, right) => (0, collate_1.stableCompare)(left.kind, right.kind) || (0, collate_1.stableCompare)(left.id, right.id));
 }
 function deriveEvidence(run) {
     const rows = new Map();
@@ -493,9 +506,18 @@ function readScores(run, candidateId) {
         .sort()
         .map((file) => JSON.parse(fs.readFileSync(path.join(dir, file), "utf8")));
 }
+/** The first selection with no verifier-gated commit yet, if any -- shared
+ *  by deriveFailures and readyCommitCommand. A Set of already-gated
+ *  selection ids, built once, replaces re-scanning ALL commits per
+ *  selection (O(selections x commits) otherwise -- the same array-scan-
+ *  per-item shape 024b007 fixed for phase/task selection). */
+function firstUngatedSelection(run) {
+    const gatedSelectionIds = new Set(commitsOf(run).filter((commit) => commit.verifierGated).map((commit) => commit.selectionId));
+    return selectionsOf(run).find((entry) => !gatedSelectionIds.has(entry.id));
+}
 function readyCommitCommand(run) {
-    const selection = selectionsOf(run).find((entry) => !commitsOf(run).some((commit) => commit.selectionId === entry.id && commit.verifierGated));
-    return selection ? `node scripts/cw.js commit ${run.id} --selection ${selection.id} --reason "<verified rationale>"` : undefined;
+    const selection = firstUngatedSelection(run);
+    return selection ? `cw commit ${run.id} --selection ${selection.id} --reason "<verified rationale>"` : undefined;
 }
 function normalizeEvidenceStatus(row) {
     if (row.rejectedBy.length)
@@ -559,16 +581,36 @@ function isTerminal(status) {
     return status === "completed" || status === "failed" || status === "cancelled";
 }
 function unique(values) {
-    return values.filter(Boolean).filter(uniqueFilter).sort();
-}
-function uniqueFilter(value, index, values) {
-    return values.indexOf(value) === index;
-}
-function uniqueById(value, index, values) {
-    return values.findIndex((entry) => entry.id === value.id) === index;
+    return [...new Set(values.filter(Boolean))].sort();
+}
+// Each dedup below keeps the FIRST occurrence of a duplicate key, same as
+// the `values.findIndex(...) === index` shape it replaces -- a Set of seen
+// keys does this in one O(N) pass instead of an O(N) findIndex per item
+// (O(N^2) total; this was the dominant cost of deriveDependencies/
+// deriveFailures at large membership counts, found while pinning perf
+// cycle P1-1's review-fix regression test).
+function uniqueById(values) {
+    const seen = new Set();
+    const result = [];
+    for (const value of values) {
+        if (seen.has(value.id))
+            continue;
+        seen.add(value.id);
+        result.push(value);
+    }
+    return result;
 }
-function uniqueByFailure(value, index, values) {
-    return values.findIndex((entry) => entry.id === value.id && entry.kind === value.kind) === index;
+function uniqueByFailure(values) {
+    const seen = new Set();
+    const result = [];
+    for (const value of values) {
+        const key = `${value.id}\0${value.kind}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        result.push(value);
+    }
+    return result;
 }
 function uniqueEdges(edges) {
     const seen = new Set();

package/dist/shell/node-store.js

@@ -94,12 +94,16 @@ function replayNodeSnapshot(run, snapshot, options = {}) {
             : (replay) => (0, fs_atomic_1.writeJson)(path.join(snapshotDir(run, snapshot.nodeId), "replays", `${replay.replayId}.json`), replay),
     });
 }
-/** Scans every dir under `nodes/snapshots/` for `<snapshotId>.json`. */
+/** Scans every dir under `nodes/snapshots/` for `<snapshotId>.json`. Runs
+ *  `snapshotId` through `safeFileName` first (matching every write-side path
+ *  segment in this file) so a traversal-shaped id can never escape `nodeDir`
+ *  into an arbitrary file elsewhere on disk. */
 function readNodeSnapshot(run, snapshotId) {
     const root = snapshotsRoot(run);
+    const safeId = (0, fs_atomic_1.safeFileName)(snapshotId);
     if (fs.existsSync(root)) {
         for (const nodeDir of fs.readdirSync(root)) {
-            const file = path.join(root, nodeDir, `${snapshotId}.json`);
+            const file = path.join(root, nodeDir, `${safeId}.json`);
             if (fs.existsSync(file))
                 return (0, validation_1.validateNodeSnapshot)(JSON.parse(fs.readFileSync(file, "utf8")));
         }
@@ -108,12 +112,14 @@ function readNodeSnapshot(run, snapshotId) {
         freshness: "absent",
     });
 }
-/** Scans every dir under `nodes/snapshots/<nodeDir>/replays/` for `<replayId>.json`. */
+/** Scans every dir under `nodes/snapshots/<nodeDir>/replays/` for
+ *  `<replayId>.json`. Same `safeFileName` guard as `readNodeSnapshot`. */
 function readNodeReplay(run, replayId) {
     const root = snapshotsRoot(run);
+    const safeId = (0, fs_atomic_1.safeFileName)(replayId);
     if (fs.existsSync(root)) {
         for (const nodeDir of fs.readdirSync(root)) {
-            const file = path.join(root, nodeDir, "replays", `${replayId}.json`);
+            const file = path.join(root, nodeDir, "replays", `${safeId}.json`);
             if (fs.existsSync(file))
                 return (0, validation_1.validateNodeReplayRun)(JSON.parse(fs.readFileSync(file, "utf8")));
         }

package/dist/shell/observability.js

@@ -431,7 +431,7 @@ function deriveMetricsReport(run, options) {
         collaboration: deriveCollaborationMetrics(run),
         nextAction: totals.unreportedUnits > 0 && totals.attestedUnits === 0
             ? "No attested usage yet — record host usage on result/worker intake (cw result ... --usage-input-tokens N --usage-output-tokens M --usage-model ID)."
-            : `node scripts/cw.js metrics show ${run.id} --json`,
+            : `cw metrics show ${run.id} --json`,
     };
 }
 function metricsDir(run) {

package/dist/shell/operator-ux-text.js

@@ -152,7 +152,7 @@ function formatMultiAgentTrustAudit(view) {
         ...formatAuditEventRows(arrayView(view.policyViolations)),
         "",
         "Next Action",
-        `  ${String(view.nextAction || `node scripts/cw.js audit multi-agent ${String(view.runId || "<run-id>")} --json`)}`,
+        `  ${String(view.nextAction || `cw audit multi-agent ${String(view.runId || "<run-id>")} --json`)}`,
     ].join("\n");
 }
 /** `Topologies` panel — port of the old build's formatTopologyPanel
@@ -299,27 +299,27 @@ function formatOperatorReport(summary, evidencePaths) {
         (0, multi_agent_operator_ux_1.formatMultiAgentEvidence)(summary.multiAgentOperator.evidence),
         "",
         "Resource Commands",
-        `  node scripts/cw.js graph ${summary.runId}`,
-        `  node scripts/cw.js worker summary ${summary.runId}`,
-        `  node scripts/cw.js topology summary ${summary.runId}`,
-        `  node scripts/cw.js topology graph ${summary.runId}`,
-        `  node scripts/cw.js multi-agent summary ${summary.runId}`,
-        `  node scripts/cw.js multi-agent graph ${summary.runId}`,
-        `  node scripts/cw.js multi-agent dependencies ${summary.runId}`,
-        `  node scripts/cw.js multi-agent failures ${summary.runId}`,
-        `  node scripts/cw.js multi-agent evidence ${summary.runId}`,
-        `  node scripts/cw.js blackboard summary ${summary.runId}`,
-        `  node scripts/cw.js blackboard graph ${summary.runId}`,
-        `  node scripts/cw.js coordinator summary ${summary.runId}`,
-        `  node scripts/cw.js candidate summary ${summary.runId}`,
-        `  node scripts/cw.js feedback summary ${summary.runId}`,
-        `  node scripts/cw.js commit summary ${summary.runId}`,
-        `  node scripts/cw.js audit summary ${summary.runId}`,
-        `  node scripts/cw.js audit provenance ${summary.runId}`,
-        `  node scripts/cw.js audit multi-agent ${summary.runId}`,
-        `  node scripts/cw.js audit policy ${summary.runId}`,
-        `  node scripts/cw.js audit blackboard ${summary.runId}`,
-        `  node scripts/cw.js audit judge ${summary.runId}`,
+        `  cw graph ${summary.runId}`,
+        `  cw worker summary ${summary.runId}`,
+        `  cw topology summary ${summary.runId}`,
+        `  cw topology graph ${summary.runId}`,
+        `  cw multi-agent summary ${summary.runId}`,
+        `  cw multi-agent graph ${summary.runId}`,
+        `  cw multi-agent dependencies ${summary.runId}`,
+        `  cw multi-agent failures ${summary.runId}`,
+        `  cw multi-agent evidence ${summary.runId}`,
+        `  cw blackboard summary ${summary.runId}`,
+        `  cw blackboard graph ${summary.runId}`,
+        `  cw coordinator summary ${summary.runId}`,
+        `  cw candidate summary ${summary.runId}`,
+        `  cw feedback summary ${summary.runId}`,
+        `  cw commit summary ${summary.runId}`,
+        `  cw audit summary ${summary.runId}`,
+        `  cw audit provenance ${summary.runId}`,
+        `  cw audit multi-agent ${summary.runId}`,
+        `  cw audit policy ${summary.runId}`,
+        `  cw audit blackboard ${summary.runId}`,
+        `  cw audit judge ${summary.runId}`,
     ].join("\n");
 }
 function groupBy(values, key) {

package/dist/shell/operator-ux.js

@@ -115,7 +115,7 @@ function summarizeRun(run) {
 function adviseNoRun() {
     return [
         {
-            command: "node scripts/cw.js plan <workflow-id> --repo <path>",
+            command: "cw plan <workflow-id> --repo <path>",
             reason: "No run id is available yet; create a workflow run before dispatching or recording evidence.",
             priority: "high",
         },
@@ -123,7 +123,8 @@ function adviseNoRun() {
 }
 function summarizePhases(run) {
     return run.phases.map((phase) => {
-        const phaseTasks = run.tasks.filter((t) => phase.taskIds.includes(t.id));
+        const taskIds = new Set(phase.taskIds);
+        const phaseTasks = run.tasks.filter((t) => taskIds.has(t.id));
         const byStatus = countBy(phaseTasks, (t) => t.status);
         return { id: phase.id, name: phase.name, status: phase.status, tasks: { total: phaseTasks.length, ...byStatus } };
     });
@@ -225,52 +226,52 @@ function adviseNextSteps(run, ctx) {
     const openFeedback = feedbackRecords.filter((record) => record.status === "open");
     if (openFeedback.length) {
         const feedback = openFeedback[0];
-        actions.push({ command: `node scripts/cw.js feedback show ${run.id} ${feedback.id}`, reason: `Open ${feedback.severity} ${feedback.classification} feedback should be inspected before more dispatch.`, priority: "high" });
-        actions.push({ command: `node scripts/cw.js feedback task ${run.id} ${feedback.id}`, reason: "Create a correction task if the feedback is actionable.", priority: "normal" });
+        actions.push({ command: `cw feedback show ${run.id} ${feedback.id}`, reason: `Open ${feedback.severity} ${feedback.classification} feedback should be inspected before more dispatch.`, priority: "high" });
+        actions.push({ command: `cw feedback task ${run.id} ${feedback.id}`, reason: "Create a correction task if the feedback is actionable.", priority: "normal" });
         return actions;
     }
     const failedWorker = ctx.workers.workers.find((w) => w.status === "failed" || w.status === "rejected");
     if (failedWorker) {
-        actions.push({ command: `node scripts/cw.js feedback list ${run.id}`, reason: `Worker ${failedWorker.id} is ${failedWorker.status}; inspect linked feedback before retrying.`, priority: "high" });
+        actions.push({ command: `cw feedback list ${run.id}`, reason: `Worker ${failedWorker.id} is ${failedWorker.status}; inspect linked feedback before retrying.`, priority: "high" });
         return actions;
     }
     if (ctx.tasks.running.length) {
         const worker = ctx.workers.workers.find((w) => w.status === "running" || w.status === "allocated");
-        actions.push({ command: worker ? `node scripts/cw.js worker manifest ${run.id} ${worker.id}` : `node scripts/cw.js worker list ${run.id}`, reason: "Running workers need their manifests inspected and final output recorded.", priority: "high" });
+        actions.push({ command: worker ? `cw worker manifest ${run.id} ${worker.id}` : `cw worker list ${run.id}`, reason: "Running workers need their manifests inspected and final output recorded.", priority: "high" });
         if (worker && worker.resultPath) {
-            actions.push({ command: `node scripts/cw.js worker output ${run.id} ${worker.id} ${worker.resultPath}`, reason: "Record the worker result after its result.md is ready.", priority: "normal" });
+            actions.push({ command: `cw worker output ${run.id} ${worker.id} ${worker.resultPath}`, reason: "Record the worker result after its result.md is ready.", priority: "normal" });
         }
         return actions;
     }
     if (ctx.tasks.pending.length) {
         const limit = Math.min(ctx.tasks.pending.length, run.workflow.limits?.maxConcurrentAgents || 4);
-        actions.push({ command: `node scripts/cw.js dispatch ${run.id} --limit ${limit}`, reason: `${ctx.tasks.pending.length} pending task(s) are ready for the active phase.`, priority: "high" });
+        actions.push({ command: `cw dispatch ${run.id} --limit ${limit}`, reason: `${ctx.tasks.pending.length} pending task(s) are ready for the active phase.`, priority: "high" });
         return actions;
     }
     const candidateRecords = (run.candidates || []);
     const selectionRecords = (run.candidateSelections || []);
     const completedWithoutCandidate = (run.tasks || []).find((task) => task.status === "completed" && task.workerId && !candidateRecords.some((candidate) => candidate.workerId === task.workerId));
     if (completedWithoutCandidate?.workerId) {
-        actions.push({ command: `node scripts/cw.js candidate register ${run.id} --worker ${completedWithoutCandidate.workerId}`, reason: "A completed worker result is available but has not been registered as a candidate.", priority: "high" });
+        actions.push({ command: `cw candidate register ${run.id} --worker ${completedWithoutCandidate.workerId}`, reason: "A completed worker result is available but has not been registered as a candidate.", priority: "high" });
         return actions;
     }
     const unscored = candidateRecords.find((candidate) => candidate.status === "registered" && !(candidate.scores || []).length);
     if (unscored) {
-        actions.push({ command: `node scripts/cw.js candidate score ${run.id} ${unscored.id} --criterion correctness=1 --evidence <path-or-locator>`, reason: "Registered candidates need score evidence before ranking or selection.", priority: "high" });
+        actions.push({ command: `cw candidate score ${run.id} ${unscored.id} --criterion correctness=1 --evidence <path-or-locator>`, reason: "Registered candidates need score evidence before ranking or selection.", priority: "high" });
         return actions;
     }
     const scoredWithoutSelection = candidateRecords.find((candidate) => candidate.status === "scored" && !selectionRecords.some((selection) => selection.candidateId === candidate.id));
     if (scoredWithoutSelection) {
-        actions.push({ command: `node scripts/cw.js candidate rank ${run.id}`, reason: "Scored candidates can be ranked before selection.", priority: "high" });
-        actions.push({ command: `node scripts/cw.js candidate select ${run.id} ${scoredWithoutSelection.id}`, reason: "Select the candidate once the ranking supports it.", priority: "normal" });
+        actions.push({ command: `cw candidate rank ${run.id}`, reason: "Scored candidates can be ranked before selection.", priority: "high" });
+        actions.push({ command: `cw candidate select ${run.id} ${scoredWithoutSelection.id}`, reason: "Select the candidate once the ranking supports it.", priority: "normal" });
         return actions;
     }
     if (ctx.candidates.readyForCommit.length) {
         const ready = ctx.candidates.readyForCommit[0];
-        actions.push({ command: `node scripts/cw.js commit ${run.id} --selection ${ready.selectionId}`, reason: "A verified selected candidate is ready for a verifier-gated commit.", priority: "high" });
+        actions.push({ command: `cw commit ${run.id} --selection ${ready.selectionId}`, reason: "A verified selected candidate is ready for a verifier-gated commit.", priority: "high" });
         return actions;
     }
-    actions.push({ command: `node scripts/cw.js report ${run.id} --show`, reason: "All tracked phases are complete or no further operator action is currently available.", priority: "normal" });
+    actions.push({ command: `cw report ${run.id} --show`, reason: "All tracked phases are complete or no further operator action is currently available.", priority: "normal" });
     return actions;
 }
 /** `cw operator status <id> --json` — a wider payload than `summarizeRun`

package/dist/shell/orchestrator.js

@@ -102,18 +102,22 @@ class CoolWorkflowRunner {
     /** `dispatch` — build the next dispatch manifest (persisting through
      *  createDispatchManifest's own writes) and checkpoint. */
     dispatch(runId, options = {}) {
-        const run = this.loadRun(runId);
-        const limit = numberOption(options.limit);
-        const manifest = (0, dispatch_1.createDispatchManifest)(run, limit, {
-            sandboxProfileId: stringOption(options.sandbox) || stringOption(options.sandboxProfile) || stringOption(options.sandboxProfileId),
-            backendId: stringOption(options.backend) || stringOption(options.backendId) || stringOption(options.executionBackend),
-            multiAgentRunId: stringOption(options.multiAgentRun || options.multiAgentRunId || options["multi-agent-run"]),
-            multiAgentGroupId: stringOption(options.multiAgentGroup || options.multiAgentGroupId || options.group || options["multi-agent-group"]),
-            multiAgentRoleId: stringOption(options.multiAgentRole || options.multiAgentRoleId || options.role || options["multi-agent-role"]),
-            multiAgentFanoutId: stringOption(options.multiAgentFanout || options.multiAgentFanoutId || options.fanout || options["multi-agent-fanout"]),
+        // Hold the state.json lock across the whole load -> change -> save so a
+        // concurrent run mutation cannot drop this dispatch (lost-update class,
+        // matching pipeline-cli.ts's dispatchRun).
+        return (0, run_store_2.withRunStateLock)(runId, this.cwd(), (run) => {
+            const limit = numberOption(options.limit);
+            const manifest = (0, dispatch_1.createDispatchManifest)(run, limit, {
+                sandboxProfileId: stringOption(options.sandbox) || stringOption(options.sandboxProfile) || stringOption(options.sandboxProfileId),
+                backendId: stringOption(options.backend) || stringOption(options.backendId) || stringOption(options.executionBackend),
+                multiAgentRunId: stringOption(options.multiAgentRun || options.multiAgentRunId || options["multi-agent-run"]),
+                multiAgentGroupId: stringOption(options.multiAgentGroup || options.multiAgentGroupId || options.group || options["multi-agent-group"]),
+                multiAgentRoleId: stringOption(options.multiAgentRole || options.multiAgentRoleId || options.role || options["multi-agent-role"]),
+                multiAgentFanoutId: stringOption(options.multiAgentFanout || options.multiAgentFanoutId || options.fanout || options["multi-agent-fanout"]),
+            });
+            (0, run_store_2.saveCheckpoint)(run);
+            return manifest;
         });
-        (0, run_store_2.saveCheckpoint)(run);
-        return manifest;
     }
     /** `showWorkerManifest` — write + return a worker's manifest. */
     showWorkerManifest(runId, workerId) {
@@ -126,10 +130,13 @@ class CoolWorkflowRunner {
     /** `recordWorkerOutput` — accept a worker's result and checkpoint. Mirrors
      *  v2's workerOutputCli: recordWorkerOutput + saveCheckpoint. */
     recordWorkerOutput(runId, workerId, resultPath, options = {}) {
-        const run = this.loadRun(runId);
-        const output = (0, worker_isolation_1.recordWorkerOutput)(run, workerId, this.resolveFromBase(resultPath), options);
-        (0, run_store_2.saveCheckpoint)(run);
-        return output;
+        // Hold the state.json lock across the whole load -> change -> save so a
+        // concurrent run mutation cannot drop this worker output (lost-update class).
+        return (0, run_store_2.withRunStateLock)(runId, this.cwd(), (run) => {
+            const output = (0, worker_isolation_1.recordWorkerOutput)(run, workerId, this.resolveFromBase(resultPath), options);
+            (0, run_store_2.saveCheckpoint)(run);
+            return output;
+        });
     }
     /** `auditSummary` — the trust-audit rollup. */
     auditSummary(runId) {
@@ -172,29 +179,33 @@ class CoolWorkflowRunner {
      *  `{ runId, commit }` to match the old orchestrator's shape (the scripts
      *  read `commitResult.commit`). */
     commit(runId, input = {}) {
-        const run = this.loadRun(runId);
-        const options = typeof input === "string" ? { reason: input } : input;
-        const allowCheckpoint = Boolean(options.allowUnverifiedCheckpoint || options["allow-unverified-checkpoint"]);
-        const hasGateOption = Boolean(options.verifier || options.verifierNode || options["verifier-node"] || options.candidate || options.selection);
-        try {
-            const commit = (0, commit_1.commitState)(run, {
-                reason: stringOption(options.reason) || "manual",
-                verifierNodeId: stringOption(options.verifier) || stringOption(options.verifierNode) || stringOption(options["verifier-node"]),
-                candidateId: stringOption(options.candidate),
-                selectionId: stringOption(options.selection),
-                verifierGated: hasGateOption || !allowCheckpoint,
-                allowUnverifiedCheckpoint: allowCheckpoint,
-                source: "cli",
-            });
-            (0, report_1.writeReport)(run);
-            (0, run_store_2.saveCheckpoint)(run);
-            return { runId: run.id, commit };
-        }
-        catch (error) {
-            (0, report_1.writeReport)(run);
-            (0, run_store_2.saveCheckpoint)(run);
-            throw error;
-        }
+        // Hold the state.json lock across the whole load -> commit -> save (both
+        // the success and the fail-closed catch persist) so a concurrent run
+        // mutation cannot drop this commit (lost-update class).
+        return (0, run_store_2.withRunStateLock)(runId, this.cwd(), (run) => {
+            const options = typeof input === "string" ? { reason: input } : input;
+            const allowCheckpoint = Boolean(options.allowUnverifiedCheckpoint || options["allow-unverified-checkpoint"]);
+            const hasGateOption = Boolean(options.verifier || options.verifierNode || options["verifier-node"] || options.candidate || options.selection);
+            try {
+                const commit = (0, commit_1.commitState)(run, {
+                    reason: stringOption(options.reason) || "manual",
+                    verifierNodeId: stringOption(options.verifier) || stringOption(options.verifierNode) || stringOption(options["verifier-node"]),
+                    candidateId: stringOption(options.candidate),
+                    selectionId: stringOption(options.selection),
+                    verifierGated: hasGateOption || !allowCheckpoint,
+                    allowUnverifiedCheckpoint: allowCheckpoint,
+                    source: "cli",
+                });
+                (0, report_1.writeReport)(run);
+                (0, run_store_2.saveCheckpoint)(run);
+                return { runId: run.id, commit };
+            }
+            catch (error) {
+                (0, report_1.writeReport)(run);
+                (0, run_store_2.saveCheckpoint)(run);
+                throw error;
+            }
+        });
     }
     /** `report` — write the run's report.md; returns `{ path }` (old shape). */
     report(runId) {