cool-workflow 0.1.80 → 0.1.82

package/dist/multi-agent-eval/format.js

@@ -0,0 +1,194 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatMultiAgentEval = formatMultiAgentEval;
+// Human formatting for the multi-agent eval replay layer (CLI-only; never affects
+// --json / MCP payloads). Pure functions — a result object in, a string out —
+// carved out of multi-agent-eval.ts (FreeBSD-audit god-module split) so the eval
+// router no longer bundles the rendering layer. The runtime-discriminating type
+// guards travel with the renderer that is their only consumer. Re-exported from
+// multi-agent-eval.ts to keep the public surface byte-unchanged.
+//
+// Types are imported type-only from the parent module: `import type` is fully
+// erased at runtime, so there is no import cycle despite the parent re-exporting
+// formatMultiAgentEval from here.
+const node_path_1 = __importDefault(require("node:path"));
+function formatMultiAgentEval(value) {
+    if (isGate(value)) {
+        return [
+            "Eval Suite",
+            `  ${value.suiteId}`,
+            "",
+            "Replay Status",
+            `  ${value.status} (${value.score}/${value.maxScore})`,
+            "",
+            "Regression Findings",
+            ...(value.findings.length ? value.findings.map((entry) => `  ${entry.severity} ${entry.category}: ${entry.reason}`) : ["  none"]),
+            "",
+            "Final Verdict",
+            `  ${value.verdict}`,
+            "",
+            "Next Action",
+            `  ${value.nextAction}`
+        ].join("\n");
+    }
+    if (isScore(value)) {
+        return [
+            "Eval Suite",
+            `  ${node_path_1.default.basename(value.paths.suiteDir)}`,
+            "",
+            "Replay Status",
+            `  ${value.status} (${value.score}/${value.maxScore})`,
+            "",
+            "Graph Comparison",
+            `  ${metricStatus(value, "replay_completed")}; ${metricStatus(value, "graph_parity")}; ${metricStatus(value, "role_parity")}; ${metricStatus(value, "group_parity")}; ${metricStatus(value, "membership_parity")}; ${metricStatus(value, "fanout_parity")}; ${metricStatus(value, "fanin_parity")}; ${metricStatus(value, "dependency_parity")}; ${metricStatus(value, "failure_parity")}`,
+            "",
+            "Evidence Comparison",
+            `  ${metricStatus(value, "blackboard_record_parity")}; ${metricStatus(value, "evidence_adoption_parity")}; ${metricStatus(value, "blackboard_provenance_parity")}`,
+            "",
+            "Trust / Policy / Audit Comparison",
+            `  ${metricStatus(value, "trust_audit_parity")}; ${metricStatus(value, "role_policy_parity")}; ${metricStatus(value, "permission_decision_parity")}; ${metricStatus(value, "policy_violation_parity")}; ${metricStatus(value, "judge_rationale_parity")}; ${metricStatus(value, "panel_decision_parity")}`,
+            "",
+            "Candidate Score Comparison",
+            `  ${metricStatus(value, "candidate_score_parity")}`,
+            "",
+            "Selection / Commit Gate",
+            `  ${metricStatus(value, "selection_parity")}; ${metricStatus(value, "verifier_commit_gate_parity")}`,
+            "",
+            "State Explosion Summaries",
+            `  ${metricStatus(value, "summary_freshness")}; ${metricStatus(value, "compact_graph_parity")}; ${metricStatus(value, "blackboard_digest_parity")}; ${metricStatus(value, "critical_path_parity")}; ${metricStatus(value, "evidence_digest_parity")}; ${metricStatus(value, "expansion_ref_integrity")}`,
+            "",
+            "Regression Findings",
+            ...(value.findings.length ? value.findings.map((entry) => `  ${entry.severity} ${entry.category}: ${entry.reason}`) : ["  none"]),
+            "",
+            "Final Verdict",
+            `  ${value.status}`,
+            "",
+            "Next Action",
+            `  ${value.status === "pass" ? "Run eval gate or include report path as evidence." : "Review findings before release."}`
+        ].join("\n");
+    }
+    if (isComparison(value)) {
+        return [
+            "Eval Suite",
+            `  ${node_path_1.default.basename(value.paths.suiteDir)}`,
+            "",
+            "Replay Status",
+            `  ${value.status}`,
+            "",
+            "Graph Comparison",
+            `  ${sectionStatus(value, "workflow")}; ${sectionStatus(value, "topologyShape")}; ${sectionStatus(value, "roles")}; ${sectionStatus(value, "groups")}; ${sectionStatus(value, "memberships")}; ${sectionStatus(value, "fanouts")}; ${sectionStatus(value, "fanins")}; ${sectionStatus(value, "dependencyEdges")}; ${sectionStatus(value, "failures")}`,
+            "",
+            "Evidence Comparison",
+            `  ${sectionStatus(value, "blackboardRecords")}; ${sectionStatus(value, "evidenceAdoption")}; ${sectionStatus(value, "messageProvenance")}`,
+            "",
+            "Trust / Policy / Audit Comparison",
+            `  ${sectionStatus(value, "blackboardWriteAudit")}; ${sectionStatus(value, "rolePolicies")}; ${sectionStatus(value, "permissionDecisions")}; ${sectionStatus(value, "policyViolations")}; ${sectionStatus(value, "judgeRationales")}; ${sectionStatus(value, "panelDecisions")}`,
+            "",
+            "Candidate Score Comparison",
+            `  ${sectionStatus(value, "candidateScores")}`,
+            "",
+            "Selection / Commit Gate",
+            `  ${sectionStatus(value, "selectedCandidates")}; ${sectionStatus(value, "verifierCommitGate")}`,
+            "",
+            "Regression Findings",
+            ...(value.findings.length ? value.findings.map((entry) => `  ${entry.severity} ${entry.category}: ${entry.reason}`) : ["  none"]),
+            "",
+            "Final Verdict",
+            `  ${value.status}`,
+            "",
+            "Next Action",
+            "  Score the replay or run the eval gate."
+        ].join("\n");
+    }
+    if (isReplay(value)) {
+        return [
+            "Eval Suite",
+            `  ${node_path_1.default.basename(value.paths.suiteDir)}`,
+            "",
+            "Replay Status",
+            `  ${value.status}`,
+            `  replay=${value.paths.replayRunPath}`,
+            "",
+            "Next Action",
+            `  node scripts/cw.js eval compare ${value.paths.snapshotPath} ${value.paths.replayRunPath}`
+        ].join("\n");
+    }
+    if (isSnapshot(value)) {
+        return [
+            "Eval Suite",
+            `  ${value.id}`,
+            "",
+            "Replay Status",
+            "  snapshot captured",
+            `  snapshot=${value.paths.snapshotPath}`,
+            "",
+            "Graph Comparison",
+            `  topology records=${value.normalized.topologyShape.length}`,
+            "",
+            "Evidence Comparison",
+            `  evidence records=${value.normalized.evidenceAdoption.length}`,
+            "",
+            "Trust / Policy / Audit Comparison",
+            `  audit records=${value.normalized.blackboardWriteAudit.length + value.normalized.messageProvenance.length}`,
+            "",
+            "Candidate Score Comparison",
+            `  score records=${value.normalized.candidateScores.length}`,
+            "",
+            "Selection / Commit Gate",
+            `  selected=${value.normalized.selectedCandidates.length}; commit gates=${value.normalized.verifierCommitGate.length}`,
+            "",
+            "Regression Findings",
+            "  none",
+            "",
+            "Final Verdict",
+            "  snapshot-ready",
+            "",
+            "Next Action",
+            `  node scripts/cw.js eval replay ${value.paths.snapshotPath}`
+        ].join("\n");
+    }
+    if (isReport(value)) {
+        return [
+            "Eval Suite",
+            `  ${node_path_1.default.dirname(value.reportPath)}`,
+            "",
+            "Replay Status",
+            `  ${value.status} (${value.score}/${value.maxScore})`,
+            "",
+            "Final Verdict",
+            `  report written: ${value.reportPath}`,
+            "",
+            "Next Action",
+            "  Run eval gate if this is release evidence."
+        ].join("\n");
+    }
+    return JSON.stringify(value, null, 2);
+}
+function metricStatus(score, id) {
+    const metric = score.metrics.find((entry) => entry.id === id);
+    return `${id}=${metric?.status || "missing"}`;
+}
+function sectionStatus(comparison, id) {
+    return `${id}=${comparison.sections[id]?.status || "missing"}`;
+}
+function isSnapshot(value) {
+    return Boolean(value && typeof value === "object" && value.kind === "multi-agent-replay-snapshot");
+}
+function isReplay(value) {
+    return Boolean(value && typeof value === "object" && value.kind === "multi-agent-replay-run");
+}
+function isComparison(value) {
+    return Boolean(value && typeof value === "object" && "sections" in value && "findings" in value);
+}
+function isScore(value) {
+    return Boolean(value && typeof value === "object" && "metrics" in value && "score" in value);
+}
+function isGate(value) {
+    return Boolean(value && typeof value === "object" && "verdict" in value && "requiredArtifacts" in value);
+}
+function isReport(value) {
+    return Boolean(value && typeof value === "object" && "reportPath" in value && !("verdict" in value));
+}

package/dist/multi-agent-eval/normalize.js

@@ -0,0 +1,51 @@
+"use strict";
+// Pure, stateless normalization helpers for the multi-agent eval replay layer —
+// timestamp/path scrubbing, recursive value normalization, and stable
+// stringification. Carved out of multi-agent-eval.ts (FreeBSD-audit god-module
+// split) so the eval router no longer bundles the deterministic-normalization
+// primitives. Nothing here touches state; everything is a pure function of its
+// arguments. Re-exported verbatim from multi-agent-eval.ts so every importer
+// (including node-snapshot.ts and reclamation.ts) stays byte-unchanged.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeValue = normalizeValue;
+exports.lines = lines;
+exports.replayStableStringify = replayStableStringify;
+function normalizeValue(value) {
+    if (Array.isArray(value))
+        return value.map(normalizeValue);
+    if (!value || typeof value !== "object") {
+        if (typeof value === "string")
+            return normalizeString(value);
+        return value;
+    }
+    const record = value;
+    const normalized = {};
+    for (const key of Object.keys(record).sort()) {
+        if (["createdAt", "updatedAt", "recordedAt", "selectedAt", "replayedAt", "generatedAt"].includes(key))
+            continue;
+        if (key.endsWith("Path") || key === "path" || key === "cwd" || key === "runDir" || key.endsWith("Dir")) {
+            normalized[key] = normalizeString(String(record[key]));
+        }
+        else {
+            normalized[key] = normalizeValue(record[key]);
+        }
+    }
+    return normalized;
+}
+function normalizeString(value) {
+    return value
+        .replace(/[0-9]{8}T[0-9]{6}Z/g, "<timestamp>")
+        .replace(/[0-9]{4}-[0-9]{2}-[0-9]{2}T[0-9:.]+Z/g, "<timestamp>")
+        .replace(/\/[^"\s]+\/\.cw\/runs\/[^"\s/]+/g, "<run-dir>")
+        .replace(/\/[^"\s]+\/\.cw\/evals\/[^"\s/]+/g, "<eval-dir>")
+        .replace(/\/var\/folders\/[^"\s]+|\/tmp\/[^"\s]+|\/private\/tmp\/[^"\s]+/g, "<tmp>");
+}
+function lines(value) {
+    const normalized = normalizeValue(value);
+    if (Array.isArray(normalized))
+        return normalized.map((entry) => replayStableStringify(entry)).sort();
+    return [replayStableStringify(normalized)].sort();
+}
+function replayStableStringify(value) {
+    return JSON.stringify(normalizeValue(value));
+}

package/dist/multi-agent-eval.js

@@ -3,16 +3,13 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatMultiAgentEval = exports.replayStableStringify = exports.normalizeValue = exports.lines = void 0;
 exports.createMultiAgentReplaySnapshot = createMultiAgentReplaySnapshot;
 exports.replayMultiAgentSnapshot = replayMultiAgentSnapshot;
 exports.compareMultiAgentReplay = compareMultiAgentReplay;
 exports.scoreMultiAgentReplay = scoreMultiAgentReplay;
 exports.gateMultiAgentEval = gateMultiAgentEval;
 exports.reportMultiAgentEval = reportMultiAgentEval;
-exports.formatMultiAgentEval = formatMultiAgentEval;
-exports.normalizeValue = normalizeValue;
-exports.lines = lines;
-exports.stableStringify = stableStringify;
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
 const multi_agent_1 = require("./multi-agent");
@@ -24,6 +21,16 @@ const trust_audit_1 = require("./trust-audit");
 const state_explosion_1 = require("./state-explosion");
 const evidence_reasoning_1 = require("./evidence-reasoning");
 const state_1 = require("./state");
+const normalize_1 = require("./multi-agent-eval/normalize");
+// Pure normalization primitives carved into ./multi-agent-eval/normalize.ts;
+// re-exported verbatim so every external importer stays byte-unchanged.
+var normalize_2 = require("./multi-agent-eval/normalize");
+Object.defineProperty(exports, "lines", { enumerable: true, get: function () { return normalize_2.lines; } });
+Object.defineProperty(exports, "normalizeValue", { enumerable: true, get: function () { return normalize_2.normalizeValue; } });
+Object.defineProperty(exports, "replayStableStringify", { enumerable: true, get: function () { return normalize_2.replayStableStringify; } });
+// Human formatter (CLI-only renderer) carved into ./multi-agent-eval/format.ts.
+var format_1 = require("./multi-agent-eval/format");
+Object.defineProperty(exports, "formatMultiAgentEval", { enumerable: true, get: function () { return format_1.formatMultiAgentEval; } });
 const METRIC_SECTIONS = [
     { metric: "replay_completed", section: "workflow", title: "Replay completed" },
     { metric: "graph_parity", section: "topologyShape", title: "Topology graph parity" },
@@ -84,7 +91,7 @@ function createMultiAgentReplaySnapshot(run, options = {}) {
             appVersion: run.workflow.app?.version,
             title: run.workflow.title
         },
-        inputs: normalizeValue(run.inputs),
+        inputs: (0, normalize_1.normalizeValue)(run.inputs),
         paths: {
             suiteDir,
             snapshotPath,
@@ -117,6 +124,14 @@ function replayMultiAgentSnapshot(target, options = {}) {
     const replayDir = node_path_1.default.join(suiteDir, "replay");
     const replayRunPath = node_path_1.default.join(suiteDir, "replay-run.json");
     node_fs_1.default.mkdirSync(replayDir, { recursive: true });
+    // RE-DERIVE the projection from the raw captured state instead of copying
+    // snapshot.normalized. Copying the baseline would make compareMultiAgentReplay
+    // diff the baseline against a byte-copy of itself, so a projection-determinism
+    // regression in normalizeRun could never be caught (the determinism moat would
+    // be false-green). We reconstruct the run from the captured raw state and run
+    // the SAME normalizeRun pipeline used at capture time, producing an INDEPENDENT
+    // re-projection the comparison can pit against the baseline.
+    const replayed = rederiveNormalizedFromSnapshot(snapshot);
     const replay = {
         schemaVersion: 1,
         kind: "multi-agent-replay-run",
@@ -132,7 +147,7 @@ function replayMultiAgentSnapshot(target, options = {}) {
             replayRunPath,
             snapshotPath: snapshot.paths.snapshotPath
         },
-        replay: snapshot.normalized,
+        replay: replayed,
         errors: []
     };
     (0, state_1.writeJson)(replayRunPath, replay);
@@ -152,7 +167,7 @@ function compareMultiAgentReplay(baselineTarget, replayTarget) {
     const findings = [];
     for (const spec of ALL_METRIC_SECTIONS) {
         const { baselineValue, replayValue } = comparisonValues(spec.metric, spec.section, baseline.normalized, replay);
-        const equal = stableStringify(baselineValue) === stableStringify(replayValue);
+        const equal = (0, normalize_1.replayStableStringify)(baselineValue) === (0, normalize_1.replayStableStringify)(replayValue);
         const id = String(spec.section);
         sections[id] = {
             id,
@@ -391,157 +406,23 @@ function loadScoreForTarget(target, scorePath) {
     }
     return scoreMultiAgentReplay(target);
 }
-function formatMultiAgentEval(value) {
-    if (isGate(value)) {
-        return [
-            "Eval Suite",
-            `  ${value.suiteId}`,
-            "",
-            "Replay Status",
-            `  ${value.status} (${value.score}/${value.maxScore})`,
-            "",
-            "Regression Findings",
-            ...(value.findings.length ? value.findings.map((entry) => `  ${entry.severity} ${entry.category}: ${entry.reason}`) : ["  none"]),
-            "",
-            "Final Verdict",
-            `  ${value.verdict}`,
-            "",
-            "Next Action",
-            `  ${value.nextAction}`
-        ].join("\n");
+// Re-derive snapshot.normalized INDEPENDENTLY at replay time. The raw captured
+// state is the baseline run state file (snapshot.paths.baselineStatePath) — the
+// same WorkflowRun captureRun/normalizeRun projected at capture time. We re-load
+// it and re-run the IDENTICAL normalizeRun pipeline, so the result is a genuine
+// re-projection rather than a copy of the baseline. Fail-closed: if the raw
+// state cannot be reconstructed we throw (never silently fall back to the
+// baseline copy — that is exactly the false-green this guards against).
+function rederiveNormalizedFromSnapshot(snapshot) {
+    const statePath = snapshot.paths.baselineStatePath;
+    if (!statePath || !node_fs_1.default.existsSync(statePath)) {
+        throw new Error(`Cannot re-derive replay projection: baseline run state missing at ${statePath || "<unset>"}; re-snapshot from a live run before replaying.`);
     }
-    if (isScore(value)) {
-        return [
-            "Eval Suite",
-            `  ${node_path_1.default.basename(value.paths.suiteDir)}`,
-            "",
-            "Replay Status",
-            `  ${value.status} (${value.score}/${value.maxScore})`,
-            "",
-            "Graph Comparison",
-            `  ${metricStatus(value, "replay_completed")}; ${metricStatus(value, "graph_parity")}; ${metricStatus(value, "role_parity")}; ${metricStatus(value, "group_parity")}; ${metricStatus(value, "membership_parity")}; ${metricStatus(value, "fanout_parity")}; ${metricStatus(value, "fanin_parity")}; ${metricStatus(value, "dependency_parity")}; ${metricStatus(value, "failure_parity")}`,
-            "",
-            "Evidence Comparison",
-            `  ${metricStatus(value, "blackboard_record_parity")}; ${metricStatus(value, "evidence_adoption_parity")}; ${metricStatus(value, "blackboard_provenance_parity")}`,
-            "",
-            "Trust / Policy / Audit Comparison",
-            `  ${metricStatus(value, "trust_audit_parity")}; ${metricStatus(value, "role_policy_parity")}; ${metricStatus(value, "permission_decision_parity")}; ${metricStatus(value, "policy_violation_parity")}; ${metricStatus(value, "judge_rationale_parity")}; ${metricStatus(value, "panel_decision_parity")}`,
-            "",
-            "Candidate Score Comparison",
-            `  ${metricStatus(value, "candidate_score_parity")}`,
-            "",
-            "Selection / Commit Gate",
-            `  ${metricStatus(value, "selection_parity")}; ${metricStatus(value, "verifier_commit_gate_parity")}`,
-            "",
-            "State Explosion Summaries",
-            `  ${metricStatus(value, "summary_freshness")}; ${metricStatus(value, "compact_graph_parity")}; ${metricStatus(value, "blackboard_digest_parity")}; ${metricStatus(value, "critical_path_parity")}; ${metricStatus(value, "evidence_digest_parity")}; ${metricStatus(value, "expansion_ref_integrity")}`,
-            "",
-            "Regression Findings",
-            ...(value.findings.length ? value.findings.map((entry) => `  ${entry.severity} ${entry.category}: ${entry.reason}`) : ["  none"]),
-            "",
-            "Final Verdict",
-            `  ${value.status}`,
-            "",
-            "Next Action",
-            `  ${value.status === "pass" ? "Run eval gate or include report path as evidence." : "Review findings before release."}`
-        ].join("\n");
+    const result = (0, state_1.loadRunStateFile)(statePath, { dryRun: true });
+    if (result.report.status === "unsupported") {
+        throw new Error(`Cannot re-derive replay projection: baseline run state at ${statePath} is unsupported: ${result.report.errors.join("; ")}`);
     }
-    if (isComparison(value)) {
-        return [
-            "Eval Suite",
-            `  ${node_path_1.default.basename(value.paths.suiteDir)}`,
-            "",
-            "Replay Status",
-            `  ${value.status}`,
-            "",
-            "Graph Comparison",
-            `  ${sectionStatus(value, "workflow")}; ${sectionStatus(value, "topologyShape")}; ${sectionStatus(value, "roles")}; ${sectionStatus(value, "groups")}; ${sectionStatus(value, "memberships")}; ${sectionStatus(value, "fanouts")}; ${sectionStatus(value, "fanins")}; ${sectionStatus(value, "dependencyEdges")}; ${sectionStatus(value, "failures")}`,
-            "",
-            "Evidence Comparison",
-            `  ${sectionStatus(value, "blackboardRecords")}; ${sectionStatus(value, "evidenceAdoption")}; ${sectionStatus(value, "messageProvenance")}`,
-            "",
-            "Trust / Policy / Audit Comparison",
-            `  ${sectionStatus(value, "blackboardWriteAudit")}; ${sectionStatus(value, "rolePolicies")}; ${sectionStatus(value, "permissionDecisions")}; ${sectionStatus(value, "policyViolations")}; ${sectionStatus(value, "judgeRationales")}; ${sectionStatus(value, "panelDecisions")}`,
-            "",
-            "Candidate Score Comparison",
-            `  ${sectionStatus(value, "candidateScores")}`,
-            "",
-            "Selection / Commit Gate",
-            `  ${sectionStatus(value, "selectedCandidates")}; ${sectionStatus(value, "verifierCommitGate")}`,
-            "",
-            "Regression Findings",
-            ...(value.findings.length ? value.findings.map((entry) => `  ${entry.severity} ${entry.category}: ${entry.reason}`) : ["  none"]),
-            "",
-            "Final Verdict",
-            `  ${value.status}`,
-            "",
-            "Next Action",
-            "  Score the replay or run the eval gate."
-        ].join("\n");
-    }
-    if (isReplay(value)) {
-        return [
-            "Eval Suite",
-            `  ${node_path_1.default.basename(value.paths.suiteDir)}`,
-            "",
-            "Replay Status",
-            `  ${value.status}`,
-            `  replay=${value.paths.replayRunPath}`,
-            "",
-            "Next Action",
-            `  node scripts/cw.js eval compare ${value.paths.snapshotPath} ${value.paths.replayRunPath}`
-        ].join("\n");
-    }
-    if (isSnapshot(value)) {
-        return [
-            "Eval Suite",
-            `  ${value.id}`,
-            "",
-            "Replay Status",
-            "  snapshot captured",
-            `  snapshot=${value.paths.snapshotPath}`,
-            "",
-            "Graph Comparison",
-            `  topology records=${value.normalized.topologyShape.length}`,
-            "",
-            "Evidence Comparison",
-            `  evidence records=${value.normalized.evidenceAdoption.length}`,
-            "",
-            "Trust / Policy / Audit Comparison",
-            `  audit records=${value.normalized.blackboardWriteAudit.length + value.normalized.messageProvenance.length}`,
-            "",
-            "Candidate Score Comparison",
-            `  score records=${value.normalized.candidateScores.length}`,
-            "",
-            "Selection / Commit Gate",
-            `  selected=${value.normalized.selectedCandidates.length}; commit gates=${value.normalized.verifierCommitGate.length}`,
-            "",
-            "Regression Findings",
-            "  none",
-            "",
-            "Final Verdict",
-            "  snapshot-ready",
-            "",
-            "Next Action",
-            `  node scripts/cw.js eval replay ${value.paths.snapshotPath}`
-        ].join("\n");
-    }
-    if (isReport(value)) {
-        return [
-            "Eval Suite",
-            `  ${node_path_1.default.dirname(value.reportPath)}`,
-            "",
-            "Replay Status",
-            `  ${value.status} (${value.score}/${value.maxScore})`,
-            "",
-            "Final Verdict",
-            `  report written: ${value.reportPath}`,
-            "",
-            "Next Action",
-            "  Run eval gate if this is release evidence."
-        ].join("\n");
-    }
-    return JSON.stringify(value, null, 2);
+    return normalizeRun(result.run);
 }
 function captureRun(run) {
     return {
@@ -566,13 +447,13 @@ function normalizeRun(run) {
     const topologies = (0, topology_1.summarizeTopologies)(run);
     const multiAgent = (0, multi_agent_1.summarizeMultiAgent)(run);
     return {
-        workflow: normalizeValue({
+        workflow: (0, normalize_1.normalizeValue)({
             id: run.workflow.id,
             appId: run.workflow.app?.id,
             appVersion: run.workflow.app?.version,
             taskCount: run.tasks.length
         }),
-        topologyShape: lines([
+        topologyShape: (0, normalize_1.lines)([
             topologies.active.map((entry) => ({
                 topologyId: entry.topologyId,
                 status: entry.status,
@@ -583,22 +464,22 @@ function normalizeRun(run) {
             })),
             multiAgent.groupsDetail
         ]),
-        roles: lines(run.multiAgent?.roles || []),
-        groups: lines(run.multiAgent?.groups || []),
-        memberships: lines(run.multiAgent?.memberships || []),
-        fanouts: lines(run.multiAgent?.fanouts || []),
-        fanins: lines(run.multiAgent?.fanins || []),
-        dependencyEdges: lines(operator.dependencies.map((entry) => ({ from: entry.from, to: entry.to, label: entry.label, status: entry.status }))),
-        failures: lines(operator.failures.map((entry) => ({ kind: entry.kind, status: entry.status, owner: entry.owner, reason: entry.reason }))),
-        blackboardRecords: lines([blackboard.boards, blackboard.topics, blackboard.messages, blackboard.contexts, blackboard.artifacts, blackboard.snapshots, blackboard.decisions]),
-        messageProvenance: lines(trust.messageProvenance || []),
-        rolePolicies: lines(trust.rolePolicies || []),
-        permissionDecisions: lines(trust.permissionDecisions || []),
-        blackboardWriteAudit: lines(trust.blackboardWrites || []),
-        judgeRationales: lines(trust.judgeRationales || []),
-        panelDecisions: lines(trust.panelDecisions || []),
-        policyViolations: lines(trust.policyViolations || []),
-        evidenceAdoption: lines(operator.evidence.map((entry) => ({
+        roles: (0, normalize_1.lines)(run.multiAgent?.roles || []),
+        groups: (0, normalize_1.lines)(run.multiAgent?.groups || []),
+        memberships: (0, normalize_1.lines)(run.multiAgent?.memberships || []),
+        fanouts: (0, normalize_1.lines)(run.multiAgent?.fanouts || []),
+        fanins: (0, normalize_1.lines)(run.multiAgent?.fanins || []),
+        dependencyEdges: (0, normalize_1.lines)(operator.dependencies.map((entry) => ({ from: entry.from, to: entry.to, label: entry.label, status: entry.status }))),
+        failures: (0, normalize_1.lines)(operator.failures.map((entry) => ({ kind: entry.kind, status: entry.status, owner: entry.owner, reason: entry.reason }))),
+        blackboardRecords: (0, normalize_1.lines)([blackboard.boards, blackboard.topics, blackboard.messages, blackboard.contexts, blackboard.artifacts, blackboard.snapshots, blackboard.decisions]),
+        messageProvenance: (0, normalize_1.lines)(trust.messageProvenance || []),
+        rolePolicies: (0, normalize_1.lines)(trust.rolePolicies || []),
+        permissionDecisions: (0, normalize_1.lines)(trust.permissionDecisions || []),
+        blackboardWriteAudit: (0, normalize_1.lines)(trust.blackboardWrites || []),
+        judgeRationales: (0, normalize_1.lines)(trust.judgeRationales || []),
+        panelDecisions: (0, normalize_1.lines)(trust.panelDecisions || []),
+        policyViolations: (0, normalize_1.lines)(trust.policyViolations || []),
+        evidenceAdoption: (0, normalize_1.lines)(operator.evidence.map((entry) => ({
             ref: entry.ref || entry.id,
             status: entry.status,
             adoptedBy: entry.adoptedBy,
@@ -606,15 +487,15 @@ function normalizeRun(run) {
             selectionIds: entry.selectionIds,
             commitIds: entry.commitIds
         }))),
-        candidateScores: lines(collectCandidateScores(run)),
-        selectedCandidates: lines((run.candidateSelections || []).map((entry) => ({
+        candidateScores: (0, normalize_1.lines)(collectCandidateScores(run)),
+        selectedCandidates: (0, normalize_1.lines)((run.candidateSelections || []).map((entry) => ({
             candidateId: entry.candidateId,
             scoreId: entry.scoreId,
             verifierNodeId: entry.verifierNodeId,
             reason: entry.reason,
             evidenceCount: entry.evidence.length
         }))),
-        verifierCommitGate: lines((run.commits || []).map((entry) => ({
+        verifierCommitGate: (0, normalize_1.lines)((run.commits || []).map((entry) => ({
             verifierGated: Boolean(entry.verifierGated),
             checkpoint: Boolean(entry.checkpoint),
             candidateId: entry.candidateId,
@@ -631,7 +512,11 @@ function collectCandidateScores(run) {
     const scores = [];
     for (const candidate of run.candidates || []) {
         for (const scoreId of candidate.scores || []) {
-            const scorePath = node_path_1.default.join(run.paths.candidatesDir || node_path_1.default.join(run.paths.runDir, "candidates"), `${(0, state_1.safeFileName)(candidate.id)}.${(0, state_1.safeFileName)(scoreId)}.score.json`);
+            // Canonical nested score path — MUST match the writers (candidate-scoring.ts
+            // persistScore, commit.ts): candidates/<candidateId>/scores/<scoreId>.json.
+            // The old flat `<id>.<scoreId>.score.json` path was written by nobody, so the
+            // candidate_score_parity eval metric silently scored empty placeholders.
+            const scorePath = node_path_1.default.join(run.paths.candidatesDir || node_path_1.default.join(run.paths.runDir, "candidates"), (0, state_1.safeFileName)(candidate.id), "scores", `${(0, state_1.safeFileName)(scoreId)}.json`);
             if (node_fs_1.default.existsSync(scorePath)) {
                 const score = (0, state_1.readJson)(scorePath);
                 scores.push({
@@ -784,45 +669,6 @@ function loadSuiteFromDir(suiteDir) {
         paths: { suiteDir, snapshotPath: node_path_1.default.join(suiteDir, "snapshot.json") }
     };
 }
-function normalizeValue(value) {
-    if (Array.isArray(value))
-        return value.map(normalizeValue);
-    if (!value || typeof value !== "object") {
-        if (typeof value === "string")
-            return normalizeString(value);
-        return value;
-    }
-    const record = value;
-    const normalized = {};
-    for (const key of Object.keys(record).sort()) {
-        if (["createdAt", "updatedAt", "recordedAt", "selectedAt", "replayedAt", "generatedAt"].includes(key))
-            continue;
-        if (key.endsWith("Path") || key === "path" || key === "cwd" || key === "runDir" || key.endsWith("Dir")) {
-            normalized[key] = normalizeString(String(record[key]));
-        }
-        else {
-            normalized[key] = normalizeValue(record[key]);
-        }
-    }
-    return normalized;
-}
-function normalizeString(value) {
-    return value
-        .replace(/[0-9]{8}T[0-9]{6}Z/g, "<timestamp>")
-        .replace(/[0-9]{4}-[0-9]{2}-[0-9]{2}T[0-9:.]+Z/g, "<timestamp>")
-        .replace(/\/[^"\s]+\/\.cw\/runs\/[^"\s/]+/g, "<run-dir>")
-        .replace(/\/[^"\s]+\/\.cw\/evals\/[^"\s/]+/g, "<eval-dir>")
-        .replace(/\/var\/folders\/[^"\s]+|\/tmp\/[^"\s]+|\/private\/tmp\/[^"\s]+/g, "<tmp>");
-}
-function lines(value) {
-    const normalized = normalizeValue(value);
-    if (Array.isArray(normalized))
-        return normalized.map((entry) => stableStringify(entry)).sort();
-    return [stableStringify(normalized)].sort();
-}
-function stableStringify(value) {
-    return JSON.stringify(normalizeValue(value));
-}
 function now() {
     return new Date().toISOString();
 }
@@ -830,28 +676,3 @@ function metricLine(score, id) {
     const metric = score.metrics.find((entry) => entry.id === id);
     return `- ${id}: ${metric?.status || "missing"} - ${metric?.reason || "metric missing"}`;
 }
-function metricStatus(score, id) {
-    const metric = score.metrics.find((entry) => entry.id === id);
-    return `${id}=${metric?.status || "missing"}`;
-}
-function sectionStatus(comparison, id) {
-    return `${id}=${comparison.sections[id]?.status || "missing"}`;
-}
-function isSnapshot(value) {
-    return Boolean(value && typeof value === "object" && value.kind === "multi-agent-replay-snapshot");
-}
-function isReplay(value) {
-    return Boolean(value && typeof value === "object" && value.kind === "multi-agent-replay-run");
-}
-function isComparison(value) {
-    return Boolean(value && typeof value === "object" && "sections" in value && "findings" in value);
-}
-function isScore(value) {
-    return Boolean(value && typeof value === "object" && "metrics" in value && "score" in value);
-}
-function isGate(value) {
-    return Boolean(value && typeof value === "object" && "verdict" in value && "requiredArtifacts" in value);
-}
-function isReport(value) {
-    return Boolean(value && typeof value === "object" && "reportPath" in value && !("verdict" in value));
-}