cool-workflow 0.1.98 → 0.2.1

package/dist/{evidence-reasoning.js → shell/evidence-reasoning.js}

@@ -1,4 +1,13 @@
 "use strict";
+// shell/evidence-reasoning.ts — the Evidence Adoption Reasoning Chain
+// (v0.1.26). Faithful port of the old flat build's src/evidence-reasoning.ts
+// (+ its src/types/evidence-reasoning.ts types), adapted to v2's core/shell
+// split. DERIVES the "why" behind each evidence adoption decision from
+// existing run state; never mutates source records, never fabricates a
+// rationale (an untraceable adoption renders `unexplained`).
+//
+// Evidence: SPEC/multi-agent.md "Evidence adoption reasoning";
+// plugins/cool-workflow/src/evidence-reasoning.ts (byte-behavior source).
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -15,30 +24,31 @@ exports.formatEvidenceReasoningReport = formatEvidenceReasoningReport;
 const node_crypto_1 = __importDefault(require("node:crypto"));
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
-const state_1 = require("./state");
+const validation_1 = require("../core/state/validation");
+const fs_atomic_1 = require("./fs-atomic");
 const multi_agent_operator_ux_1 = require("./multi-agent-operator-ux");
 const trust_audit_1 = require("./trust-audit");
-const multi_agent_trust_1 = require("./multi-agent-trust");
-const validation_1 = require("./validation");
-// ---------------------------------------------------------------------------
-// Evidence Adoption Reasoning Chain (v0.1.26)
-//
-// This module DERIVES the "why" behind each evidence adoption decision from
-// existing run state. It is the mechanism half of the FreeBSD mechanism/policy
-// split: it captures, fingerprints and renders the recorded rationale; it never
-// decides whether a rationale is *sufficient* (that stays with the verifier /
-// role policy). It never mutates source-of-truth records and never fabricates a
-// rationale — an adoption whose reason cannot be traced renders `unexplained`.
-//
-// The persisted view mirrors the v0.1.25 state-explosion summaries: a derived,
-// versioned, provenance-backed index under .cw/runs/<id>/reasoning/ with a
-// sourceFingerprint and valid|stale|absent freshness, refreshable, never
-// authoritative over raw state.
-// ---------------------------------------------------------------------------
+const trust_policy_1 = require("../core/multi-agent/trust-policy");
 exports.EVIDENCE_REASONING_SCHEMA_VERSION = 1;
-// ---------------------------------------------------------------------------
-// Derivation
-// ---------------------------------------------------------------------------
+function candidatesOf(run) {
+    return (run.candidates || []);
+}
+function selectionsOf(run) {
+    return (run.candidateSelections || []);
+}
+function commitsOf(run) {
+    return (run.commits || []);
+}
+function decisionsOf(run) {
+    return (run.blackboard?.decisions || []);
+}
+function faninsOf(run) {
+    return (run.multiAgent?.fanins || []);
+}
+function rolesOf(run) {
+    return (run.multiAgent?.roles || []);
+}
+// ---- Derivation ------------------------------------------------------------
 function buildEvidenceReasoningReport(run, options = {}) {
     const operator = (0, multi_agent_operator_ux_1.summarizeMultiAgentOperator)(run);
     const scores = readAllScores(run);
@@ -62,27 +72,18 @@ function buildEvidenceReasoningReport(run, options = {}) {
         schemaVersion: exports.EVIDENCE_REASONING_SCHEMA_VERSION,
         runId: run.id,
         generatedAt: new Date().toISOString(),
-        freshness: {
-            status,
-            persistedFingerprint: persisted?.sourceFingerprint,
-            currentFingerprint
-        },
+        freshness: { status, persistedFingerprint: persisted?.sourceFingerprint, currentFingerprint },
         sourceFingerprint: currentFingerprint,
         totals,
         chains,
-        nextAction
+        nextAction,
     };
 }
 function buildChain(run, evidence, context) {
     const steps = [];
     const sourceRecordIds = new Set();
-    const note = (id) => {
-        if (id)
-            sourceRecordIds.add(id);
-    };
-    // Walk the adopters/rejecters recorded on the evidence row and classify each
-    // by the gate it represents. We never invent gates: a step exists only when a
-    // real adopter/decision record references this evidence.
+    const note = (id) => { if (id)
+        sourceRecordIds.add(id); };
     const adopters = [...evidence.adoptedBy, ...evidence.rejectedBy];
     for (const scoreId of evidence.scoreIds) {
         const score = context.scores.get(scoreId);
@@ -90,22 +91,20 @@ function buildChain(run, evidence, context) {
         steps.push(buildScoreStep(run, evidence, score, scoreId, context));
     }
     for (const selectionId of evidence.selectionIds) {
-        const selection = (run.candidateSelections || []).find((entry) => entry.id === selectionId);
+        const selection = selectionsOf(run).find((entry) => entry.id === selectionId);
         note(selectionId);
         steps.push(buildSelectionStep(run, evidence, selection, selectionId, context));
     }
     for (const commitId of evidence.commitIds) {
-        const commit = (run.commits || []).find((entry) => entry.id === commitId);
+        const commit = commitsOf(run).find((entry) => entry.id === commitId);
         note(commitId);
-        const commitStep = buildCommitStep(run, evidence, commit, commitId);
-        steps.push(commitStep);
-        const verifierStep = buildVerifierStep(run, evidence, commit, commitId);
+        steps.push(buildCommitStep(run, evidence, commit, commitId));
+        const verifierStep = buildVerifierStep(evidence, commit, commitId);
         if (verifierStep)
             steps.push(verifierStep);
     }
-    // Fanin and coordinator-decision adopters (blackboard -> fanin consolidation).
-    const faninIds = new Set((run.multiAgent?.fanins || []).map((entry) => entry.id));
-    const decisions = run.blackboard?.decisions || [];
+    const faninIds = new Set(faninsOf(run).map((entry) => entry.id));
+    const decisions = decisionsOf(run);
     for (const adopter of unique(adopters)) {
         if (faninIds.has(adopter)) {
             note(adopter);
@@ -115,13 +114,10 @@ function buildChain(run, evidence, context) {
             const decision = decisions.find((entry) => entry.id === adopter);
             if (decision) {
                 note(decision.id);
-                steps.push(buildDecisionStep(run, evidence, decision));
+                steps.push(buildDecisionStep(evidence, decision));
             }
         }
     }
-    // An adopted/rejected item that produced no decision-gate step has a known
-    // WHAT but no recorded WHY: fail closed with an explicit unexplained step so
-    // the gap is visible rather than silently treated as adopted.
     if (!steps.length && isDecisionStatus(evidence.status)) {
         steps.push(buildUnexplainedStep(evidence));
     }
@@ -142,17 +138,12 @@ function buildChain(run, evidence, context) {
         sourceId: evidence.sourceId,
         steps,
         sourceRecordIds: [...sourceRecordIds].filter(Boolean).sort(),
-        unexplainedReasons
+        unexplainedReasons,
     };
 }
-// ---------------------------------------------------------------------------
-// Per-gate steps
-// ---------------------------------------------------------------------------
 function buildScoreStep(run, evidence, score, scoreId, context) {
     const decision = score?.verdict === "fail" ? "rejected" : "adopted";
-    const judge = context.auditEvents.find((event) => event.kind === "judge.rationale" &&
-        event.decision === "accepted" &&
-        (event.scoreId === scoreId || (!event.scoreId && event.candidateId && evidence.candidateIds.includes(event.candidateId))));
+    const judge = context.auditEvents.find((event) => event.kind === "judge.rationale" && event.decision === "accepted" && (event.scoreId === scoreId || (!event.scoreId && event.candidateId && evidence.candidateIds.includes(event.candidateId))));
     const rationaleText = score?.notes || judgeRationaleText(judge);
     const rationale = rationaleText
         ? {
@@ -161,13 +152,9 @@ function buildScoreStep(run, evidence, score, scoreId, context) {
             sourceKind: score?.notes ? "score-notes" : "judge-rationale",
             sourceId: score?.notes ? scoreId : judge?.id,
             scoreCriteria: score?.criteria,
-            scoreDelta: context.counterfactuals.bestRejectedNormalized !== undefined && score
-                ? round(score.normalized - context.counterfactuals.bestRejectedNormalized)
-                : undefined
+            scoreDelta: context.counterfactuals.bestRejectedNormalized !== undefined && score ? round(score.normalized - context.counterfactuals.bestRejectedNormalized) : undefined,
         }
         : unexplainedRationale();
-    // AUTHORITY: the judge role that authored the rationale, when recorded; the
-    // host that mechanically wrote the score is the fallback actor.
     const auditIds = unique([...collectAuditIds(score), ...(judge ? [judge.id] : [])]);
     return {
         gate: "candidate-score",
@@ -175,77 +162,44 @@ function buildScoreStep(run, evidence, score, scoreId, context) {
         basis: basisFor(evidence, { auditEventIds: auditIds, evidenceRefs: scoreEvidenceRefs(score) }),
         authority: roleAuthority(run, judge?.agentRoleId || score?.scorer, judge ? judge.decision === "accepted" : undefined),
         rationale,
-        counterfactuals: decision === "adopted" ? context.counterfactuals.forScoreGate : []
+        counterfactuals: decision === "adopted" ? context.counterfactuals.forScoreGate : [],
     };
 }
 function buildSelectionStep(run, evidence, selection, selectionId, context) {
     const rationaleText = selection?.reason;
     const acceptance = selection?.acceptanceRationale;
     const rationale = rationaleText
-        ? {
-            status: "explained",
-            text: truncate(rationaleText),
-            sourceKind: "selection-reason",
-            sourceId: selectionId,
-            scoreCriteria: acceptance?.scoreCriteria,
-            judgeRationaleIds: acceptance?.judgeRationaleIds,
-            panelDecisionId: acceptance?.panelDecisionId
-        }
+        ? { status: "explained", text: truncate(rationaleText), sourceKind: "selection-reason", sourceId: selectionId, scoreCriteria: acceptance?.scoreCriteria, judgeRationaleIds: acceptance?.judgeRationaleIds, panelDecisionId: acceptance?.panelDecisionId }
         : acceptance
-            ? {
-                status: "explained",
-                text: `commit gate ${acceptance.commitGateResult || "recorded"} with ${acceptance.evidenceCount} evidence ref(s)`,
-                sourceKind: "acceptance-rationale",
-                sourceId: selectionId,
-                scoreCriteria: acceptance.scoreCriteria,
-                judgeRationaleIds: acceptance.judgeRationaleIds,
-                panelDecisionId: acceptance.panelDecisionId
-            }
+            ? { status: "explained", text: `commit gate ${acceptance.commitGateResult || "recorded"} with ${acceptance.evidenceCount} evidence ref(s)`, sourceKind: "acceptance-rationale", sourceId: selectionId, scoreCriteria: acceptance.scoreCriteria, judgeRationaleIds: acceptance.judgeRationaleIds, panelDecisionId: acceptance.panelDecisionId }
             : unexplainedRationale();
-    // AUTHORITY: the chair role recorded as the author of the candidate-synthesis
-    // coordinator decision for this selection; the host is the fallback actor.
-    const synthesis = (run.blackboard?.decisions || []).find((entry) => entry.kind === "candidate-synthesis" && entry.subjectIds.includes(selectionId) && entry.author?.kind === "role");
+    const synthesis = decisionsOf(run).find((entry) => entry.kind === "candidate-synthesis" && (entry.subjectIds || []).includes(selectionId) && entry.author?.kind === "role");
     return {
         gate: "selection",
         decision: "adopted",
-        basis: basisFor(evidence, {
-            auditEventIds: acceptance?.auditEventIds || [],
-            evidenceRefs: (selection?.evidence || []).map(evidenceRef).filter(Boolean)
-        }),
+        basis: basisFor(evidence, { auditEventIds: acceptance?.auditEventIds || [], evidenceRefs: (selection?.evidence || []).map(evidenceRef).filter(Boolean) }),
         authority: roleAuthority(run, synthesis?.author?.id || selection?.selectedBy, true),
         rationale,
-        counterfactuals: context.counterfactuals.forSelectionGate
+        counterfactuals: context.counterfactuals.forSelectionGate,
     };
 }
-function buildCommitStep(run, evidence, commit, commitId) {
+function buildCommitStep(_run, evidence, commit, commitId) {
     const decision = commit?.verifierGated ? "adopted" : "pending";
     const rationale = commit?.reason
-        ? {
-            status: "explained",
-            text: truncate(commit.reason),
-            sourceKind: "commit-reason",
-            sourceId: commitId
-        }
+        ? { status: "explained", text: truncate(commit.reason), sourceKind: "commit-reason", sourceId: commitId }
         : decision === "adopted"
             ? unexplainedRationale()
             : { status: "not-applicable" };
     return {
         gate: "commit",
         decision,
-        basis: basisFor(evidence, {
-            auditEventIds: commit?.acceptanceRationale?.auditEventIds || [],
-            evidenceRefs: (commit?.evidence || []).map(evidenceRef).filter(Boolean)
-        }),
-        authority: {
-            actor: commitId,
-            actorKind: "runtime",
-            allowed: commit?.verifierGated
-        },
+        basis: basisFor(evidence, { auditEventIds: commit?.acceptanceRationale?.auditEventIds || [], evidenceRefs: (commit?.evidence || []).map(evidenceRef).filter(Boolean) }),
+        authority: { actor: commitId, actorKind: "runtime", allowed: commit?.verifierGated },
         rationale,
-        counterfactuals: []
+        counterfactuals: [],
     };
 }
-function buildVerifierStep(run, evidence, commit, commitId) {
+function buildVerifierStep(evidence, commit, commitId) {
     const verifierNodeId = commit?.verifierNodeId;
     if (!verifierNodeId)
         return undefined;
@@ -260,27 +214,22 @@ function buildVerifierStep(run, evidence, commit, commitId) {
             : commit?.verifierGated
                 ? { status: "explained", text: "verifier-gated commit recorded", sourceKind: "commit-reason", sourceId: commitId }
                 : { status: "not-applicable" },
-        counterfactuals: []
+        counterfactuals: [],
     };
 }
 function buildFaninStep(run, evidence, faninId, decisions) {
-    const fanin = (run.multiAgent?.fanins || []).find((entry) => entry.id === faninId);
-    const readiness = decisions.find((entry) => entry.kind === "fanin-readiness" && entry.subjectIds.includes(faninId));
+    const fanin = faninsOf(run).find((entry) => entry.id === faninId);
+    const readiness = decisions.find((entry) => entry.kind === "fanin-readiness" && (entry.subjectIds || []).includes(faninId));
     const adopted = evidence.adoptedBy.includes(faninId);
     const decision = adopted ? "adopted" : "pending";
     let rationale;
     if (readiness?.reason) {
         rationale = { status: "explained", text: truncate(readiness.reason), sourceKind: "coordinator-decision", sourceId: readiness.id };
     }
-    else if (fanin && fanin.verifierReady && coverageComplete(fanin, evidence)) {
-        rationale = {
-            status: "explained",
-            text: `fanin ${faninId} ready: required evidence covered under "${fanin.strategy}" strategy`,
-            sourceKind: "coordinator-decision",
-            sourceId: faninId
-        };
+    else if (fanin && fanin.verifierReady && coverageComplete(fanin)) {
+        rationale = { status: "explained", text: `fanin ${faninId} ready: required evidence covered under "${fanin.strategy}" strategy`, sourceKind: "coordinator-decision", sourceId: faninId };
     }
-    else if (fanin && fanin.blockedReasons.length) {
+    else if (fanin && (fanin.blockedReasons || []).length) {
         rationale = { status: "explained", text: truncate(fanin.blockedReasons[0]), sourceKind: "coordinator-decision", sourceId: faninId };
     }
     else {
@@ -292,109 +241,66 @@ function buildFaninStep(run, evidence, faninId, decisions) {
         basis: basisFor(evidence, { auditEventIds: [], evidenceRefs: [] }),
         authority: { actor: faninId, actorKind: "coordinator", allowed: adopted },
         rationale,
-        counterfactuals: []
+        counterfactuals: [],
     };
 }
-function buildDecisionStep(run, evidence, decision) {
-    const status = mapDecisionOutcome(decision.outcome);
+function buildDecisionStep(evidence, decision) {
+    const status = mapDecisionOutcome(decision.outcome || "");
     return {
         gate: "fanin",
         decision: status,
         basis: basisFor(evidence, { auditEventIds: [], evidenceRefs: decision.evidenceRefs || [] }),
-        authority: {
-            actor: decision.author?.id || decision.id,
-            actorKind: authorKind(decision.author?.kind),
-            allowed: decision.outcome === "accepted" || decision.outcome === "ready"
-        },
+        authority: { actor: decision.author?.id || decision.id, actorKind: authorKind(decision.author?.kind), allowed: decision.outcome === "accepted" || decision.outcome === "ready" },
         rationale: decision.reason
             ? { status: "explained", text: truncate(decision.reason), sourceKind: "coordinator-decision", sourceId: decision.id }
             : isDecisionStatus(status)
                 ? unexplainedRationale()
                 : { status: "not-applicable" },
-        counterfactuals: []
+        counterfactuals: [],
     };
 }
 function buildUnexplainedStep(evidence) {
-    // The item is marked adopted/rejected but no decision record carries a reason.
-    // Render the gap explicitly (fail closed) rather than inferring a rationale.
     return {
         gate: "fanin",
         decision: mapStatus(evidence.status),
         basis: basisFor(evidence, { auditEventIds: [], evidenceRefs: [] }),
-        authority: {
-            actor: evidence.adoptedBy[0] || evidence.rejectedBy[0] || evidence.sourceId,
-            actorKind: actorKindForSource(evidence.sourceKind),
-            allowed: evidence.status === "adopted"
-        },
-        rationale: evidence.reason
-            ? { status: "explained", text: truncate(evidence.reason), sourceKind: "coordinator-decision", sourceId: evidence.sourceId }
-            : unexplainedRationale(),
-        counterfactuals: []
+        authority: { actor: evidence.adoptedBy[0] || evidence.rejectedBy[0] || evidence.sourceId, actorKind: actorKindForSource(evidence.sourceKind), allowed: evidence.status === "adopted" },
+        rationale: evidence.reason ? { status: "explained", text: truncate(evidence.reason), sourceKind: "coordinator-decision", sourceId: evidence.sourceId } : unexplainedRationale(),
+        counterfactuals: [],
     };
 }
-// ---------------------------------------------------------------------------
-// Counterfactuals
-// ---------------------------------------------------------------------------
 function deriveCounterfactuals(run, scores) {
     const forScoreGate = [];
     const forSelectionGate = [];
     let bestRejectedNormalized;
-    for (const candidate of run.candidates || []) {
+    for (const candidate of candidatesOf(run)) {
         if (candidate.status === "rejected" || candidate.status === "failed") {
-            forSelectionGate.push({
-                ref: candidate.id,
-                kind: "candidate",
-                status: "rejected",
-                reason: candidate.feedbackIds[0] ? `see feedback ${candidate.feedbackIds[0]}` : `candidate ${candidate.id} ${candidate.status}`
-            });
+            forSelectionGate.push({ ref: candidate.id, kind: "candidate", status: "rejected", reason: (candidate.feedbackIds || [])[0] ? `see feedback ${candidate.feedbackIds[0]}` : `candidate ${candidate.id} ${candidate.status}` });
             for (const scoreId of candidate.scores || []) {
                 const score = scores.get(scoreId);
-                if (score && (bestRejectedNormalized === undefined || score.normalized > bestRejectedNormalized)) {
+                if (score && (bestRejectedNormalized === undefined || score.normalized > bestRejectedNormalized))
                     bestRejectedNormalized = score.normalized;
-                }
             }
         }
     }
     for (const [scoreId, score] of scores) {
         if (score.verdict === "fail") {
-            forScoreGate.push({
-                ref: scoreId,
-                kind: "score",
-                status: "rejected",
-                reason: score.notes ? truncate(score.notes) : `score ${scoreId} verdict=fail (normalized ${round(score.normalized)})`
-            });
+            forScoreGate.push({ ref: scoreId, kind: "score", status: "rejected", reason: score.notes ? truncate(score.notes) : `score ${scoreId} verdict=fail (normalized ${round(score.normalized)})` });
         }
     }
-    for (const decision of run.blackboard?.decisions || []) {
+    for (const decision of decisionsOf(run)) {
         if (decision.outcome === "rejected" || decision.outcome === "superseded" || decision.outcome === "conflicting") {
-            forSelectionGate.push({
-                ref: decision.id,
-                kind: "decision",
-                status: mapDecisionOutcome(decision.outcome),
-                reason: decision.reason ? truncate(decision.reason) : `decision ${decision.id} ${decision.outcome}`
-            });
+            forSelectionGate.push({ ref: decision.id, kind: "decision", status: mapDecisionOutcome(decision.outcome), reason: decision.reason ? truncate(decision.reason) : `decision ${decision.id} ${decision.outcome}` });
         }
     }
-    return {
-        forScoreGate: forScoreGate.sort(byRef),
-        forSelectionGate: forSelectionGate.sort(byRef),
-        bestRejectedNormalized
-    };
+    return { forScoreGate: forScoreGate.sort(byRef), forSelectionGate: forSelectionGate.sort(byRef), bestRejectedNormalized };
 }
-// ---------------------------------------------------------------------------
-// Compaction exemption
-//
-// FreeBSD tenet — ORTHOGONALITY & COMPOSABILITY: the reasoning chain composes
-// with the existing graph views and must survive compaction. A reasoning step is
-// on the critical path and must NEVER be collapsed into a synthetic summary
-// node. This returns the operator-graph node ids backing every decision-bearing
-// reasoning step of an adopted chain, so state-explosion can protect them.
-// ---------------------------------------------------------------------------
-function reasoningCriticalNodeIds(run, operator = (0, multi_agent_operator_ux_1.summarizeMultiAgentOperator)(run)) {
+/** Critical-path node ids that state-explosion compaction must never collapse. */
+function reasoningCriticalNodeIds(run) {
     const ids = new Set();
-    const faninIds = new Set((run.multiAgent?.fanins || []).map((entry) => entry.id));
-    const commitById = new Map((run.commits || []).map((commit) => [commit.id, commit]));
-    for (const evidence of operator.evidence) {
+    const faninIds = new Set(faninsOf(run).map((entry) => entry.id));
+    const commitById = new Map(commitsOf(run).map((commit) => [commit.id, commit]));
+    for (const evidence of (0, multi_agent_operator_ux_1.summarizeMultiAgentOperator)(run).evidence) {
         if (evidence.status !== "adopted")
             continue;
         for (const id of evidence.candidateIds)
@@ -403,20 +309,15 @@ function reasoningCriticalNodeIds(run, operator = (0, multi_agent_operator_ux_1.
             ids.add(`${run.id}:score:${id}`);
         for (const id of evidence.selectionIds)
             ids.add(`${run.id}:selection:${id}`);
-        for (const id of evidence.commitIds) {
-            const commit = commitById.get(id);
-            ids.add(commit?.stateNodeId || `${run.id}:commit:${id}`);
-        }
-        for (const adopter of evidence.adoptedBy) {
+        for (const id of evidence.commitIds)
+            ids.add(commitById.get(id)?.stateNodeId || `${run.id}:commit:${id}`);
+        for (const adopter of evidence.adoptedBy)
             if (faninIds.has(adopter))
                 ids.add(`${run.id}:multi-agent:fanin:${adopter}`);
-        }
     }
     return [...ids].sort();
 }
-// ---------------------------------------------------------------------------
-// Persistence + refresh (mirrors state-explosion summaries discipline)
-// ---------------------------------------------------------------------------
+// ---- Persistence + refresh -------------------------------------------------
 function reasoningDir(run) {
     return node_path_1.default.join(run.paths.runDir, "reasoning");
 }
@@ -426,15 +327,9 @@ function refreshEvidenceReasoning(run) {
     node_fs_1.default.mkdirSync(dir, { recursive: true });
     const entries = [];
     for (const chain of report.chains) {
-        const file = node_path_1.default.join(dir, `chain-${(0, state_1.safeFileName)(chain.id)}.json`);
-        (0, state_1.writeJson)(file, chain);
-        entries.push({
-            id: chain.id,
-            path: file,
-            evidenceStatus: chain.evidenceStatus,
-            rationaleStatus: chain.rationaleStatus,
-            sourceFingerprint: fingerprintChains([chain])
-        });
+        const file = node_path_1.default.join(dir, `chain-${(0, fs_atomic_1.safeFileName)(chain.id)}.json`);
+        (0, fs_atomic_1.writeJson)(file, chain);
+        entries.push({ id: chain.id, path: file, evidenceStatus: chain.evidenceStatus, rationaleStatus: chain.rationaleStatus, sourceFingerprint: fingerprintChains([chain]) });
     }
     const indexPath = node_path_1.default.join(dir, "index.json");
     const reportPath = node_path_1.default.join(dir, "report.json");
@@ -447,10 +342,10 @@ function refreshEvidenceReasoning(run) {
         totals: report.totals,
         entries: entries.sort((a, b) => a.id.localeCompare(b.id)),
         paths: { reasoningDir: dir, indexPath, reportPath },
-        nextAction: `node scripts/cw.js multi-agent reasoning ${run.id}`
+        nextAction: `node scripts/cw.js multi-agent reasoning ${run.id}`,
     };
-    (0, state_1.writeJson)(indexPath, index);
-    (0, state_1.writeJson)(reportPath, { ...report, freshness: { ...report.freshness, status: "valid", persistedFingerprint: report.sourceFingerprint } });
+    (0, fs_atomic_1.writeJson)(indexPath, index);
+    (0, fs_atomic_1.writeJson)(reportPath, { ...report, freshness: { ...report.freshness, status: "valid", persistedFingerprint: report.sourceFingerprint } });
     return index;
 }
 function loadEvidenceReasoningIndex(run) {
@@ -475,10 +370,9 @@ function showEvidenceReasoning(run, options = {}) {
     const chains = report.chains.filter((chain) => chain.id === options.evidenceId || chain.ref === options.evidenceId);
     return { ...report, chains, totals: summarizeTotals(chains) };
 }
+/** Derive the reasoning eval sections WITHOUT the persisted index (a replay
+ *  run has no reasoning/index.json). Port of normalizeEvidenceReasoningForEval. */
 function normalizeEvidenceReasoningForEval(run) {
-    // Derive without the persisted index: a replay run has no reasoning/index.json,
-    // so persistence-derived freshness status would drift. Parity is asserted over
-    // the derived content (the CLI smoke test covers valid|stale|absent behavior).
     const report = buildEvidenceReasoningReport(run);
     return {
         reasoningFreshness: [
@@ -489,8 +383,8 @@ function normalizeEvidenceReasoningForEval(run) {
                 unexplained: report.totals.unexplained,
                 notApplicable: report.totals.notApplicable,
                 adopted: report.totals.adopted,
-                rejected: report.totals.rejected
-            })
+                rejected: report.totals.rejected,
+            }),
         ],
         reasoningChains: report.chains
             .map((chain) => JSON.stringify({
@@ -498,21 +392,16 @@ function normalizeEvidenceReasoningForEval(run) {
             evidenceStatus: chain.evidenceStatus,
             rationaleStatus: chain.rationaleStatus,
             gates: chain.steps.map((step) => `${step.gate}:${step.decision}:${step.rationale.status}`),
-            counterfactuals: chain.steps.reduce((total, step) => total + step.counterfactuals.length, 0)
+            counterfactuals: chain.steps.reduce((total, step) => total + step.counterfactuals.length, 0),
         }))
             .sort(),
-        reasoningUnexplained: report.chains
-            .filter((chain) => chain.rationaleStatus === "unexplained")
-            .map((chain) => stripRunId(run, chain.id))
-            .sort()
+        reasoningUnexplained: report.chains.filter((chain) => chain.rationaleStatus === "unexplained").map((chain) => stripRunId(run, chain.id)).sort(),
     };
 }
 function stripRunId(run, id) {
     return id.startsWith(`${run.id}:`) ? id.slice(run.id.length + 1) : id;
 }
-// ---------------------------------------------------------------------------
-// Human formatting (stable, six-panel-compatible idiom)
-// ---------------------------------------------------------------------------
+// ---- Human formatting ------------------------------------------------------
 function formatEvidenceReasoningReport(report) {
     const lines = [];
     lines.push(`Evidence Adoption Reasoning: ${report.runId}`);
@@ -521,9 +410,8 @@ function formatEvidenceReasoningReport(report) {
     lines.push("Adoption Rationale");
     lines.push(`  chains=${report.totals.chains}; explained=${report.totals.explained}; unexplained=${report.totals.unexplained}; n/a=${report.totals.notApplicable}; adopted=${report.totals.adopted}; rejected=${report.totals.rejected}`);
     lines.push("");
-    if (!report.chains.length) {
+    if (!report.chains.length)
         lines.push("  none");
-    }
     for (const chain of report.chains.slice(0, 60)) {
         lines.push(`  [${chain.evidenceStatus}/${chain.rationaleStatus}] ${chain.id} (${chain.ref || chain.sourceKind})`);
         for (const step of chain.steps) {
@@ -531,9 +419,8 @@ function formatEvidenceReasoningReport(report) {
             const why = step.rationale.status === "explained" ? step.rationale.text : `(${step.rationale.status})`;
             const policy = step.authority.policyRef ? ` policy=${step.authority.policyRef}` : "";
             lines.push(`    - ${step.gate} [${step.decision}] by ${actor}${policy}: ${why}`);
-            for (const cf of step.counterfactuals.slice(0, 4)) {
+            for (const cf of step.counterfactuals.slice(0, 4))
                 lines.push(`        x ${cf.kind} ${cf.ref} [${cf.status}]: ${cf.reason}`);
-            }
         }
         for (const reason of chain.unexplainedReasons)
             lines.push(`    ! ${reason}`);
@@ -545,41 +432,30 @@ function formatEvidenceReasoningReport(report) {
     lines.push(`  ${report.nextAction}`);
     return lines.join("\n");
 }
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
+// ---- Helpers ---------------------------------------------------------------
 function basisFor(evidence, extra) {
     return {
         evidenceRefs: unique([evidence.locator || evidence.path || evidence.ref || evidence.id, ...extra.evidenceRefs].filter(Boolean)),
         provenanceSource: provenanceSourceFor(evidence),
         parentEvidenceIds: [],
-        auditEventIds: unique(extra.auditEventIds.filter(Boolean))
+        auditEventIds: unique(extra.auditEventIds.filter(Boolean)),
     };
 }
 function provenanceSourceFor(evidence) {
     const value = evidence.provenanceSource;
-    if (value === "cw-validated" || value === "host-attested" || value === "operator-recorded" || value === "runtime-derived") {
+    if (value === "cw-validated" || value === "host-attested" || value === "operator-recorded" || value === "runtime-derived")
         return value;
-    }
     return undefined;
 }
-// AUTHORITY resolver: links the actor to its role policy when the actor is a
-// role; never fabricates a policy. allowed comes from the recorded decision.
 function roleAuthority(run, actor, allowed) {
-    const role = (run.multiAgent?.roles || []).find((entry) => entry.id === actor);
-    const policyRef = role ? (role.policy || (0, multi_agent_trust_1.policyForRole)(role)).policyRef : undefined;
-    return {
-        actor,
-        actorKind: role ? "role" : actor === "multi-agent-host" ? "operator" : actorKindForActor(actor),
-        policyRef,
-        allowed
-    };
+    const role = rolesOf(run).find((entry) => entry.id === actor);
+    const policyRef = role ? (role.policy || (0, trust_policy_1.policyForRole)(role)).policyRef : undefined;
+    return { actor, actorKind: role ? "role" : actor === "multi-agent-host" ? "operator" : actorKindForActor(actor), policyRef, allowed };
 }
 function rollupRationale(steps, evidenceStatus) {
     const decisionSteps = steps.filter((step) => isDecisionStatus(step.decision));
     if (!decisionSteps.length)
         return "not-applicable";
-    // Explained only when EVERY decision-bearing step is explained — fail closed.
     if (decisionSteps.some((step) => step.rationale.status === "unexplained"))
         return "unexplained";
     if (decisionSteps.every((step) => step.rationale.status === "explained"))
@@ -588,11 +464,7 @@ function rollupRationale(steps, evidenceStatus) {
 }
 function summarizeTotals(chains) {
     const byStatus = {};
-    let explained = 0;
-    let unexplained = 0;
-    let notApplicable = 0;
-    let adopted = 0;
-    let rejected = 0;
+    let explained = 0, unexplained = 0, notApplicable = 0, adopted = 0, rejected = 0;
     for (const chain of chains) {
         byStatus[chain.evidenceStatus] = (byStatus[chain.evidenceStatus] || 0) + 1;
         if (chain.rationaleStatus === "explained")
@@ -611,31 +483,28 @@ function summarizeTotals(chains) {
 function readAllScores(run) {
     const scores = new Map();
     const candidatesDir = run.paths.candidatesDir || node_path_1.default.join(run.paths.runDir, "candidates");
-    for (const candidate of run.candidates || []) {
-        const dir = node_path_1.default.join(candidatesDir, (0, state_1.safeFileName)(candidate.id), "scores");
+    for (const candidate of candidatesOf(run)) {
+        const dir = node_path_1.default.join(candidatesDir, (0, fs_atomic_1.safeFileName)(candidate.id), "scores");
         if (!node_fs_1.default.existsSync(dir))
             continue;
         for (const file of node_fs_1.default.readdirSync(dir).filter((entry) => entry.endsWith(".json")).sort()) {
             try {
-                const score = (0, validation_1.tryValidateCandidateScore)(JSON.parse(node_fs_1.default.readFileSync(node_path_1.default.join(dir, file), "utf8")));
-                if (!score)
-                    continue; // Malformed/forged score shape: skip; the score gate fails closed.
-                scores.set(score.id, score);
+                // Fail closed on a malformed/forged score shape via the shared core
+                // guard (full field-shape check, not just id/normalized).
+                const parsed = (0, validation_1.tryValidateCandidateScore)(JSON.parse(node_fs_1.default.readFileSync(node_path_1.default.join(dir, file), "utf8")));
+                if (!parsed)
+                    continue;
+                scores.set(parsed.id, parsed);
             }
             catch {
-                // Unreadable score record: skip; the score gate will fail closed.
+                // Unreadable score record: skip; the score gate fails closed.
             }
         }
     }
     return scores;
 }
 function fingerprintChains(chains) {
-    const lines = chains.map((chain) => JSON.stringify([
-        chain.id,
-        chain.evidenceStatus,
-        chain.rationaleStatus,
-        chain.steps.map((step) => [step.gate, step.decision, step.rationale.status, step.rationale.sourceId || ""])
-    ]));
+    const lines = chains.map((chain) => JSON.stringify([chain.id, chain.evidenceStatus, chain.rationaleStatus, chain.steps.map((step) => [step.gate, step.decision, step.rationale.status, step.rationale.sourceId || ""])]));
     const hash = node_crypto_1.default.createHash("sha256");
     hash.update(JSON.stringify([...lines].sort()));
     return `sha256:${hash.digest("hex").slice(0, 32)}`;
@@ -649,10 +518,9 @@ function judgeRationaleText(event) {
 }
 function collectAuditIds(score) {
     const ids = [];
-    for (const item of score?.evidence || []) {
+    for (const item of score?.evidence || [])
         for (const id of item.provenance?.auditEventIds || [])
             ids.push(id);
-    }
     return ids;
 }
 function scoreEvidenceRefs(score) {
@@ -661,8 +529,9 @@ function scoreEvidenceRefs(score) {
 function evidenceRef(item) {
     return item.locator || item.path || item.summary || item.id || "";
 }
-function coverageComplete(fanin, _evidence) {
-    return fanin.evidenceCoverage.length > 0 && fanin.evidenceCoverage.every((entry) => entry.complete);
+function coverageComplete(fanin) {
+    const coverage = fanin.evidenceCoverage || [];
+    return coverage.length > 0 && coverage.every((entry) => entry.complete);
 }
 function mapStatus(status) {
     return status;
@@ -719,7 +588,7 @@ function actorKindForSource(sourceKind) {
     return "runtime";
 }
 function statusRank(status) {
-    return { adopted: 0, pending: 1, missing: 2, conflicting: 3, rejected: 4, superseded: 5, unexplained: 6 }[status];
+    return { adopted: 0, pending: 1, missing: 2, conflicting: 3, rejected: 4, superseded: 5, unexplained: 6 }[status] ?? 9;
 }
 function truncate(value) {
     const single = value.replace(/\s+/g, " ").trim();