cool-workflow 0.2.1 → 0.2.3

package/dist/shell/state-cli.js

@@ -65,6 +65,7 @@ const node_store_1 = require("./node-store");
 const contract_migration_1 = require("../core/state/contract-migration");
 const node_snapshot_1 = require("../core/state/node-snapshot");
 const dispatch_1 = require("../core/pipeline/dispatch");
+const numeric_flag_1 = require("../core/util/numeric-flag");
 function optionalStringArg(value) {
     return typeof value === "string" && value.trim() ? value.trim() : undefined;
 }
@@ -128,12 +129,6 @@ function loadRun(runId, options = {}) {
     const cwd = options.cwd ? path.resolve(String(options.cwd)) : process.cwd();
     return (0, run_store_1.loadRunFromCwd)(runId, cwd);
 }
-function numberOption(value) {
-    if (value === undefined || value === null || value === true)
-        return undefined;
-    const n = Number(value);
-    return Number.isFinite(n) ? n : undefined;
-}
 /** `cw next <run-id> [--limit N]` — the read-only "what would dispatch next"
  *  preview: the runnable tasks the next `cw dispatch` would pick, in order,
  *  without mutating state. A byte-behavior port of the old build's
@@ -141,7 +136,7 @@ function numberOption(value) {
  *  the cw_next MCP tool render this same DispatchTask[] value, so their
  *  payloads stay identical. */
 function nextCli(runId, options = {}) {
-    return (0, dispatch_1.nextDispatchTasks)(loadRun(runId, options), numberOption(options.limit));
+    return (0, dispatch_1.nextDispatchTasks)(loadRun(runId, options), (0, numeric_flag_1.requiredNumberFlag)(options.limit, "--limit"));
 }
 function listNodes(runId, options = {}) {
     return loadRun(runId, options).nodes || [];

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");
 }
@@ -133,8 +134,8 @@ function refreshStateExplosionSummaries(run, options = {}) {
         generatedAt: now,
         status: "valid",
         deterministic: true,
-        nextAction: `node scripts/cw.js summary show ${run.id}`,
-        entries: entries.sort((a, b) => a.id.localeCompare(b.id)),
+        nextAction: `cw summary show ${run.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 },
     };
@@ -183,15 +184,23 @@ function loadRun(runId, options = {}) {
  *  only (the run-state checkpoint write is real and load-bearing today;
  *  report.md rendering is not). */
 function summaryRefreshCli(runId, options = {}) {
-    const run = loadRun(runId, options);
-    const index = refreshStateExplosionSummaries(run);
-    (0, run_store_1.saveCheckpoint)(run);
-    return index;
+    // Hold the state.json lock across the whole load -> refresh -> save so a
+    // concurrent run mutation cannot drop this summary refresh (lost-update class).
+    const cwd = options.cwd ? path.resolve(String(options.cwd)) : process.cwd();
+    return (0, run_store_1.withRunStateLock)(runId, cwd, (run) => {
+        const index = refreshStateExplosionSummaries(run);
+        (0, run_store_1.saveCheckpoint)(run);
+        return index;
+    });
 }
-/** `cw summary show <run-id> [--json]` — also runs `saveCheckpoint`. */
+/** `cw summary show <run-id> [--json]` — a plain read: `showStateExplosionSummary`
+ *  only loads the persisted summary index and builds a report from it, it
+ *  never mutates `run`, so there is nothing here for a checkpoint write to
+ *  durably persist. No `saveCheckpoint` call (dropped one, see ITERATION_LOG
+ *  — it used to durably rewrite the whole unchanged state.json on every
+ *  `summary show`, only bumping `run.updatedAt` as a side effect of a
+ *  command whose whole job is to look, not touch). */
 function summaryShowCli(runId, options = {}) {
     const run = loadRun(runId, options);
-    const report = showStateExplosionSummary(run);
-    (0, run_store_1.saveCheckpoint)(run);
-    return report;
+    return showStateExplosionSummary(run);
 }

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");
 }
@@ -70,6 +71,23 @@ function topologyRunPath(run, id) {
     const safe = id.replace(/[^a-zA-Z0-9_.:-]+/g, "_");
     return path.join(topologyRoot(run), "runs", `${safe}.json`);
 }
+// Dirty-id tracking for persistTopologyState, mirroring coordinator-io.ts's
+// blackboard dirty tracking: without it, every persist call rewrote every
+// topology run's OWN file (topologyRunPath), even ones untouched this call —
+// O(N) writes per call, O(N^2) across N applyTopology calls. Kept off the
+// serialized TopologyState itself (a WeakMap keyed by the state object) so it
+// can never leak into state.json's bytes. applyTopology is the only place
+// state.runs is pushed to or an existing record mutated, so it is the only
+// call site that needs to mark a run id dirty.
+const topologyDirtyIds = new WeakMap();
+function dirtyTopologyIds(state) {
+    let ids = topologyDirtyIds.get(state);
+    if (!ids) {
+        ids = new Set();
+        topologyDirtyIds.set(state, ids);
+    }
+    return ids;
+}
 function ensureTopologyState(run) {
     run.paths.topologiesDir = topologyRoot(run);
     fs.mkdirSync(run.paths.topologiesDir, { recursive: true });
@@ -89,8 +107,13 @@ function persistTopologyState(run) {
         counts: { runs: state.runs.length },
         runs: state.runs.map((record) => ({ id: record.id, topologyId: record.topologyId, status: record.status, updatedAt: record.updatedAt })),
     });
-    for (const record of state.runs)
-        (0, fs_atomic_1.writeJson)(topologyRunPath(run, record.id), record);
+    const dirty = dirtyTopologyIds(state);
+    for (const id of dirty) {
+        const record = state.runs.find((entry) => entry.id === id);
+        if (record)
+            (0, fs_atomic_1.writeJson)(topologyRunPath(run, id), record);
+    }
+    dirty.clear();
 }
 function now() {
     return new Date().toISOString();
@@ -237,6 +260,7 @@ function applyTopology(run, topologyId, input = {}) {
         metadata: compact({ ...(input.metadata || {}), topology: definition }),
     };
     state.runs.push(record);
+    dirtyTopologyIds(state).add(record.id);
     appendTopologyNode(run, record, topo.statusToNodeStatus(record.status));
     (0, trust_audit_1.recordTrustAuditEvent)(run, {
         kind: "topology.verdict",
@@ -271,7 +295,15 @@ function summarizeTopologies(run) {
     const multi = run.multiAgent || {};
     const fanins = multi.fanins || [];
     const active = state.runs.map((record) => {
-        const inferredFanins = fanins.filter((fanin) => record.groupIds.includes(fanin.groupId) || record.fanoutIds.includes(fanin.fanoutId || ""));
+        // `fanins` (multi.fanins) grows with total fan-in activity across the
+        // whole run, re-scanned here once per topology record -- Sets built
+        // from each record's own small groupIds/fanoutIds replace an
+        // O(fanins) `.includes()` scan per fanin with an O(1) lookup (the
+        // same array-scan-per-item shape 024b007 fixed for phase/task
+        // selection).
+        const groupIdSet = new Set(record.groupIds);
+        const fanoutIdSet = new Set(record.fanoutIds);
+        const inferredFanins = fanins.filter((fanin) => groupIdSet.has(fanin.groupId) || fanoutIdSet.has(fanin.fanoutId || ""));
         const allFaninIds = topo.unique([...record.faninIds, ...inferredFanins.map((fanin) => fanin.id)]);
         const blocked = inferredFanins.filter((fanin) => fanin.status === "blocked" || !fanin.verifierReady);
         const ready = inferredFanins.some((fanin) => fanin.verifierReady);
@@ -290,7 +322,7 @@ function summarizeTopologies(run) {
             missingEvidence,
             conflicts: record.conflicts,
             readiness: ready ? "fanin ready" : missingEvidence.length ? "missing evidence" : "awaiting worker output",
-            nextActions: ready ? [`node scripts/cw.js candidate register ${run.id} --result-node <reducer-or-panel-result>`] : record.nextActions,
+            nextActions: ready ? [`cw candidate register ${run.id} --result-node <reducer-or-panel-result>`] : record.nextActions,
         };
     });
     return {
@@ -299,7 +331,7 @@ function summarizeTopologies(run) {
         runsByStatus: countBy(active, (record) => record.status),
         officialTopologies: topo.listTopologyDefinitions().map((definition) => definition.id),
         active,
-        nextAction: active.find((record) => record.nextActions.length)?.nextActions[0] || `node scripts/cw.js topology apply ${run.id} map-reduce --task <task-id>`,
+        nextAction: active.find((record) => record.nextActions.length)?.nextActions[0] || `cw topology apply ${run.id} map-reduce --task <task-id>`,
     };
 }
 function buildTopologyGraph(run) {
@@ -307,7 +339,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,7 +58,9 @@ exports.TRUST_AUDIT_SCHEMA_VERSION = void 0;
 exports.ensureTrustAudit = ensureTrustAudit;
 exports.trustAuditGenesis = trustAuditGenesis;
 exports.listTrustAuditEvents = listTrustAuditEvents;
+exports.trustAuditHead = trustAuditHead;
 exports.verifyTrustAudit = verifyTrustAudit;
+exports.repairTrustAuditTornTail = repairTrustAuditTornTail;
 exports.recordTrustAuditEvent = recordTrustAuditEvent;
 exports.recordSandboxPathDecision = recordSandboxPathDecision;
 exports.normalizeEvidence = normalizeEvidence;
@@ -105,6 +107,43 @@ function computeEventHash(event) {
     void eventHash;
     return (0, hash_1.sha256)((0, hash_1.eventHashInput)(rest));
 }
+function tailCachePathFor(eventLogPath) {
+    return path.join(path.dirname(eventLogPath), "tail-cache.json");
+}
+function readAuditTailCache(tailCachePath) {
+    if (!fs.existsSync(tailCachePath))
+        return undefined;
+    try {
+        const parsed = JSON.parse(fs.readFileSync(tailCachePath, "utf8"));
+        if (parsed && parsed.schemaVersion === 1 && typeof parsed.logBytes === "number" && typeof parsed.count === "number" && typeof parsed.lastHash === "string") {
+            return parsed;
+        }
+    }
+    catch {
+        // Corrupt/unreadable cache -- fall back to the full parse below.
+    }
+    return undefined;
+}
+function writeAuditTailCache(tailCachePath, cache) {
+    try {
+        (0, fs_atomic_1.writeJson)(tailCachePath, cache);
+    }
+    catch {
+        // Best-effort: a failed cache write must never break the real append.
+    }
+}
+/** Deletes the tail cache so the NEXT append always re-derives ground
+ *  truth from the real log, rather than trusting a byte-size coincidence.
+ *  Called whenever something OTHER than a plain append changes the log's
+ *  content (currently: repair). */
+function invalidateAuditTailCache(eventLogPath) {
+    try {
+        fs.unlinkSync(tailCachePathFor(eventLogPath));
+    }
+    catch {
+        // Nothing to invalidate (no cache existed yet) -- fine.
+    }
+}
 /** Read events in FILE (append) order, tolerating corrupt lines — one
  *  bad line must not brick the whole audit read surface (it is counted,
  *  not thrown). The chain links append order, so this is the order
@@ -136,6 +175,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,23 +201,32 @@ 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) {
-    const audit = ensureTrustAudit(run);
-    const { events, corruptLines } = readEventsRawCounted(audit.eventLogPath);
+ *  `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. */
+/** Chain-walk core shared by `verifyTrustAudit` (reads from disk) and
+ *  `repairTrustAuditTornTail` (re-checks an in-memory candidate result
+ *  BEFORE ever writing it to disk). Pure — no fs. */
+function verifyEventsChain(runId, events, corruptLines, anchor) {
     const checks = [];
     let verified = corruptLines === 0;
     if (corruptLines > 0)
         checks.push({ name: "parse", pass: false, code: "trust-audit-corrupt-line" });
     let chained = 0;
     let unchained = 0;
-    let expectedPrev = trustAuditGenesis(run.id);
+    let expectedPrev = trustAuditGenesis(runId);
+    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;
@@ -171,19 +234,126 @@ function verifyTrustAudit(run) {
             verified = false;
             checks.push({ name: `event-hash[${i}]`, pass: false, code: "trust-audit-digest-mismatch" });
         }
-        if (event.prevEventHash !== undefined && event.prevEventHash !== expectedPrev) {
+        // No `undefined` skip here: the writer ALWAYS sets prevEventHash (the
+        // first event gets the genesis hash), so a chained event without it is
+        // a forgery — dropping the field and re-making eventHash must NOT let a
+        // cut or re-ordered chain verify green. Fail closed on the mismatch.
+        if (event.prevEventHash !== expectedPrev) {
             verified = false;
             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 verifyTrustAudit(run, anchor) {
+    const audit = ensureTrustAudit(run);
+    const { events, corruptLines } = readEventsRawCounted(audit.eventLogPath);
+    return verifyEventsChain(run.id, events, corruptLines, anchor);
+}
+/** Repairs a torn TRAILING write in the audit event log — the ONE
+ *  corruption shape a crash mid-append can produce (`durableAppendFileSync`
+ *  only ever adds bytes at the current end of file, so an interruption can
+ *  only ever leave the LAST append incomplete; it can never touch earlier,
+ *  already-flushed lines). Every line is always actually parsed — the
+ *  file's trailing-newline byte says only whether the LAST WRITE
+ *  completed, nothing about whether any line parses: if a run is RESUMED
+ *  after a torn write (another event appended right after the garbled
+ *  remnant, with no separating newline of its own), the two merge into one
+ *  unparseable line and the file ends in a newline again, even though
+ *  content is still corrupt. Refuses (`outcome: "refused"`) rather than
+ *  touching anything when:
+ *   - more than one line is unparseable, or the sole bad line is NOT the
+ *     last one (not a shape a crash can produce — treated as possible
+ *     tampering, not auto-repaired);
+ *   - removing the bad trailing line still leaves an unverifiable chain,
+ *     OR (when `anchor` is given) the repaired chain doesn't reach
+ *     `anchor.expectCount`/contain `anchor.expectHead` — an anchor
+ *     captured before the corruption is the ONLY way to catch an attacker
+ *     deleting real historical events and leaving a torn-looking fragment
+ *     behind (an empty/short chain otherwise "verifies" trivially — the
+ *     same documented blind spot `verifyTrustAudit` itself has without an
+ *     anchor; this function must never launder that shape into a
+ *     confidently-"repaired" empty log).
+ *  `write: false` (default) reports what WOULD happen without touching
+ *  disk, matching this codebase's `cw state check [--write]` convention.
+ *  Held under the SAME `withFileLock` as `recordTrustAuditEvent` (below),
+ *  so a repair can never interleave with a live append. */
+function repairTrustAuditTornTail(run, options = {}) {
+    const audit = ensureTrustAudit(run);
+    return (0, fs_atomic_1.withFileLock)(audit.eventLogPath, () => {
+        const raw = fs.readFileSync(audit.eventLogPath, "utf8");
+        const lines = raw.split("\n").filter((line) => line.trim() !== "");
+        const badIndexes = [];
+        const events = [];
+        lines.forEach((line, i) => {
+            try {
+                events.push(JSON.parse(line));
+            }
+            catch {
+                badIndexes.push(i);
+            }
+        });
+        if (badIndexes.length === 0) {
+            return { outcome: "clean", reason: "every line parses — no torn trailing write to repair" };
+        }
+        if (badIndexes.length > 1 || badIndexes[0] !== lines.length - 1) {
+            return {
+                outcome: "refused",
+                reason: "corruption is not confined to exactly the trailing line — this is not a shape a crash mid-append can produce and will not be auto-repaired (looks like tampering)",
+            };
+        }
+        // `events` already holds every line EXCEPT the one bad trailing line
+        // (JSON.parse threw for it, so nothing was pushed) — exactly the "good"
+        // set, in file order.
+        const recheck = verifyEventsChain(run.id, events, 0, options.anchor);
+        if (!recheck.verified) {
+            return {
+                outcome: "refused",
+                reason: options.anchor
+                    ? "removing the torn trailing write still doesn't reach the given --expect-head/--expect-count anchor — refusing to repair (this looks like deleted history, not a crash)"
+                    : "removing the torn trailing write still leaves an unverifiable chain — refusing to repair (this looks like tampering, not a crash)",
+            };
+        }
+        const removedBytes = Buffer.byteLength(lines[lines.length - 1], "utf8");
+        const repairedContent = events.length > 0 ? `${lines.slice(0, -1).join("\n")}\n` : "";
+        if (options.write) {
+            (0, fs_atomic_1.writeTextDurable)(audit.eventLogPath, repairedContent, { durable: true });
+            // The log's bytes just changed out from under the append tail cache
+            // (perf cycle P1-2) -- invalidate rather than rely on the size check
+            // alone catching every case.
+            invalidateAuditTailCache(audit.eventLogPath);
+        }
+        return {
+            outcome: "repaired",
+            reason: options.write
+                ? `removed a torn trailing write (${removedBytes} bytes) and restored a verified chain of ${events.length} event(s)`
+                : `would remove a torn trailing write (${removedBytes} bytes) and restore a verified chain of ${events.length} event(s) — pass --write to apply`,
+            removedLines: 1,
+            removedBytes,
+        };
+    });
+}
 function unique(values) {
     return Array.from(new Set(values.filter(Boolean)));
 }
@@ -210,9 +380,14 @@ function scrubMetadata(value) {
 function compact(value) {
     return Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== undefined));
 }
-function createEventId(run, kind) {
-    const count = readEventsRaw(trustAuditPaths(run).eventLogPath).length + 1;
-    return `audit-${(0, fs_atomic_1.safeFileName)(kind)}-${String(count).padStart(4, "0")}`;
+/** `count` must be the number of PRIOR events, read under the SAME lock
+ *  the append itself happens under (see `recordTrustAuditEvent`) — an
+ *  earlier version read this count separately, outside any lock, so two
+ *  concurrent writers could mint the SAME id for two different events
+ *  (the hash chain still forked-proof, but the id — referenced elsewhere
+ *  as `auditEventIds`/`parentEventIds` for provenance — was not unique). */
+function createEventId(kind, count) {
+    return `audit-${(0, fs_atomic_1.safeFileName)(kind)}-${String(count + 1).padStart(4, "0")}`;
 }
 /** Correlation-id keys copied verbatim (and no others) — byte-exact list/
  *  order to the old build's CORRELATION_ID_FIELDS. */
@@ -255,11 +430,20 @@ function indexCorrelationIds(event) {
     }
     return picked;
 }
+/** Read-modify-append: computes `prevEventHash` from the CURRENT last event
+ *  and appends. Held under `withFileLock` (like every other read-modify-
+ *  write in this codebase) so two processes recording events for the same
+ *  run at once can never both read the same tail and compute the same
+ *  `prevEventHash` — that would fork the hash chain, and a forked chain
+ *  fails `verifyTrustAudit` for good, with no repair for THAT shape (unlike
+ *  a torn trailing write, a fork is not confined to the last line). */
 function recordTrustAuditEvent(run, input) {
     const audit = ensureTrustAudit(run);
+    // `id` is NOT set here — it depends on the prior event count, which (like
+    // prevEventHash) must be read under the lock below, or two concurrent
+    // writers could mint the same id for two different events.
     const event = compact({
         schemaVersion: exports.TRUST_AUDIT_SCHEMA_VERSION,
-        id: createEventId(run, input.kind),
         createdAt: new Date().toISOString(),
         runId: run.id,
         kind: input.kind,
@@ -283,11 +467,35 @@ function recordTrustAuditEvent(run, input) {
         parentEventIds: unique(input.parentEventIds || []).sort(),
         metadata: scrubMetadata(input.metadata || {}),
     });
-    const prior = readEventsRaw(audit.eventLogPath);
-    event.prevEventHash = prior.length ? prior[prior.length - 1].eventHash || computeEventHash(prior[prior.length - 1]) : trustAuditGenesis(run.id);
-    event.eventHash = computeEventHash(event);
-    (0, fs_atomic_1.durableAppendFileSync)(audit.eventLogPath, `${JSON.stringify(event)}\n`);
-    return event;
+    return (0, fs_atomic_1.withFileLock)(audit.eventLogPath, () => {
+        // The prior event count and last-event hash are the ONLY two things
+        // this append needs from the existing log. A tail cache (keyed on the
+        // log's own byte size) serves both without a full parse when nothing
+        // else has touched the log since it was written; any size mismatch
+        // (a repair, a torn write, this being the very first append) falls
+        // back to the full parse, same as before this cache existed.
+        const tailCachePath = tailCachePathFor(audit.eventLogPath);
+        const currentBytes = fs.existsSync(audit.eventLogPath) ? fs.statSync(audit.eventLogPath).size : 0;
+        const cached = readAuditTailCache(tailCachePath);
+        let count;
+        let prevHash;
+        if (cached && cached.logBytes === currentBytes) {
+            count = cached.count;
+            prevHash = cached.lastHash;
+        }
+        else {
+            const prior = readEventsRaw(audit.eventLogPath);
+            count = prior.length;
+            prevHash = prior.length ? prior[prior.length - 1].eventHash || computeEventHash(prior[prior.length - 1]) : trustAuditGenesis(run.id);
+        }
+        event.id = createEventId(input.kind, count);
+        event.prevEventHash = prevHash;
+        event.eventHash = computeEventHash(event);
+        const line = `${JSON.stringify(event)}\n`;
+        (0, fs_atomic_1.durableAppendFileSync)(audit.eventLogPath, line);
+        writeAuditTailCache(tailCachePath, { schemaVersion: 1, logBytes: currentBytes + Buffer.byteLength(line, "utf8"), count: count + 1, lastHash: event.eventHash });
+        return event;
+    });
 }
 function recordSandboxPathDecision(run, input) {
     return recordTrustAuditEvent(run, {
@@ -348,11 +556,32 @@ function countBy(values, key) {
  *  here — the old build's extra workers/candidates/commits/multiAgent/
  *  blackboard rollups are milestone 9's own summarizeMultiAgent/
  *  candidate-scoring-io/coordinator-io surfaces, not duplicated here. */
+/** Groups events by a key field once, so each row below is an O(1) Map
+ *  lookup instead of an O(events) `.filter()` re-scan per id -- found
+ *  alongside the id.find() version of this same shape while pinning perf
+ *  cycle P1-1's review-fix regression test (O(ids x events) otherwise). */
+function groupEventsBy(events, key) {
+    const groups = new Map();
+    for (const event of events) {
+        const k = key(event);
+        if (!k)
+            continue;
+        const list = groups.get(k);
+        if (list)
+            list.push(event);
+        else
+            groups.set(k, [event]);
+    }
+    return groups;
+}
 function workerRows(events, run) {
-    const workerIds = unique([...(run.workers || []).map((w) => w.id), ...events.map((e) => e.workerId || "")]).sort();
+    const workers = run.workers || [];
+    const workersById = new Map(workers.map((w) => [w.id, w]));
+    const eventsByWorkerId = groupEventsBy(events, (e) => e.workerId);
+    const workerIds = unique([...workers.map((w) => w.id), ...events.map((e) => e.workerId || "")]).sort();
     return workerIds.filter(Boolean).map((workerId) => {
-        const worker = (run.workers || []).find((w) => w.id === workerId);
-        const scoped = events.filter((e) => e.workerId === workerId);
+        const worker = workersById.get(workerId);
+        const scoped = eventsByWorkerId.get(workerId) || [];
         return {
             workerId,
             taskId: worker?.taskId || scoped.find((e) => e.taskId)?.taskId,
@@ -366,11 +595,21 @@ function workerRows(events, run) {
 function candidateRows(events, run) {
     const cands = run.candidates || [];
     const selectionsAll = run.candidateSelections || [];
+    const candsById = new Map(cands.map((c) => [c.id, c]));
+    const selectionsByCandidateId = new Map();
+    for (const selection of selectionsAll) {
+        const list = selectionsByCandidateId.get(selection.candidateId);
+        if (list)
+            list.push(selection);
+        else
+            selectionsByCandidateId.set(selection.candidateId, [selection]);
+    }
+    const eventsByCandidateId = groupEventsBy(events, (e) => e.candidateId);
     const ids = unique([...cands.map((c) => c.id), ...events.map((e) => e.candidateId || "")]).sort();
     return ids.filter(Boolean).map((candidateId) => {
-        const candidate = cands.find((c) => c.id === candidateId);
-        const selections = selectionsAll.filter((s) => s.candidateId === candidateId);
-        const scoped = events.filter((e) => e.candidateId === candidateId);
+        const candidate = candsById.get(candidateId);
+        const selections = selectionsByCandidateId.get(candidateId) || [];
+        const scoped = eventsByCandidateId.get(candidateId) || [];
         return {
             candidateId,
             scoreIds: unique([...(candidate?.scores || []), ...scoped.map((e) => e.scoreId || "")]).filter(Boolean).sort(),
@@ -380,9 +619,11 @@ function candidateRows(events, run) {
     });
 }
 function commitRows(events, run) {
-    const ids = unique([...(run.commits || []).map((c) => c.id), ...events.map((e) => e.commitId || "")]).sort();
+    const commits = run.commits || [];
+    const commitsById = new Map(commits.map((c) => [c.id, c]));
+    const ids = unique([...commits.map((c) => c.id), ...events.map((e) => e.commitId || "")]).sort();
     return ids.filter(Boolean).map((commitId) => {
-        const commit = (run.commits || []).find((c) => c.id === commitId);
+        const commit = commitsById.get(commitId);
         return {
             commitId,
             verifierGated: Boolean(commit?.verifierGated),

package/dist/shell/trust-policy-io.js

@@ -209,7 +209,7 @@ function summarizeMultiAgentTrust(run) {
         judgeRationales: byKind("judge.rationale"),
         panelDecisions: byKind("judge.panel-decision"),
         policyViolations,
-        nextAction: policyViolations.length ? `node scripts/cw.js audit policy ${run.id}` : `node scripts/cw.js audit multi-agent ${run.id} --json`,
+        nextAction: policyViolations.length ? `cw audit policy ${run.id}` : `cw audit multi-agent ${run.id} --json`,
     };
 }
 function hasAcceptedJudgeRationale(run, input = {}) {