cool-workflow 0.1.80 → 0.1.81

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,
@@ -152,7 +159,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,158 +398,6 @@ 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");
-    }
-    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 captureRun(run) {
     return {
         topology: run.topologies || { schemaVersion: 1, runs: [] },
@@ -566,13 +421,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 +438,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 +461,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 +486,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 +643,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 +650,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));
-}

package/dist/multi-agent-host.js

@@ -3,7 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.hostRun = hostRun;
 exports.hostStatus = hostStatus;
 exports.hostStep = hostStep;
-exports.hostAutoStep = hostAutoStep;
 exports.hostBlackboard = hostBlackboard;
 exports.hostScore = hostScore;
 exports.hostSelect = hostSelect;
@@ -179,24 +178,6 @@ function hostStep(run, options = {}) {
         requiredHostAction: "No safe deterministic step is available. Use multi-agent status for the next explicit command."
     });
 }
-/** Auto-step: loop hostStep until blocked, complete, or max iterations reached
- *  (v0.1.74). Each iteration performs one deterministic step. Returns the final
- *  response and the number of steps taken. */
-function hostAutoStep(run, options = {}) {
-    const maxSteps = Number(options.maxSteps || options["max-steps"] || 20);
-    const steps = [];
-    let response = envelope(run, "step", { performed: "none" });
-    for (let i = 0; i < maxSteps; i++) {
-        response = hostStep(run, options);
-        const performed = response.data?.performed;
-        steps.push({ step: i + 1, performed: String(performed || "none") });
-        if (performed === "none" || performed === undefined)
-            break;
-        if (response.data?.requiredHostAction)
-            break;
-    }
-    return { finalResponse: response, stepsTaken: steps.length, steps };
-}
 function hostBlackboard(run, action, options = {}) {
     const topology = optionalSingleActiveTopology(run);
     const blackboardId = resolveHostBlackboardId(run, topology, options);