cool-workflow 0.2.1 → 0.2.2

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")
@@ -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(", ");

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)
@@ -143,8 +144,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 +191,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 +201,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),
@@ -425,7 +426,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 };
 }

package/dist/shell/pipeline-cli.js

@@ -552,84 +552,94 @@ function quickstartRun(args) {
 }
 function dispatchRun(args) {
     const runId = String(args.runId);
-    const run = (0, run_store_1.loadRunFromCwd)(runId, invocationCwd(args));
-    // parseArgv keys long flags in kebab-case; accept camelCase as a fallback.
-    const flag = (kebab, camel) => {
-        const v = args[kebab] ?? args[camel];
-        return typeof v === "string" && v.trim() ? v : undefined;
-    };
-    const manifest = (0, dispatch_1.createDispatchManifest)(run, args.limit !== undefined ? Number(args.limit) : undefined, {
-        sandboxProfileId: typeof args.sandbox === "string" ? args.sandbox : undefined,
-        sandbox: typeof args.sandbox === "string" ? args.sandbox : undefined,
-        backendId: typeof args.backend === "string" ? args.backend : undefined,
-        multiAgentRunId: flag("multi-agent-run", "multiAgentRun"),
-        multiAgentGroupId: flag("multi-agent-group", "multiAgentGroup"),
-        multiAgentRoleId: flag("multi-agent-role", "multiAgentRole"),
-        multiAgentFanoutId: flag("multi-agent-fanout", "multiAgentFanout"),
+    // The whole load -> change -> save cycle holds the state.json lock so a
+    // concurrent dispatch/result on the same run cannot drop this update.
+    return (0, run_store_1.withRunStateLock)(runId, invocationCwd(args), (run) => {
+        // parseArgv keys long flags in kebab-case; accept camelCase as a fallback.
+        const flag = (kebab, camel) => {
+            const v = args[kebab] ?? args[camel];
+            return typeof v === "string" && v.trim() ? v : undefined;
+        };
+        const manifest = (0, dispatch_1.createDispatchManifest)(run, args.limit !== undefined ? Number(args.limit) : undefined, {
+            sandboxProfileId: typeof args.sandbox === "string" ? args.sandbox : undefined,
+            sandbox: typeof args.sandbox === "string" ? args.sandbox : undefined,
+            backendId: typeof args.backend === "string" ? args.backend : undefined,
+            multiAgentRunId: flag("multi-agent-run", "multiAgentRun"),
+            multiAgentGroupId: flag("multi-agent-group", "multiAgentGroup"),
+            multiAgentRoleId: flag("multi-agent-role", "multiAgentRole"),
+            multiAgentFanoutId: flag("multi-agent-fanout", "multiAgentFanout"),
+        });
+        if (manifest.dispatchId) {
+            (0, commit_1.commitState)(run, `dispatch:${manifest.dispatchId}`);
+            (0, run_store_1.saveCheckpoint)(run);
+            (0, report_1.writeReport)(run);
+        }
+        return manifest;
     });
-    if (manifest.dispatchId) {
-        (0, commit_1.commitState)(run, `dispatch:${manifest.dispatchId}`);
-        (0, run_store_1.saveCheckpoint)(run);
-        (0, report_1.writeReport)(run);
-    }
-    return manifest;
 }
 function recordResultRun(args) {
     const runId = String(args.runId);
     const taskId = String(args.taskId);
     const resultPath = String(args.resultPath);
-    const run = (0, run_store_1.loadRunFromCwd)(runId, invocationCwd(args));
-    const task = run.tasks.find((t) => t.id === taskId);
-    if (!task || !task.workerId)
-        throw new Error(`Unknown task id for run ${runId}: ${taskId}`);
-    const absolute = path.resolve(resultPath);
-    // A result path inside a system directory is never accepted (POLA): the
-    // operator file gets copied into the worker's result.md, so a /etc/passwd
-    // source would smuggle system content into a run. Byte-behavior port of the
-    // old build's recordResult system-directory blacklist.
-    if (/^\/(etc|bin|sbin|usr|Library|System|Applications|boot|dev|proc|sys|root|var\/log|var\/run)\//.test(absolute)) {
-        throw new Error(`Result path must not be a system directory: ${resultPath}`);
-    }
-    if (!fs.existsSync(absolute))
-        throw new Error(`Result file does not exist: ${resultPath}`);
-    const workerId = String(task.workerId);
-    // Host-attested `cw result <run> <task> <file>` intake: the operator hands CW
-    // an EXTERNAL result file that lives OUTSIDE the worker's read-only write
-    // boundary. The old task-level recordResult (lifecycle-operations.ts:279-280)
-    // COPIED that external file into the run's results area and recorded the
-    // internal path — it never ran the external path through validateSandboxWrite.
-    // v2 collapsed the two intakes into recordWorkerOutput, which sandbox-validates
-    // its input against the worker boundary, so a bare external path is rejected
-    // ("write path is outside sandbox profile <id>"). Restore the copy-in: stage
-    // the operator file at the worker's OWN result.md (which IS inside the write
-    // boundary), then record that internal path exactly like a driven worker.
-    const manifest = (0, worker_isolation_1.showWorkerManifest)(run, workerId);
-    fs.mkdirSync(path.dirname(manifest.resultPath), { recursive: true });
-    fs.copyFileSync(absolute, manifest.resultPath);
-    const output = (0, worker_isolation_1.recordWorkerOutput)(run, workerId, manifest.resultPath);
-    // Host-attested token usage (v0.1.31): record it verbatim as provenance when
-    // the operator supplied `--usage-*` flags; CW never synthesizes usage. The old
-    // task-level recordResult set `task.usage = usage` (lifecycle-operations.ts:286)
-    // and its unit was the TASK. v2 records through recordWorkerOutput, which gives
-    // the worker an `output` record — so the observability usage UNIT becomes the
-    // WORKER (deriveUsageTotals reads worker.usage for workers with output, and
-    // EXCLUDES that task). Attach the usage to the worker scope so the report counts
-    // it as an attested unit; also stamp task.usage for byte-parity with the old
-    // task-level record.
-    const usage = (0, observability_1.parseUsageFromArgs)(args, new Date().toISOString());
-    if (usage) {
-        task.usage = usage;
-        const scope = (0, worker_isolation_1.getWorkerScope)(run, workerId);
-        if (scope)
-            scope.usage = usage;
-    }
-    // Byte-exact to the old build's orchestrator recordWorkerOutput()
-    // wrapper: an accepted result is its own checkpoint commit, not just a
-    // bare saveCheckpoint (SPEC/pipeline-run.md's persist-ordering rule).
-    (0, commit_1.commitState)(run, `worker:${workerId}:result`);
-    (0, run_store_1.saveCheckpoint)(run);
-    (0, report_1.writeReport)(run);
-    return output;
+    // Two processes recording results for two tasks of the SAME run used to
+    // race: both loaded, and the later saveCheckpoint dropped the earlier
+    // task's completion. The lock now covers the whole cycle.
+    return (0, run_store_1.withRunStateLock)(runId, invocationCwd(args), (run) => {
+        const task = run.tasks.find((t) => t.id === taskId);
+        if (!task || !task.workerId)
+            throw new Error(`Unknown task id for run ${runId}: ${taskId}`);
+        const absolute = path.resolve(resultPath);
+        // A result path inside a system directory is never accepted (POLA): the
+        // operator file gets copied into the worker's result.md, so a /etc/passwd
+        // source would smuggle system content into a run. Byte-behavior port of the
+        // old build's recordResult system-directory blacklist.
+        if (/^\/(etc|bin|sbin|usr|Library|System|Applications|boot|dev|proc|sys|root|var\/log|var\/run)\//.test(absolute)) {
+            throw new Error(`Result path must not be a system directory: ${resultPath}`);
+        }
+        if (!fs.existsSync(absolute))
+            throw new Error(`Result file does not exist: ${resultPath}`);
+        const workerId = String(task.workerId);
+        // Host-attested `cw result <run> <task> <file>` intake: the operator hands CW
+        // an EXTERNAL result file that lives OUTSIDE the worker's read-only write
+        // boundary. The old task-level recordResult (lifecycle-operations.ts:279-280)
+        // COPIED that external file into the run's results area and recorded the
+        // internal path — it never ran the external path through validateSandboxWrite.
+        // v2 collapsed the two intakes into recordWorkerOutput, which sandbox-validates
+        // its input against the worker boundary, so a bare external path is rejected
+        // ("write path is outside sandbox profile <id>"). Restore the copy-in: stage
+        // the operator file at the worker's OWN result.md (which IS inside the write
+        // boundary), then record that internal path exactly like a driven worker.
+        const manifest = (0, worker_isolation_1.showWorkerManifest)(run, workerId);
+        fs.mkdirSync(path.dirname(manifest.resultPath), { recursive: true });
+        fs.copyFileSync(absolute, manifest.resultPath);
+        const output = (0, worker_isolation_1.recordWorkerOutput)(run, workerId, manifest.resultPath, {
+            requireAttestedTelemetry: (0, agent_config_1.resolveAgentConfig)(args).requireAttestedTelemetry,
+            allowUnattested: Boolean(args.allowUnattested ?? args["allow-unattested"]),
+        });
+        // Host-attested token usage (v0.1.31): record it verbatim as provenance when
+        // the operator supplied `--usage-*` flags; CW never synthesizes usage. The old
+        // task-level recordResult set `task.usage = usage` (lifecycle-operations.ts:286)
+        // and its unit was the TASK. v2 records through recordWorkerOutput, which gives
+        // the worker an `output` record — so the observability usage UNIT becomes the
+        // WORKER (deriveUsageTotals reads worker.usage for workers with output, and
+        // EXCLUDES that task). Attach the usage to the worker scope so the report counts
+        // it as an attested unit; also stamp task.usage for byte-parity with the old
+        // task-level record.
+        const usage = (0, observability_1.parseUsageFromArgs)(args, new Date().toISOString());
+        if (usage) {
+            task.usage = usage;
+            const scope = (0, worker_isolation_1.getWorkerScope)(run, workerId);
+            if (scope)
+                scope.usage = usage;
+        }
+        // Byte-exact to the old build's orchestrator recordWorkerOutput()
+        // wrapper: an accepted result is its own checkpoint commit, not just a
+        // bare saveCheckpoint (SPEC/pipeline-run.md's persist-ordering rule).
+        (0, commit_1.commitState)(run, `worker:${workerId}:result`);
+        (0, run_store_1.saveCheckpoint)(run);
+        (0, report_1.writeReport)(run);
+        return output;
+    });
 }
 /** `cw commit <run-id>` — byte-exact port of the old build's
  *  `orchestrator/lifecycle-operations.ts`'s `commit()`: the CLI/MCP

package/dist/shell/reclamation-io.js

@@ -106,6 +106,7 @@ const node_store_1 = require("./node-store");
 const node_snapshot_1 = require("../core/state/node-snapshot");
 const node_projection_1 = require("../core/state/node-projection");
 const hash_1 = require("../core/hash");
+const collate_1 = require("../core/util/collate");
 const run_registry_io_1 = require("./run-registry-io");
 // ---------------------------------------------------------------------------
 // Content addressing + byte measurement (in-process, no `du`) — carried
@@ -1287,7 +1288,7 @@ function readCloneEntries(root) {
             bytes: dirSize(dir),
         });
     }
-    entries.sort((a, b) => (a.fetchedAt || "").localeCompare(b.fetchedAt || ""));
+    entries.sort((a, b) => (0, collate_1.stableCompare)(a.fetchedAt || "", b.fetchedAt || ""));
     return entries;
 }
 /** `cw clones list` — every cached remote checkout with its origin,

package/dist/shell/report.js

@@ -59,13 +59,14 @@ const telemetry_ledger_io_1 = require("./telemetry-ledger-io");
 const multi_agent_io_1 = require("./multi-agent-io");
 const coordinator_io_1 = require("./coordinator-io");
 const multi_agent_operator_ux_1 = require("./multi-agent-operator-ux");
+const collate_1 = require("../core/util/collate");
 function formatInputList(value) {
     if (Array.isArray(value))
         return value.join("; ");
     return value ? String(value) : "";
 }
 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(", ");

package/dist/shell/run-store.js

@@ -50,6 +50,7 @@ exports.loadRunStateFile = loadRunStateFile;
 exports.checkRunStateFile = checkRunStateFile;
 exports.migrateRunStateFile = migrateRunStateFile;
 exports.loadRunFromCwd = loadRunFromCwd;
+exports.withRunStateLock = withRunStateLock;
 exports.saveCheckpoint = saveCheckpoint;
 exports.compactCheckpoint = compactCheckpoint;
 exports.createRun = createRun;
@@ -112,6 +113,22 @@ function loadRunFromCwd(runId, cwd = process.cwd()) {
     }
     return result.run;
 }
+/** Hold the state.json lock over a WHOLE load -> change -> save cycle.
+ *  A bare loadRunFromCwd + saveCheckpoint pair leaves a window where two
+ *  processes both load the same state and the later save silently drops
+ *  the earlier change (the same lost-update class PR #339 fixed for
+ *  queue.json / triggers.json). `fn` gets the run loaded UNDER the lock;
+ *  saveCheckpoint calls inside `fn` re-enter the same lock (withFileLock
+ *  is re-entrant in-process) and write exactly as before. The probe load
+ *  runs BEFORE the lock so an unknown run id throws the exact
+ *  loadRunFromCwd error without first creating the run directory as a
+ *  lock-file side effect — and it supplies `paths.state`, the same lock
+ *  target saveCheckpoint uses. Keep `fn` short: a critical section past
+ *  30s can be stolen as a stale lock. */
+function withRunStateLock(runId, cwd, fn) {
+    const probe = loadRunFromCwd(runId, cwd);
+    return (0, fs_atomic_1.withFileLock)(probe.paths.state, () => fn(loadRunFromCwd(runId, cwd)));
+}
 /** state.json is the single source of truth — set `updatedAt`, then write
  *  it DURABLY with a lock so concurrent processes never lose an update. */
 function saveCheckpoint(run) {

package/dist/shell/state-explosion-cli.js

@@ -66,6 +66,7 @@ const report_1 = require("../core/state/state-explosion/report");
 Object.defineProperty(exports, "buildStateExplosionReport", { enumerable: true, get: function () { return report_1.buildStateExplosionReport; } });
 const size_2 = require("../core/state/state-explosion/size");
 const multi_agent_operator_ux_1 = require("./multi-agent-operator-ux");
+const collate_1 = require("../core/util/collate");
 function summariesDir(run) {
     return path.join(run.paths.runDir, "summaries");
 }
@@ -134,7 +135,7 @@ function refreshStateExplosionSummaries(run, options = {}) {
         status: "valid",
         deterministic: true,
         nextAction: `node scripts/cw.js summary show ${run.id}`,
-        entries: entries.sort((a, b) => a.id.localeCompare(b.id)),
+        entries: entries.sort((a, b) => (0, collate_1.stableCompare)(a.id, b.id)),
         views,
         paths: { summariesDir: dir, indexPath: path.join(dir, "index.json"), reportPath },
     };

package/dist/shell/topology-io.js

@@ -63,6 +63,7 @@ const hash_2 = require("../core/hash");
 const topo = __importStar(require("../core/multi-agent/topology"));
 const multi_agent_io_1 = require("./multi-agent-io");
 const coordinator_io_1 = require("./coordinator-io");
+const collate_1 = require("../core/util/collate");
 function topologyRoot(run) {
     return run.paths.topologiesDir || path.join(run.paths.runDir, "topologies");
 }
@@ -307,7 +308,7 @@ function buildTopologyGraph(run) {
     return topo.buildTopologyGraphFromRuns(run.id, state.runs, (id) => topologyRunPath(run, id));
 }
 function formatTopologyCounts(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(", ");

package/dist/shell/trust-audit.js

@@ -58,6 +58,7 @@ exports.TRUST_AUDIT_SCHEMA_VERSION = void 0;
 exports.ensureTrustAudit = ensureTrustAudit;
 exports.trustAuditGenesis = trustAuditGenesis;
 exports.listTrustAuditEvents = listTrustAuditEvents;
+exports.trustAuditHead = trustAuditHead;
 exports.verifyTrustAudit = verifyTrustAudit;
 exports.recordTrustAuditEvent = recordTrustAuditEvent;
 exports.recordSandboxPathDecision = recordSandboxPathDecision;
@@ -136,6 +137,21 @@ function readEventsRaw(eventLogPath) {
 function listTrustAuditEvents(run) {
     return readEventsRaw(ensureTrustAudit(run).eventLogPath);
 }
+/** The current head of a run's trust-audit chain: the hash the NEXT
+ *  appended event will link from (genesis when the log is empty), plus
+ *  the event count. Read-only projection over existing data. Capture it
+ *  (e.g. right after a run, or at export time) and later hand it to
+ *  `verifyTrustAudit`'s anchor / `cw audit verify --expect-head` to
+ *  re-prove the log was not shortened since the capture. */
+function trustAuditHead(run) {
+    const audit = ensureTrustAudit(run);
+    const events = readEventsRaw(audit.eventLogPath);
+    let head = trustAuditGenesis(run.id);
+    for (const event of events) {
+        head = event.eventHash !== undefined ? event.eventHash : computeEventHash(event);
+    }
+    return { eventCount: events.length, headHash: head };
+}
 /** Re-prove the run's trust-audit chain: prevEventHash linkage (append
  *  order) + per-event hash recompute. A corrupt line, an edited event,
  *  or a removed event flips verified=false. Legacy events without a
@@ -147,8 +163,14 @@ function listTrustAuditEvents(run) {
  *  era) or all-legacy (pre-chain). An unchained (eventHash-less) line
  *  mixed into an otherwise-chained log is a forgery attempt — dropping
  *  the hash to be waved through as "legacy" — so it fails with
- *  `trust-audit-unchained-event`, never silently accepted. */
-function verifyTrustAudit(run) {
+ *  `trust-audit-unchained-event`, never silently accepted.
+ *
+ *  ANCHOR (optional): the walk alone cannot see tail truncation — see
+ *  TrustAuditAnchor. With an anchor, the head-hash trail (genesis plus
+ *  the hash after each event) must contain `expectHead`, and the log
+ *  must reach `expectCount` events; a shortfall fails closed with
+ *  `trust-audit-truncated`. Without an anchor, behavior is unchanged. */
+function verifyTrustAudit(run, anchor) {
     const audit = ensureTrustAudit(run);
     const { events, corruptLines } = readEventsRawCounted(audit.eventLogPath);
     const checks = [];
@@ -158,12 +180,14 @@ function verifyTrustAudit(run) {
     let chained = 0;
     let unchained = 0;
     let expectedPrev = trustAuditGenesis(run.id);
+    const headTrail = new Set([expectedPrev]);
     for (let i = 0; i < events.length; i++) {
         const event = events[i];
         const recomputed = computeEventHash(event);
         if (event.eventHash === undefined) {
             unchained += 1;
             expectedPrev = recomputed; // advance the chain over legacy events
+            headTrail.add(expectedPrev);
             continue;
         }
         chained += 1;
@@ -176,12 +200,27 @@ function verifyTrustAudit(run) {
             checks.push({ name: `chain-link[${i}]`, pass: false, code: "trust-audit-chain-broken" });
         }
         expectedPrev = event.eventHash;
+        headTrail.add(expectedPrev);
     }
     // Era rule: a log with ANY chained event must have EVERY event chained.
     if (chained > 0 && unchained > 0) {
         verified = false;
         checks.push({ name: "unchained-events", pass: false, code: "trust-audit-unchained-event" });
     }
+    // Anchor rule: the captured head must still be ON the chain, and the log
+    // must be at least as long as it was at capture time. A truncated-then-
+    // appended log fails the head check (new events link from an earlier
+    // point, so the old head is no longer in the trail).
+    if (anchor) {
+        if (anchor.expectCount !== undefined && events.length < anchor.expectCount) {
+            verified = false;
+            checks.push({ name: "anchor-count", pass: false, code: "trust-audit-truncated" });
+        }
+        if (anchor.expectHead !== undefined && !headTrail.has(anchor.expectHead)) {
+            verified = false;
+            checks.push({ name: "anchor-head", pass: false, code: "trust-audit-truncated" });
+        }
+    }
     return { present: events.length > 0, verified, eventCount: events.length, chained, unchained, corruptLines, checks };
 }
 function unique(values) {

package/dist/shell/worker-cli.js

@@ -51,6 +51,7 @@ const drive_1 = require("./drive");
 const commit_1 = require("./commit");
 const report_1 = require("./report");
 const operator_ux_1 = require("./operator-ux");
+const agent_config_1 = require("./agent-config");
 function cwdFor(args) {
     return typeof args.cwd === "string" && args.cwd.trim() ? path.resolve(args.cwd) : process.cwd();
 }
@@ -60,6 +61,10 @@ function req(value, label) {
         throw new Error(`Missing ${label}`);
     return s;
 }
+/** `--allow-unattested` (CLI: dashed key; MCP: allowUnattested). */
+function allowUnattestedOption(args) {
+    return Boolean(args.allowUnattested ?? args["allow-unattested"]);
+}
 function workerListCli(args) {
     const run = (0, run_store_1.loadRunFromCwd)(req(args.runId, "run id"), cwdFor(args));
     return (0, worker_isolation_1.listWorkerScopes)(run, { status: typeof args.status === "string" ? args.status : undefined });
@@ -92,7 +97,10 @@ function workerManifestCli(args) {
  *  same steps itself around the bare accept, so it never routes through here. */
 function workerOutputCli(args) {
     const run = (0, run_store_1.loadRunFromCwd)(req(args.runId, "run id"), cwdFor(args));
-    (0, worker_isolation_1.recordWorkerOutput)(run, req(args.workerId, "worker id"), req(args.resultPath, "result file"), {});
+    (0, worker_isolation_1.recordWorkerOutput)(run, req(args.workerId, "worker id"), req(args.resultPath, "result file"), {
+        requireAttestedTelemetry: (0, agent_config_1.resolveAgentConfig)(args).requireAttestedTelemetry,
+        allowUnattested: allowUnattestedOption(args),
+    });
     run.loopStage = "observe";
     (0, dispatch_1.updatePhaseStatuses)(run);
     (0, drive_1.maybeExpandLoop)(run);