cool-workflow 0.2.1 → 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

@@ -62,6 +62,7 @@ const coordinator_io_1 = require("./coordinator-io");
 const multi_agent_io_1 = require("./multi-agent-io");
 const topology_io_1 = require("./topology-io");
 const trust_audit_1 = require("./trust-audit");
+const collate_1 = require("../core/util/collate");
 function maOf(run) {
     return run.multiAgent || {};
 }
@@ -105,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(),
@@ -260,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)) {
@@ -275,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) => left.from.localeCompare(right.from) || left.to.localeCompare(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 = [];
@@ -283,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) => left.kind.localeCompare(right.kind) || left.id.localeCompare(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();
@@ -442,7 +456,7 @@ function deriveEvidence(run) {
     return [...rows.values()]
         .map(normalizeEvidenceStatus)
         .map(withDisposition)
-        .sort((left, right) => statusRank(left.status) - statusRank(right.status) || left.id.localeCompare(right.id));
+        .sort((left, right) => statusRank(left.status) - statusRank(right.status) || (0, collate_1.stableCompare)(left.id, right.id));
 }
 function formatDependencies(rows) {
     const lines = ["Dependencies"];
@@ -492,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)
@@ -558,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

@@ -66,6 +66,7 @@ const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
 const fs_atomic_1 = require("./fs-atomic");
 const telemetry_ledger_io_1 = require("./telemetry-ledger-io");
+const collate_1 = require("../core/util/collate");
 exports.METRICS_SCHEMA_VERSION = 1;
 const VERIFIER_PASS_STATUSES = new Set(["verified", "completed", "committed"]);
 const VERIFIER_FAIL_STATUSES = new Set(["failed", "rejected", "blocked"]);
@@ -105,22 +106,22 @@ function usageKey(usage) {
 }
 function fingerprintMetricsSource(run) {
     const parts = [`id:${run.id}`, `createdAt:${run.createdAt}`, `updatedAt:${run.updatedAt}`, `app:${run.workflow.app?.id || run.workflow.id}`];
-    for (const task of [...run.tasks].sort((a, b) => a.id.localeCompare(b.id))) {
+    for (const task of [...run.tasks].sort((a, b) => (0, collate_1.stableCompare)(a.id, b.id))) {
         parts.push(`task:${task.id}:${task.status}:${task.dispatchedAt || "-"}:${task.completedAt || "-"}:${usageKey(task.usage)}:${task.backendId || "-"}`);
     }
-    for (const worker of [...(run.workers || [])].sort((a, b) => a.id.localeCompare(b.id))) {
+    for (const worker of [...(run.workers || [])].sort((a, b) => (0, collate_1.stableCompare)(a.id, b.id))) {
         parts.push(`worker:${worker.id}:${worker.status}:${worker.output?.recordedAt || "-"}:${usageKey(worker.usage)}:${worker.backendId || "-"}`);
     }
-    for (const node of [...(run.nodes || [])].filter((n) => n.kind === "verifier").sort((a, b) => a.id.localeCompare(b.id))) {
+    for (const node of [...(run.nodes || [])].filter((n) => n.kind === "verifier").sort((a, b) => (0, collate_1.stableCompare)(a.id, b.id))) {
         parts.push(`verifier:${node.id}:${node.status}`);
     }
-    for (const cand of [...(run.candidates || [])].sort((a, b) => a.id.localeCompare(b.id))) {
+    for (const cand of [...(run.candidates || [])].sort((a, b) => (0, collate_1.stableCompare)(a.id, b.id))) {
         parts.push(`candidate:${cand.id}:${cand.status}`);
     }
-    for (const fb of [...(run.feedback || [])].sort((a, b) => a.id.localeCompare(b.id))) {
+    for (const fb of [...(run.feedback || [])].sort((a, b) => (0, collate_1.stableCompare)(a.id, b.id))) {
         parts.push(`feedback:${fb.id}:${fb.status}`);
     }
-    for (const m of [...(run.multiAgent?.memberships || [])].sort((a, b) => a.id.localeCompare(b.id))) {
+    for (const m of [...(run.multiAgent?.memberships || [])].sort((a, b) => (0, collate_1.stableCompare)(a.id, b.id))) {
         parts.push(`membership:${m.id}:${m.status}`);
     }
     return fingerprintStrings(parts);
@@ -148,7 +149,7 @@ function usageUnits(run) {
             units.push({ unit: task.id, kind: "task", usage: task.usage });
         }
     }
-    return units.sort((a, b) => a.unit.localeCompare(b.unit));
+    return units.sort((a, b) => (0, collate_1.stableCompare)(a.unit, b.unit));
 }
 function tokenTotal(usage) {
     if (typeof usage.totalTokens === "number")
@@ -349,12 +350,12 @@ function deriveCandidateAcceptanceRate(run) {
 function taskRows(run) {
     return run.tasks
         .map((task) => ({ id: task.id, kind: "task", status: task.status, duration: duration(task.dispatchedAt, task.completedAt) }))
-        .sort((a, b) => a.id.localeCompare(b.id));
+        .sort((a, b) => (0, collate_1.stableCompare)(a.id, b.id));
 }
 function workerRows(run) {
     return (run.workers || [])
         .map((worker) => ({ id: worker.id, kind: "worker", status: worker.status, duration: duration(worker.createdAt, workerEndAt(worker)) }))
-        .sort((a, b) => a.id.localeCompare(b.id));
+        .sort((a, b) => (0, collate_1.stableCompare)(a.id, b.id));
 }
 function targetCreatedAt(run, target) {
     if (target.kind === "candidate")
@@ -430,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) {
@@ -541,7 +542,7 @@ function deriveMetricsSummary(inputs, options) {
         const report = deriveMetricsReport(input.run, { now: options.now, policy: options.policy, persistedFingerprint: input.persistedFingerprint });
         perRun.push({ report, ref: { runId: report.runId, repo: input.repo, app: report.scope.app, backendIds: report.scope.backendIds, freshness: report.freshness.status, rates: report.rates, usage: report.usage, cost: report.cost } });
     }
-    perRun.sort((a, b) => a.report.runId.localeCompare(b.report.runId));
+    perRun.sort((a, b) => (0, collate_1.stableCompare)(a.report.runId, b.report.runId));
     const groupBy = (keyOf) => {
         const map = new Map();
         for (const { report } of perRun) {
@@ -552,7 +553,7 @@ function deriveMetricsSummary(inputs, options) {
             }
         }
         return [...map.entries()]
-            .sort((a, b) => a[0].localeCompare(b[0]))
+            .sort((a, b) => (0, collate_1.stableCompare)(a[0], b[0]))
             .map(([key, reports]) => ({
             key,
             runCount: reports.length,

package/dist/shell/onramp.js

@@ -294,10 +294,26 @@ function evaluateOnrampContract(files, options = {}) {
     const scriptFiles = normalized.filter((file) => file.startsWith("plugins/cool-workflow/scripts/"));
     const surfaceFiles = normalized.filter(isSurfaceFile);
     const smokeFiles = normalized.filter((file) => /^plugins\/cool-workflow\/test\/.+-smoke\.js$/.test(file));
+    // WP1.1 (#360) restored a second, parallel test layer: pure `core/`
+    // logic proven by `test/*.test.js` under `npm run test:unit`, run and
+    // gated separately from the black-box `test/*-smoke.js` suite. A cycle
+    // that proves its fix with a unit test only (no smoke touched) is a
+    // real, complete cycle — the gate must accept either kind, not just
+    // the one that existed before the unit-test layer came back.
+    const unitTestFiles = normalized.filter((file) => /^plugins\/cool-workflow\/test\/.+\.test\.js$/.test(file));
+    // The black-box conformance suite (v2/conformance/cases/*.case.js) is a
+    // third, equally real proof layer — CI-gated on every push, and the one
+    // North Star Track C leans on. A cycle proven end to end by a new or
+    // changed conformance case (with no test/*-smoke.js or test/*.test.js
+    // touched) is a real, complete cycle too.
+    const conformanceCaseFiles = normalized.filter((file) => /^v2\/conformance\/cases\/.+\.case\.js$/.test(file));
     const docFiles = normalized.filter(isDocFile);
     const iterationFiles = normalized.filter((file) => file === "ITERATION_LOG.md");
     const sourceAppOrScript = runtimeFiles.length > 0 || typeFiles.length > 0 || appFiles.length > 0 || scriptFiles.length > 0;
-    if ((runtimeFiles.length > 0 || appFiles.length > 0) && smokeFiles.length === 0) {
+    if ((runtimeFiles.length > 0 || appFiles.length > 0) &&
+        smokeFiles.length === 0 &&
+        unitTestFiles.length === 0 &&
+        conformanceCaseFiles.length === 0) {
         issues.push({
             code: "runtime-smoke-required",
             detail: "Runtime or app changes must include at least one smoke test change.",

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

@@ -24,8 +24,9 @@ exports.formatCandidateSummaryText = formatCandidateSummaryText;
 exports.formatFeedbackSummaryText = formatFeedbackSummaryText;
 const term_1 = require("./term");
 const multi_agent_operator_ux_1 = require("./multi-agent-operator-ux");
+const collate_1 = require("../core/util/collate");
 function formatCounts(counts) {
-    const entries = Object.entries(counts).sort(([a], [b]) => a.localeCompare(b));
+    const entries = Object.entries(counts).sort(([a], [b]) => (0, collate_1.stableCompare)(a, b));
     if (!entries.length)
         return "none";
     return entries.map(([k, v]) => `${k}=${v}`).join(", ");
@@ -151,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
@@ -298,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

@@ -66,6 +66,7 @@ const coordinator_io_1 = require("./coordinator-io");
 const topology_io_1 = require("./topology-io");
 const multi_agent_operator_ux_1 = require("./multi-agent-operator-ux");
 const trust_policy_io_1 = require("./trust-policy-io");
+const collate_1 = require("../core/util/collate");
 function countBy(values, key) {
     const counts = {};
     for (const value of values)
@@ -114,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",
         },
@@ -122,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 } };
     });
@@ -143,8 +145,8 @@ function summarizeTasks(tasks) {
  *  verb and operator panel both read. */
 function summarizeOperatorCandidates(run) {
     const counts = (0, candidate_scoring_io_1.summarizeCandidates)(run);
-    const candidates = [...(run.candidates || [])].sort((left, right) => left.id.localeCompare(right.id));
-    const selections = [...(run.candidateSelections || [])].sort((left, right) => left.id.localeCompare(right.id));
+    const candidates = [...(run.candidates || [])].sort((left, right) => (0, collate_1.stableCompare)(left.id, right.id));
+    const selections = [...(run.candidateSelections || [])].sort((left, right) => (0, collate_1.stableCompare)(left.id, right.id));
     const commits = run.commits || [];
     const selectedIds = new Set(selections.map((selection) => selection.candidateId));
     const readyForCommit = selections
@@ -190,7 +192,7 @@ function summarizeOperatorFeedback(run) {
     };
 }
 function summarizeOperatorCommits(run) {
-    const commits = [...(run.commits || [])].sort((left, right) => left.createdAt.localeCompare(right.createdAt) || left.id.localeCompare(right.id));
+    const commits = [...(run.commits || [])].sort((left, right) => (0, collate_1.stableCompare)(left.createdAt, right.createdAt) || (0, collate_1.stableCompare)(left.id, right.id));
     return {
         total: commits.length,
         verifierGated: commits.filter((c) => c.verifierGated).length,
@@ -200,7 +202,7 @@ function summarizeOperatorCommits(run) {
     };
 }
 function summarizeOperatorWorkers(run) {
-    const workers = (run.workers || []).slice().sort((a, b) => a.id.localeCompare(b.id));
+    const workers = (run.workers || []).slice().sort((a, b) => (0, collate_1.stableCompare)(a.id, b.id));
     return {
         total: workers.length,
         byStatus: countBy(workers, (w) => w.status),
@@ -224,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`
@@ -425,7 +427,7 @@ function buildOperatorGraph(run) {
         addNode(node.id, node.kind, node.status, node.label, node.path);
     for (const edge of blackboardGraph.edges)
         addEdge(edge.from, edge.to, edge.label);
-    const sortedNodes = [...nodes.values()].sort((a, b) => a.kind.localeCompare(b.kind) || a.id.localeCompare(b.id));
-    const sortedEdges = edges.slice().sort((a, b) => a.from.localeCompare(b.from) || a.to.localeCompare(b.to) || (a.label || "").localeCompare(b.label || ""));
+    const sortedNodes = [...nodes.values()].sort((a, b) => (0, collate_1.stableCompare)(a.kind, b.kind) || (0, collate_1.stableCompare)(a.id, b.id));
+    const sortedEdges = edges.slice().sort((a, b) => (0, collate_1.stableCompare)(a.from, b.from) || (0, collate_1.stableCompare)(a.to, b.to) || (0, collate_1.stableCompare)(a.label || "", b.label || ""));
     return { runId: run.id, nodes: sortedNodes, edges: sortedEdges };
 }