cool-workflow 0.1.78

package/dist/state-explosion.js

@@ -0,0 +1,1213 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GRAPH_VIEWS = exports.DEFAULT_STATE_EXPLOSION_THRESHOLDS = exports.STATE_EXPLOSION_SCHEMA_VERSION = void 0;
+exports.computeStateSize = computeStateSize;
+exports.summarizeBlackboardDigest = summarizeBlackboardDigest;
+exports.buildCompactGraph = buildCompactGraph;
+exports.buildOperatorDigest = buildOperatorDigest;
+exports.buildStateExplosionReport = buildStateExplosionReport;
+exports.maybeCompactRun = maybeCompactRun;
+exports.refreshStateExplosionSummaries = refreshStateExplosionSummaries;
+exports.loadStateExplosionSummaryIndex = loadStateExplosionSummaryIndex;
+exports.showStateExplosionSummary = showStateExplosionSummary;
+exports.formatStateExplosionReport = formatStateExplosionReport;
+exports.formatCompactGraph = formatCompactGraph;
+exports.formatBlackboardDigest = formatBlackboardDigest;
+exports.stateExplosionReportLines = stateExplosionReportLines;
+exports.normalizeStateExplosionForEval = normalizeStateExplosionForEval;
+exports.fingerprintStrings = fingerprintStrings;
+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 coordinator_1 = require("./coordinator");
+const multi_agent_operator_ux_1 = require("./multi-agent-operator-ux");
+const trust_audit_1 = require("./trust-audit");
+const evidence_reasoning_1 = require("./evidence-reasoning");
+exports.STATE_EXPLOSION_SCHEMA_VERSION = 1;
+exports.DEFAULT_STATE_EXPLOSION_THRESHOLDS = {
+    graphNodes: 40,
+    graphEdges: 60,
+    blackboardMessages: 25,
+    blackboardRecords: 40,
+    collapseBucket: 6,
+    totalRecords: 80
+};
+exports.GRAPH_VIEWS = [
+    "full",
+    "compact",
+    "critical-path",
+    "failures",
+    "evidence",
+    "trust",
+    "topology",
+    "blackboard",
+    "candidate",
+    "commit-gate"
+];
+// ---------------------------------------------------------------------------
+// State size
+// ---------------------------------------------------------------------------
+function computeStateSize(run, thresholds = exports.DEFAULT_STATE_EXPLOSION_THRESHOLDS) {
+    const ma = run.multiAgent || { runs: [], roles: [], groups: [], memberships: [], fanouts: [], fanins: [] };
+    const bb = run.blackboard || { topics: [], messages: [], contexts: [], artifacts: [], snapshots: [], decisions: [] };
+    const graph = (0, multi_agent_operator_ux_1.buildMultiAgentOperatorGraph)(run);
+    const counts = {
+        multiAgentRuns: (ma.runs || []).length,
+        roles: (ma.roles || []).length,
+        groups: (ma.groups || []).length,
+        memberships: (ma.memberships || []).length,
+        fanouts: (ma.fanouts || []).length,
+        fanins: (ma.fanins || []).length,
+        topics: (bb.topics || []).length,
+        messages: (bb.messages || []).length,
+        contexts: (bb.contexts || []).length,
+        artifacts: (bb.artifacts || []).length,
+        snapshots: (bb.snapshots || []).length,
+        decisions: (bb.decisions || []).length,
+        graphNodes: graph.nodes.length,
+        graphEdges: graph.edges.length
+    };
+    const total = counts.multiAgentRuns +
+        counts.roles +
+        counts.groups +
+        counts.memberships +
+        counts.fanouts +
+        counts.fanins +
+        counts.topics +
+        counts.messages +
+        counts.contexts +
+        counts.artifacts +
+        counts.snapshots +
+        counts.decisions;
+    const reasons = [];
+    if (counts.graphNodes > thresholds.graphNodes)
+        reasons.push(`graph has ${counts.graphNodes} nodes (> ${thresholds.graphNodes})`);
+    if (counts.graphEdges > thresholds.graphEdges)
+        reasons.push(`graph has ${counts.graphEdges} edges (> ${thresholds.graphEdges})`);
+    if (counts.messages > thresholds.blackboardMessages)
+        reasons.push(`blackboard has ${counts.messages} messages (> ${thresholds.blackboardMessages})`);
+    const bbRecords = counts.topics + counts.messages + counts.contexts + counts.artifacts + counts.snapshots + counts.decisions;
+    if (bbRecords > thresholds.blackboardRecords)
+        reasons.push(`blackboard has ${bbRecords} records (> ${thresholds.blackboardRecords})`);
+    if (total > thresholds.totalRecords)
+        reasons.push(`run has ${total} multi-agent records (> ${thresholds.totalRecords})`);
+    return { ...counts, total, compactionRecommended: reasons.length > 0, reasons: reasons.sort() };
+}
+// ---------------------------------------------------------------------------
+// Blackboard digest (deterministic structural summary)
+// ---------------------------------------------------------------------------
+function summarizeBlackboardDigest(run, blackboardId) {
+    const bb = run.blackboard || {
+        boards: [],
+        topics: [],
+        messages: [],
+        contexts: [],
+        artifacts: [],
+        snapshots: [],
+        decisions: []
+    };
+    const board = blackboardId ? (bb.boards || []).find((b) => b.id === blackboardId) : (bb.boards || [])[0];
+    const boardId = board?.id;
+    const inBoard = (items) => boardId ? items.filter((item) => item.blackboardId === boardId) : items;
+    const topics = inBoard(bb.topics || []);
+    const messages = inBoard(bb.messages || []);
+    const contexts = inBoard(bb.contexts || []);
+    const artifacts = inBoard(bb.artifacts || []);
+    const decisions = inBoard(bb.decisions || []);
+    const summary = (0, coordinator_1.summarizeBlackboard)(run, boardId);
+    const topicRollups = topics
+        .map((topic) => {
+        const topicMessages = messages.filter((m) => m.topicId === topic.id);
+        return {
+            id: topic.id,
+            label: `${topic.title} (${topicMessages.length} messages, ${topic.contextIds.length} contexts, ${topic.artifactRefIds.length} artifacts)`,
+            status: topic.status,
+            sourceIds: [topic.id, ...topicMessages.map((m) => m.id)],
+            evidenceRefs: unique(topicMessages.flatMap((m) => m.linkedEvidenceRefs || [])),
+            expansionCommand: `node scripts/cw.js blackboard message list ${run.id} --topic ${topic.id}`
+        };
+    })
+        .sort(byId);
+    const threadSummaries = topics
+        .map((topic) => {
+        const topicMessages = messages
+            .filter((m) => m.topicId === topic.id)
+            .sort((a, b) => a.createdAt.localeCompare(b.createdAt) || a.id.localeCompare(b.id));
+        const last = topicMessages[topicMessages.length - 1];
+        return {
+            id: `thread:${topic.id}`,
+            label: `${topic.title}: ${topicMessages.length} messages${last ? `; latest by ${last.author.kind}:${last.author.id}` : ""}`,
+            status: topic.status,
+            sourceIds: topicMessages.map((m) => m.id),
+            evidenceRefs: unique(topicMessages.flatMap((m) => m.linkedEvidenceRefs || [])),
+            expansionCommand: `node scripts/cw.js blackboard message list ${run.id} --topic ${topic.id}`
+        };
+    })
+        .filter((entry) => entry.sourceIds.length)
+        .sort(byId);
+    const unresolvedQuestions = contexts
+        .filter((c) => c.kind === "question" && c.status === "open")
+        .map((c) => ({
+        id: c.id,
+        label: `${c.key}: ${truncate(c.value)}`,
+        status: c.status,
+        sourceIds: [c.id],
+        evidenceRefs: unique([...(c.evidenceRefs || []), ...(c.artifactRefIds || [])]),
+        expansionCommand: `node scripts/cw.js blackboard message post ${run.id} --topic ${c.topicId} --body "<answer with evidence>"`
+    }))
+        .sort(byId);
+    const conflicts = contexts
+        .filter((c) => c.status === "conflicting" || (c.conflictingContextIds || []).length)
+        .map((c) => ({
+        id: c.id,
+        label: `${c.key} conflicts with ${(c.conflictingContextIds || []).join(", ") || "another value"}`,
+        status: c.status,
+        sourceIds: [c.id, ...(c.conflictingContextIds || [])],
+        evidenceRefs: unique([...(c.evidenceRefs || []), ...(c.artifactRefIds || [])]),
+        expansionCommand: `node scripts/cw.js coordinator decision ${run.id} --kind conflict-resolution --outcome accepted --subject ${c.id} --reason "<reason>"`
+    }))
+        .sort(byId);
+    const decisionEntries = decisions
+        .map((d) => ({
+        id: d.id,
+        label: `${d.kind}:${d.outcome} ${truncate(d.reason)}`,
+        status: d.status,
+        sourceIds: [d.id, ...(d.subjectIds || [])],
+        evidenceRefs: unique([...(d.evidenceRefs || []), ...(d.artifactRefIds || [])]),
+        expansionCommand: `node scripts/cw.js node show ${run.id} ${run.id}:coordinator:decision:${d.id}`
+    }))
+        .sort(byId);
+    const artifactEntries = artifacts
+        .map((a) => ({
+        id: a.id,
+        label: `${a.kind} ${a.locator || a.path || a.id}`,
+        status: a.status,
+        sourceIds: [a.id],
+        evidenceRefs: unique(a.evidenceRefs || []),
+        expansionCommand: `node scripts/cw.js blackboard artifact list ${run.id}`
+    }))
+        .sort(byId);
+    const adoptedEvidence = artifacts
+        .filter((a) => a.status === "active")
+        .map((a) => ({
+        id: `evidence:${a.id}`,
+        label: `${a.kind} ${a.locator || a.path || a.id}`,
+        status: a.status,
+        sourceIds: [a.id],
+        evidenceRefs: unique([a.locator || a.path || a.id, ...(a.evidenceRefs || [])]),
+        expansionCommand: `node scripts/cw.js audit blackboard ${run.id} --json`
+    }))
+        .sort(byId);
+    const missingEvidence = (summary.missingEvidence || [])
+        .map((reason, index) => ({
+        id: `missing:${index}:${slug(reason)}`,
+        label: reason,
+        status: "missing",
+        sourceIds: [],
+        evidenceRefs: [],
+        expansionCommand: `node scripts/cw.js multi-agent failures ${run.id}`
+    }))
+        .sort(byId);
+    const policyViolations = decisions
+        .filter((d) => d.outcome === "rejected" || d.outcome === "blocked" || d.outcome === "conflicting")
+        .map((d) => ({
+        id: `policy:${d.id}`,
+        label: `${d.kind}:${d.outcome} ${truncate(d.reason)}`,
+        status: d.status,
+        sourceIds: [d.id],
+        evidenceRefs: unique(d.evidenceRefs || []),
+        expansionCommand: `node scripts/cw.js audit policy ${run.id} --json`
+    }))
+        .sort(byId);
+    const judgeRationale = messages
+        .filter((m) => (m.tags || []).includes("judge-rationale") || Boolean(m.metadata?.judgeRationale))
+        .map((m) => ({
+        id: `judge:${m.id}`,
+        label: `${m.author.kind}:${m.author.id} ${truncate(m.body)}`,
+        status: m.status,
+        sourceIds: [m.id],
+        evidenceRefs: unique(m.linkedEvidenceRefs || []),
+        expansionCommand: `node scripts/cw.js audit judge ${run.id} --json`
+    }))
+        .sort(byId);
+    const recentChanges = [...messages, ...contexts, ...artifacts, ...decisions]
+        .map((record) => ({
+        id: record.id,
+        kind: record.kind,
+        updatedAt: record.updatedAt,
+        status: record.status
+    }))
+        .sort((a, b) => b.updatedAt.localeCompare(a.updatedAt) || a.id.localeCompare(b.id))
+        .slice(0, 10)
+        .map((record) => ({
+        id: `recent:${record.id}`,
+        label: `${record.id} (${record.status})`,
+        status: record.status,
+        sourceIds: [record.id],
+        evidenceRefs: [],
+        expansionCommand: `node scripts/cw.js node show ${run.id} ${record.id}`
+    }))
+        .sort(byId);
+    const highSignal = [
+        ...conflicts,
+        ...unresolvedQuestions,
+        ...policyViolations,
+        ...missingEvidence
+    ].sort(byId);
+    const sourceRecordIds = unique([
+        ...topics.map((t) => t.id),
+        ...messages.map((m) => m.id),
+        ...contexts.map((c) => c.id),
+        ...artifacts.map((a) => a.id),
+        ...decisions.map((d) => d.id)
+    ]);
+    const evidenceRefs = unique([
+        ...messages.flatMap((m) => m.linkedEvidenceRefs || []),
+        ...artifacts.flatMap((a) => [a.locator || a.path || a.id, ...(a.evidenceRefs || [])]),
+        ...contexts.flatMap((c) => c.evidenceRefs || [])
+    ]);
+    const trustAuditEventRefs = unique([
+        ...messages.flatMap((m) => m.linkedAuditEventIds || []),
+        ...artifacts.flatMap((a) => a.trustAuditEventIds || [])
+    ]);
+    const fingerprint = fingerprintRecords([...topics, ...messages, ...contexts, ...artifacts, ...decisions]);
+    return {
+        schemaVersion: exports.STATE_EXPLOSION_SCHEMA_VERSION,
+        runId: run.id,
+        id: `blackboard-digest${boardId ? `:${boardId}` : ""}`,
+        scope: "blackboard",
+        blackboardId: boardId,
+        sourceRecordIds,
+        sourceFingerprint: fingerprint,
+        includedCount: topicRollups.length + conflicts.length + unresolvedQuestions.length + decisionEntries.length + artifactEntries.length,
+        omittedCount: Math.max(0, messages.length - threadSummaries.length),
+        importantRefs: unique([
+            ...conflicts.map((c) => c.id),
+            ...unresolvedQuestions.map((q) => q.id),
+            ...policyViolations.map((p) => p.id)
+        ]),
+        evidenceRefs,
+        trustAuditEventRefs,
+        generatedAt: new Date().toISOString(),
+        status: "valid",
+        deterministic: true,
+        nextAction: summary.nextAction || `node scripts/cw.js blackboard summary ${run.id}`,
+        topicRollups,
+        threadSummaries,
+        unresolvedQuestions,
+        conflicts,
+        decisions: decisionEntries,
+        artifacts: artifactEntries,
+        adoptedEvidence,
+        missingEvidence,
+        policyViolations,
+        judgeRationale,
+        recentChanges,
+        highSignal
+    };
+}
+function buildCompactGraph(run, view = "compact", options = {}) {
+    const thresholds = options.thresholds || exports.DEFAULT_STATE_EXPLOSION_THRESHOLDS;
+    const full = (0, multi_agent_operator_ux_1.buildMultiAgentOperatorGraph)(run);
+    const operator = (0, multi_agent_operator_ux_1.summarizeMultiAgentOperator)(run);
+    const critical = criticalPathNodeIds(run, operator);
+    const protectedIds = new Set(critical);
+    // Failures, blocked, rejected, conflicting nodes are always preserved.
+    for (const node of full.nodes) {
+        if (isProtectedStatus(node.status))
+            protectedIds.add(node.id);
+    }
+    // v0.1.26: reasoning steps are on the critical path and must never be collapsed
+    // into a synthetic summary node — protect every decision-gate node backing an
+    // adopted reasoning chain (notably score nodes, which are otherwise collapsed).
+    for (const id of (0, evidence_reasoning_1.reasoningCriticalNodeIds)(run))
+        protectedIds.add(id);
+    for (const failure of operator.failures) {
+        if (failure.linked)
+            protectedIds.add(failure.linked);
+    }
+    const parents = parentMap(full.edges);
+    const parentOf = (id) => parents.get(id);
+    let scopeNodes = full.nodes;
+    let scopeEdges = full.edges;
+    if (view !== "full" && view !== "compact" && view !== "critical-path") {
+        const filtered = filterByView(run, view, full, operator, protectedIds);
+        scopeNodes = filtered.nodes;
+        scopeEdges = filtered.edges;
+    }
+    // Focus + depth: keep nodes within BFS depth of focus; collapse the rest.
+    let focusKeep;
+    if (options.focus) {
+        focusKeep = bfsNeighborhood(options.focus, scopeNodes, scopeEdges, options.depth ?? 1);
+        for (const id of focusKeep)
+            protectedIds.add(id);
+    }
+    const collapseEnabled = view === "compact" || view === "critical-path" || Boolean(options.focus);
+    if (view === "full" || !collapseEnabled) {
+        // No collapse: emit scoped graph verbatim (still records provenance + critical path).
+        return finalizeGraphRecord(run, view, options, full, {
+            nodes: scopeNodes.map((node) => ({ ...node })),
+            edges: scopeEdges.map((edge) => ({ ...edge })),
+            syntheticNodes: [],
+            critical,
+            operator
+        });
+    }
+    // Determine collapse buckets per node.
+    const rule = collapseRuleFor(view);
+    const keep = new Set();
+    const buckets = new Map();
+    for (const node of scopeNodes) {
+        if (protectedIds.has(node.id) || (focusKeep && focusKeep.has(node.id))) {
+            keep.add(node.id);
+            continue;
+        }
+        if (view === "critical-path") {
+            // Collapse everything not on the critical path into one bucket per kind.
+            const key = `critical-context:${node.kind}`;
+            buckets.set(key, [...(buckets.get(key) || []), node.id]);
+            continue;
+        }
+        if (!shouldCollapseKind(node.kind, rule)) {
+            keep.add(node.id);
+            continue;
+        }
+        const key = rule.bucketBy(node, parentOf);
+        buckets.set(key, [...(buckets.get(key) || []), node.id]);
+    }
+    // Buckets smaller than the collapse threshold stay expanded (unless critical-path).
+    const synthetic = [];
+    const collapsedNodeIds = new Map(); // sourceNodeId -> syntheticId
+    for (const [key, ids] of [...buckets.entries()].sort((a, b) => a[0].localeCompare(b[0]))) {
+        if (view !== "critical-path" && ids.length < thresholds.collapseBucket) {
+            for (const id of ids)
+                keep.add(id);
+            continue;
+        }
+        const members = scopeNodes.filter((node) => ids.includes(node.id));
+        const internalEdges = scopeEdges.filter((edge) => ids.includes(edge.from) && ids.includes(edge.to));
+        const syntheticId = `${run.id}:summary:${slug(key)}`;
+        const dominant = dominantStatus(members.map((m) => m.status));
+        const blocked = members.find((m) => isProtectedStatus(m.status));
+        synthetic.push({
+            id: syntheticId,
+            kind: "summary",
+            label: `${key} (${ids.length} collapsed)`,
+            status: dominant,
+            collapsedNodeCount: ids.length,
+            collapsedEdgeCount: internalEdges.length,
+            sourceIds: [...ids].sort(),
+            dominantStatus: dominant,
+            blockedReason: blocked ? `${blocked.kind} ${blocked.id} is ${blocked.status}` : undefined,
+            expansionCommand: expansionCommandFor(run, view, key)
+        });
+        for (const id of ids)
+            collapsedNodeIds.set(id, syntheticId);
+    }
+    const redirect = (id) => collapsedNodeIds.get(id) || id;
+    const nodes = [];
+    for (const node of scopeNodes) {
+        if (keep.has(node.id))
+            nodes.push({ ...node });
+    }
+    for (const syn of synthetic) {
+        nodes.push({
+            id: syn.id,
+            kind: "summary",
+            label: syn.label,
+            status: syn.status,
+            synthetic: syn
+        });
+    }
+    const edgeSeen = new Set();
+    const edges = [];
+    for (const edge of scopeEdges) {
+        const from = redirect(edge.from);
+        const to = redirect(edge.to);
+        if (from === to)
+            continue; // edge fully internal to a synthetic node
+        const key = `${from}\0${to}\0${edge.label || ""}`;
+        if (edgeSeen.has(key))
+            continue;
+        edgeSeen.add(key);
+        edges.push({ from, to, label: edge.label });
+    }
+    return finalizeGraphRecord(run, view, options, full, {
+        nodes: nodes.sort((a, b) => a.kind.localeCompare(b.kind) || a.id.localeCompare(b.id)),
+        edges: edges.sort((a, b) => a.from.localeCompare(b.from) || a.to.localeCompare(b.to) || (a.label || "").localeCompare(b.label || "")),
+        syntheticNodes: synthetic.sort((a, b) => a.id.localeCompare(b.id)),
+        critical,
+        operator
+    });
+}
+function finalizeGraphRecord(run, view, options, full, built) {
+    const collapsedNodeCount = built.syntheticNodes.reduce((acc, syn) => acc + syn.collapsedNodeCount, 0);
+    const collapsedEdgeCount = built.syntheticNodes.reduce((acc, syn) => acc + syn.collapsedEdgeCount, 0);
+    const blockedReasons = unique([
+        ...built.operator.failures.map((f) => `${f.kind} ${f.id}: ${f.reason}`),
+        ...built.syntheticNodes.filter((s) => s.blockedReason).map((s) => s.blockedReason)
+    ]);
+    return {
+        schemaVersion: exports.STATE_EXPLOSION_SCHEMA_VERSION,
+        runId: run.id,
+        id: `graph-${view}${options.focus ? `:focus:${slug(options.focus)}` : ""}`,
+        scope: "run",
+        view,
+        focus: options.focus,
+        depth: options.depth,
+        fullNodeCount: full.nodes.length,
+        fullEdgeCount: full.edges.length,
+        compactNodeCount: built.nodes.length,
+        compactEdgeCount: built.edges.length,
+        collapsedNodeCount,
+        collapsedEdgeCount,
+        syntheticNodes: built.syntheticNodes,
+        criticalPath: built.critical,
+        blockedReasons,
+        nodes: built.nodes,
+        edges: built.edges,
+        sourceRecordIds: full.nodes.map((n) => n.id).sort(),
+        sourceFingerprint: fingerprintStrings(full.nodes.map((n) => `${n.id}:${n.status}`)),
+        includedCount: built.nodes.length,
+        omittedCount: collapsedNodeCount,
+        importantRefs: built.critical,
+        evidenceRefs: [],
+        trustAuditEventRefs: [],
+        generatedAt: new Date().toISOString(),
+        status: "valid",
+        deterministic: true,
+        nextAction: collapsedNodeCount > 0
+            ? `node scripts/cw.js multi-agent graph ${run.id} --view full --json`
+            : `node scripts/cw.js multi-agent graph ${run.id} --view ${view} --json`
+    };
+}
+function collapseRuleFor(view) {
+    return {
+        collapse: true,
+        bucketBy: (node, parentOf) => {
+            switch (node.kind) {
+                case "blackboard-message":
+                    return "messages";
+                case "blackboard-context":
+                    return "contexts";
+                case "agent-membership": {
+                    const parent = parentOf(node.id);
+                    return `memberships:${parent ? parent.split(":").pop() : "unscoped"}`;
+                }
+                case "worker":
+                    return "workers";
+                case "score":
+                    return "scores";
+                case "blackboard-snapshot":
+                    return "snapshots";
+                default:
+                    return `${node.kind}`;
+            }
+        }
+    };
+}
+function shouldCollapseKind(kind, _rule) {
+    // Collapsible kinds (high-volume, low-individual-signal). Decisions, artifacts,
+    // fanins, candidates, selections, commits and feedback are NEVER collapsed so
+    // failures, evidence, policy and judge rationale stay visible.
+    return [
+        "blackboard-message",
+        "blackboard-context",
+        "agent-membership",
+        "worker",
+        "score",
+        "blackboard-snapshot",
+        "agent-role"
+    ].includes(kind);
+}
+function filterByView(run, view, full, operator, protectedIds) {
+    const keepKinds = (kinds) => {
+        const ids = new Set();
+        for (const node of full.nodes) {
+            if (kinds.includes(node.kind) || protectedIds.has(node.id))
+                ids.add(node.id);
+        }
+        return ids;
+    };
+    let ids;
+    switch (view) {
+        case "failures": {
+            ids = new Set();
+            for (const failure of operator.failures) {
+                if (failure.linked)
+                    ids.add(failure.linked);
+            }
+            for (const node of full.nodes)
+                if (isProtectedStatus(node.status))
+                    ids.add(node.id);
+            ids.add(`${run.id}:run`);
+            break;
+        }
+        case "evidence":
+            ids = keepKinds([
+                "multi-agent-run-root",
+                "blackboard",
+                "blackboard-topic",
+                "blackboard-artifact",
+                "blackboard-message",
+                "agent-membership",
+                "agent-fanin",
+                "candidate",
+                "selection",
+                "commit"
+            ]);
+            break;
+        case "trust":
+            ids = keepKinds([
+                "multi-agent-run-root",
+                "blackboard",
+                "coordinator-decision",
+                "agent-fanin",
+                "candidate",
+                "selection",
+                "commit"
+            ]);
+            break;
+        case "topology":
+            ids = keepKinds([
+                "multi-agent-run-root",
+                "topology",
+                "multi-agent-run",
+                "agent-group",
+                "agent-role",
+                "agent-fanout",
+                "agent-fanin"
+            ]);
+            break;
+        case "blackboard":
+            ids = keepKinds([
+                "multi-agent-run-root",
+                "blackboard",
+                "blackboard-topic",
+                "blackboard-message",
+                "blackboard-context",
+                "blackboard-artifact",
+                "blackboard-snapshot",
+                "coordinator-decision"
+            ]);
+            break;
+        case "candidate":
+            ids = keepKinds(["multi-agent-run-root", "candidate", "score", "selection", "worker", "agent-fanin"]);
+            break;
+        case "commit-gate":
+            ids = keepKinds(["multi-agent-run-root", "selection", "commit", "candidate", "agent-fanin"]);
+            break;
+        default:
+            ids = new Set(full.nodes.map((n) => n.id));
+    }
+    const nodes = full.nodes.filter((node) => ids.has(node.id));
+    const edges = full.edges.filter((edge) => ids.has(edge.from) && ids.has(edge.to));
+    return { nodes, edges };
+}
+function criticalPathNodeIds(run, operator) {
+    const ids = [`${run.id}:run`];
+    const ma = run.multiAgent;
+    for (const record of ma?.runs || [])
+        ids.push(`${run.id}:multi-agent:${record.id}`);
+    for (const group of ma?.groups || [])
+        ids.push(`${run.id}:multi-agent:group:${group.id}`);
+    for (const fanout of ma?.fanouts || [])
+        ids.push(`${run.id}:multi-agent:fanout:${fanout.id}`);
+    for (const fanin of ma?.fanins || [])
+        ids.push(`${run.id}:multi-agent:fanin:${fanin.id}`);
+    for (const selection of run.candidateSelections || []) {
+        ids.push(`${run.id}:selection:${selection.id}`);
+        ids.push(`${run.id}:candidate:${selection.candidateId}`);
+    }
+    for (const commit of run.commits || []) {
+        if (commit.verifierGated)
+            ids.push(commit.stateNodeId || `${run.id}:commit:${commit.id}`);
+    }
+    // Blocked dependencies live on the critical path because they gate completion.
+    for (const failure of operator.failures) {
+        if (failure.linked)
+            ids.push(failure.linked);
+    }
+    return unique(ids);
+}
+function bfsNeighborhood(focus, nodes, edges, depth) {
+    const adjacency = new Map();
+    for (const edge of edges) {
+        if (!adjacency.has(edge.from))
+            adjacency.set(edge.from, new Set());
+        if (!adjacency.has(edge.to))
+            adjacency.set(edge.to, new Set());
+        adjacency.get(edge.from).add(edge.to);
+        adjacency.get(edge.to).add(edge.from);
+    }
+    const keep = new Set([focus]);
+    let frontier = new Set([focus]);
+    for (let level = 0; level < Math.max(0, depth); level += 1) {
+        const next = new Set();
+        for (const id of frontier) {
+            for (const neighbor of adjacency.get(id) || []) {
+                if (!keep.has(neighbor)) {
+                    keep.add(neighbor);
+                    next.add(neighbor);
+                }
+            }
+        }
+        frontier = next;
+    }
+    return keep;
+}
+function expansionCommandFor(run, view, key) {
+    if (key === "messages" || key.startsWith("thread"))
+        return `node scripts/cw.js blackboard message list ${run.id}`;
+    if (key.startsWith("memberships"))
+        return `node scripts/cw.js multi-agent graph ${run.id} --view full --json`;
+    return `node scripts/cw.js multi-agent graph ${run.id} --view full --focus ${key} --json`;
+}
+// ---------------------------------------------------------------------------
+// Operator digest
+// ---------------------------------------------------------------------------
+function buildOperatorDigest(run, thresholds = exports.DEFAULT_STATE_EXPLOSION_THRESHOLDS) {
+    const stateSize = computeStateSize(run, thresholds);
+    const operator = (0, multi_agent_operator_ux_1.summarizeMultiAgentOperator)(run);
+    const compact = buildCompactGraph(run, "compact", { thresholds });
+    const blackboard = summarizeBlackboardDigest(run);
+    const evidence = operator.evidence;
+    const adopted = evidence.filter((e) => e.status === "adopted");
+    const missing = evidence.filter((e) => e.status === "missing" || e.status === "pending" || e.status === "conflicting");
+    const rejected = evidence.filter((e) => e.status === "rejected");
+    const trust = operator.summaries.trust;
+    const hiddenSourceRecords = compact.syntheticNodes.map((syn) => ({
+        kind: syn.id.split(":summary:")[1] || syn.kind,
+        count: syn.collapsedNodeCount,
+        expansionCommand: syn.expansionCommand
+    }));
+    const expansionCommands = unique([
+        `node scripts/cw.js multi-agent graph ${run.id} --view full --json`,
+        `node scripts/cw.js blackboard message list ${run.id} --topic <topic-id>`,
+        `node scripts/cw.js multi-agent graph ${run.id} --view critical-path`,
+        `node scripts/cw.js multi-agent failures ${run.id} --json`,
+        ...compact.syntheticNodes.map((syn) => syn.expansionCommand)
+    ]);
+    return {
+        schemaVersion: exports.STATE_EXPLOSION_SCHEMA_VERSION,
+        runId: run.id,
+        id: "operator-digest",
+        scope: "run",
+        sourceRecordIds: compact.sourceRecordIds,
+        sourceFingerprint: fingerprintStrings([
+            compact.sourceFingerprint,
+            blackboard.sourceFingerprint,
+            String(stateSize.total)
+        ]),
+        includedCount: compact.compactNodeCount,
+        omittedCount: compact.collapsedNodeCount,
+        importantRefs: compact.criticalPath,
+        evidenceRefs: unique(adopted.map((e) => e.ref || e.id)),
+        trustAuditEventRefs: [],
+        generatedAt: new Date().toISOString(),
+        status: "valid",
+        deterministic: true,
+        nextAction: operator.nextAction,
+        stateSize,
+        compactGraphRef: compact.id,
+        blackboardDigestRef: blackboard.id,
+        criticalPath: compact.criticalPath,
+        failures: operator.failures.map((f) => ({
+            id: f.id,
+            kind: f.kind,
+            status: f.status,
+            reason: f.reason,
+            nextCommand: f.nextCommand
+        })),
+        evidenceDigest: {
+            adopted: adopted.length,
+            missing: missing.length,
+            rejected: rejected.length,
+            entries: [...adopted, ...missing].slice(0, 40).map((e) => ({
+                id: e.id,
+                label: `${e.ref || e.id} (${e.status})`,
+                status: e.status,
+                sourceIds: [e.sourceId || e.id].filter(Boolean),
+                evidenceRefs: [e.ref || e.id].filter(Boolean),
+                expansionCommand: `node scripts/cw.js multi-agent evidence ${run.id} --json`
+            }))
+        },
+        trustDigest: {
+            events: trust?.totalEvents || 0,
+            policyViolations: blackboard.policyViolations.length,
+            judgeRationales: blackboard.judgeRationale.length,
+            entries: unique([
+                ...blackboard.policyViolations.map((p) => p.id),
+                ...blackboard.judgeRationale.map((j) => j.id)
+            ])
+        },
+        hiddenSourceRecords,
+        expansionCommands
+    };
+}
+// ---------------------------------------------------------------------------
+// State explosion report (combines all derived indexes)
+// ---------------------------------------------------------------------------
+function buildStateExplosionReport(run, options = {}) {
+    const thresholds = options.thresholds || exports.DEFAULT_STATE_EXPLOSION_THRESHOLDS;
+    const stateSize = computeStateSize(run, thresholds);
+    const compactGraph = buildCompactGraph(run, "compact", { thresholds });
+    const criticalPathGraph = buildCompactGraph(run, "critical-path", { thresholds });
+    const blackboardDigest = summarizeBlackboardDigest(run);
+    const operatorDigest = buildOperatorDigest(run, thresholds);
+    const currentFingerprint = fingerprintStrings([
+        compactGraph.sourceFingerprint,
+        blackboardDigest.sourceFingerprint,
+        operatorDigest.sourceFingerprint,
+        String(stateSize.total)
+    ]);
+    const persisted = options.index;
+    const staleScopes = [];
+    let status = persisted ? "valid" : "absent";
+    if (persisted) {
+        if (persisted.sourceFingerprint !== currentFingerprint)
+            status = "stale";
+        for (const entry of persisted.entries) {
+            const current = currentEntryFingerprint(run, entry, { compactGraph, blackboardDigest, operatorDigest });
+            if (current && current !== entry.sourceFingerprint)
+                staleScopes.push(`${entry.scope}:${entry.id}`);
+        }
+        if (staleScopes.length)
+            status = "stale";
+    }
+    const nextAction = status === "stale" || status === "absent"
+        ? `node scripts/cw.js summary refresh ${run.id}`
+        : operatorDigest.nextAction;
+    return {
+        schemaVersion: exports.STATE_EXPLOSION_SCHEMA_VERSION,
+        runId: run.id,
+        generatedAt: new Date().toISOString(),
+        stateSize,
+        freshness: {
+            status,
+            persistedFingerprint: persisted?.sourceFingerprint,
+            currentFingerprint,
+            staleScopes: staleScopes.sort()
+        },
+        index: persisted,
+        compactGraph,
+        criticalPathGraph,
+        blackboardDigest,
+        operatorDigest,
+        hiddenSourceRecords: operatorDigest.hiddenSourceRecords,
+        expansionCommands: operatorDigest.expansionCommands,
+        nextAction
+    };
+}
+function currentEntryFingerprint(run, entry, records) {
+    if (entry.scope === "blackboard")
+        return records.blackboardDigest.sourceFingerprint;
+    if (entry.id.startsWith("graph-")) {
+        if (entry.id === records.compactGraph.id)
+            return records.compactGraph.sourceFingerprint;
+        return undefined;
+    }
+    if (entry.id === "operator-digest")
+        return records.operatorDigest.sourceFingerprint;
+    return undefined;
+}
+// ---------------------------------------------------------------------------
+// Persistence + refresh
+// ---------------------------------------------------------------------------
+/** Check state size and auto-compact if thresholds exceeded. Best-effort —
+ *  errors are silently caught; never fail a state mutation for compaction.
+ *  BSD: mechanism (check + refresh); policy (when to call) is at the call site. */
+function maybeCompactRun(run) {
+    try {
+        const size = computeStateSize(run);
+        if (size.compactionRecommended) {
+            refreshStateExplosionSummaries(run);
+        }
+    }
+    catch {
+        // Best-effort optimization only.
+    }
+}
+function summariesDir(run) {
+    return node_path_1.default.join(run.paths.runDir, "summaries");
+}
+function refreshStateExplosionSummaries(run, options = {}) {
+    const thresholds = options.thresholds || exports.DEFAULT_STATE_EXPLOSION_THRESHOLDS;
+    const dir = summariesDir(run);
+    node_fs_1.default.mkdirSync(dir, { recursive: true });
+    const views = options.views || ["full", "compact", "critical-path", "failures", "evidence", "trust", "topology", "blackboard", "candidate", "commit-gate"];
+    const blackboardDigest = summarizeBlackboardDigest(run);
+    const operatorDigest = buildOperatorDigest(run, thresholds);
+    const graphRecords = views.map((view) => buildCompactGraph(run, view, { thresholds }));
+    const entries = [];
+    const writeRecord = (id, record, scope, fingerprint, included, omitted) => {
+        const file = node_path_1.default.join(dir, `${(0, state_1.safeFileName)(id)}.json`);
+        (0, state_1.writeJson)(file, record);
+        entries.push({ scope, id, path: file, sourceFingerprint: fingerprint, includedCount: included, omittedCount: omitted, status: "valid" });
+    };
+    writeRecord(blackboardDigest.id, blackboardDigest, "blackboard", blackboardDigest.sourceFingerprint, blackboardDigest.includedCount, blackboardDigest.omittedCount);
+    writeRecord(operatorDigest.id, operatorDigest, "run", operatorDigest.sourceFingerprint, operatorDigest.includedCount, operatorDigest.omittedCount);
+    for (const record of graphRecords) {
+        writeRecord(record.id, record, "run", record.sourceFingerprint, record.compactNodeCount, record.collapsedNodeCount);
+    }
+    const stateSize = computeStateSize(run, thresholds);
+    const indexFingerprint = fingerprintStrings([
+        operatorDigest.sourceFingerprint,
+        blackboardDigest.sourceFingerprint,
+        ...graphRecords.map((r) => r.sourceFingerprint),
+        String(stateSize.total)
+    ]);
+    const reportPath = node_path_1.default.join(dir, "state-explosion-report.json");
+    const index = {
+        schemaVersion: exports.STATE_EXPLOSION_SCHEMA_VERSION,
+        runId: run.id,
+        id: "multi-agent-summary-index",
+        scope: "run",
+        sourceRecordIds: unique([...blackboardDigest.sourceRecordIds, ...operatorDigest.sourceRecordIds]),
+        sourceFingerprint: fingerprintStrings([
+            buildCompactGraph(run, "compact", { thresholds }).sourceFingerprint,
+            blackboardDigest.sourceFingerprint,
+            operatorDigest.sourceFingerprint,
+            String(stateSize.total)
+        ]),
+        includedCount: entries.reduce((acc, e) => acc + e.includedCount, 0),
+        omittedCount: entries.reduce((acc, e) => acc + e.omittedCount, 0),
+        importantRefs: operatorDigest.criticalPath,
+        evidenceRefs: operatorDigest.evidenceRefs,
+        trustAuditEventRefs: blackboardDigest.trustAuditEventRefs,
+        generatedAt: new Date().toISOString(),
+        status: "valid",
+        deterministic: true,
+        nextAction: `node scripts/cw.js summary show ${run.id}`,
+        entries: entries.sort((a, b) => a.id.localeCompare(b.id)),
+        views,
+        paths: {
+            summariesDir: dir,
+            indexPath: node_path_1.default.join(dir, "index.json"),
+            reportPath
+        }
+    };
+    void indexFingerprint;
+    (0, state_1.writeJson)(index.paths.indexPath, index);
+    const report = buildStateExplosionReport(run, { thresholds, index });
+    (0, state_1.writeJson)(reportPath, report);
+    (0, trust_audit_1.recordTrustAuditEvent)(run, {
+        kind: "summary.refresh",
+        decision: "recorded",
+        source: "runtime-derived",
+        actor: "cw",
+        metadata: {
+            deterministic: true,
+            scopes: entries.map((e) => `${e.scope}:${e.id}`),
+            includedRecords: index.includedCount,
+            omittedRecords: index.omittedCount,
+            compactionRecommended: stateSize.compactionRecommended,
+            sourceFingerprint: index.sourceFingerprint,
+            stale: false
+        }
+    });
+    return index;
+}
+function loadStateExplosionSummaryIndex(run) {
+    const indexPath = node_path_1.default.join(summariesDir(run), "index.json");
+    if (!node_fs_1.default.existsSync(indexPath))
+        return undefined;
+    try {
+        const parsed = JSON.parse(node_fs_1.default.readFileSync(indexPath, "utf8"));
+        if (!parsed || parsed.id !== "multi-agent-summary-index")
+            return undefined;
+        return parsed;
+    }
+    catch {
+        return undefined;
+    }
+}
+function showStateExplosionSummary(run, options = {}) {
+    const index = loadStateExplosionSummaryIndex(run);
+    const report = buildStateExplosionReport(run, { thresholds: options.thresholds, index });
+    if (index && report.freshness.status === "stale") {
+        (0, trust_audit_1.recordTrustAuditEvent)(run, {
+            kind: "summary.stale",
+            decision: "failed",
+            source: "runtime-derived",
+            actor: "cw",
+            metadata: {
+                persistedFingerprint: report.freshness.persistedFingerprint,
+                currentFingerprint: report.freshness.currentFingerprint,
+                staleScopes: report.freshness.staleScopes
+            }
+        });
+    }
+    return report;
+}
+// ---------------------------------------------------------------------------
+// Human formatting
+// ---------------------------------------------------------------------------
+function formatStateExplosionReport(report) {
+    const lines = [];
+    const size = report.stateSize;
+    lines.push(`State Explosion Report: ${report.runId}`);
+    lines.push(`Freshness: ${report.freshness.status}${report.freshness.staleScopes.length ? ` (stale: ${report.freshness.staleScopes.join(", ")})` : ""}`);
+    lines.push("");
+    lines.push("State Size");
+    lines.push(`  records=${size.total}; graph nodes=${size.graphNodes}; graph edges=${size.graphEdges}; messages=${size.messages}; compaction=${size.compactionRecommended ? "recommended" : "not needed"}`);
+    for (const reason of size.reasons)
+        lines.push(`  - ${reason}`);
+    lines.push("");
+    lines.push("Compact Graph");
+    lines.push(`  full=${report.compactGraph.fullNodeCount} nodes/${report.compactGraph.fullEdgeCount} edges -> compact=${report.compactGraph.compactNodeCount} nodes/${report.compactGraph.compactEdgeCount} edges`);
+    if (report.compactGraph.collapsedNodeCount > 0) {
+        lines.push(`  Graph compacted: ${report.compactGraph.collapsedNodeCount} nodes collapsed into ${report.compactGraph.syntheticNodes.length} summary nodes`);
+    }
+    for (const syn of report.compactGraph.syntheticNodes) {
+        lines.push(`  [${syn.dominantStatus}] ${syn.id} collapses ${syn.collapsedNodeCount} nodes/${syn.collapsedEdgeCount} edges${syn.blockedReason ? ` blocked=${syn.blockedReason}` : ""}; expand: ${syn.expansionCommand}`);
+    }
+    lines.push("");
+    lines.push("Blackboard Digest");
+    lines.push(`  topics=${report.blackboardDigest.topicRollups.length}; threads=${report.blackboardDigest.threadSummaries.length}; unresolved=${report.blackboardDigest.unresolvedQuestions.length}; conflicts=${report.blackboardDigest.conflicts.length}; decisions=${report.blackboardDigest.decisions.length}; artifacts=${report.blackboardDigest.artifacts.length}`);
+    for (const topic of report.blackboardDigest.topicRollups.slice(0, 20))
+        lines.push(`  - ${topic.label}; expand: ${topic.expansionCommand}`);
+    lines.push("");
+    lines.push("Critical Path");
+    if (!report.criticalPathGraph.criticalPath.length)
+        lines.push("  none");
+    for (const id of report.criticalPathGraph.criticalPath.slice(0, 40))
+        lines.push(`  -> ${id}`);
+    lines.push("");
+    lines.push("Failures / Blockers");
+    if (!report.operatorDigest.failures.length)
+        lines.push("  none");
+    for (const failure of report.operatorDigest.failures.slice(0, 30))
+        lines.push(`  [${failure.status}] ${failure.kind} ${failure.id}: ${failure.reason}; next=${failure.nextCommand}`);
+    lines.push("");
+    lines.push("Evidence Digest");
+    lines.push(`  adopted=${report.operatorDigest.evidenceDigest.adopted}; missing=${report.operatorDigest.evidenceDigest.missing}; rejected=${report.operatorDigest.evidenceDigest.rejected}`);
+    lines.push("");
+    lines.push("Trust / Policy Digest");
+    lines.push(`  events=${report.operatorDigest.trustDigest.events}; policyViolations=${report.operatorDigest.trustDigest.policyViolations}; judgeRationales=${report.operatorDigest.trustDigest.judgeRationales}`);
+    for (const violation of report.blackboardDigest.policyViolations.slice(0, 20))
+        lines.push(`  [policy] ${violation.label}; expand: ${violation.expansionCommand}`);
+    lines.push("");
+    lines.push("Hidden Source Records");
+    if (!report.hiddenSourceRecords.length)
+        lines.push("  none (all records shown)");
+    for (const hidden of report.hiddenSourceRecords)
+        lines.push(`  ${hidden.kind}: ${hidden.count} records hidden; expand: ${hidden.expansionCommand}`);
+    lines.push("");
+    lines.push("Expansion Commands");
+    for (const command of report.expansionCommands)
+        lines.push(`  ${command}`);
+    lines.push("");
+    lines.push("Next Action");
+    lines.push(`  ${report.nextAction}`);
+    return lines.join("\n");
+}
+function formatCompactGraph(graph) {
+    const lines = [];
+    lines.push(`Compact Graph (${graph.view}): ${graph.runId}`);
+    lines.push(`  full=${graph.fullNodeCount} nodes/${graph.fullEdgeCount} edges -> view=${graph.compactNodeCount} nodes/${graph.compactEdgeCount} edges`);
+    if (graph.collapsedNodeCount > 0) {
+        lines.push(`  Graph compacted: ${graph.collapsedNodeCount} nodes collapsed into ${graph.syntheticNodes.length} summary nodes`);
+    }
+    lines.push("");
+    lines.push("Critical Path");
+    if (!graph.criticalPath.length)
+        lines.push("  none");
+    for (const id of graph.criticalPath.slice(0, 40))
+        lines.push(`  -> ${id}`);
+    lines.push("");
+    lines.push("Summary Nodes");
+    if (!graph.syntheticNodes.length)
+        lines.push("  none");
+    for (const syn of graph.syntheticNodes) {
+        lines.push(`  [${syn.dominantStatus}] ${syn.id}: ${syn.collapsedNodeCount} nodes / ${syn.collapsedEdgeCount} edges${syn.blockedReason ? ` blocked=${syn.blockedReason}` : ""}`);
+        lines.push(`    expand: ${syn.expansionCommand}`);
+    }
+    lines.push("");
+    lines.push("Blockers");
+    if (!graph.blockedReasons.length)
+        lines.push("  none");
+    for (const reason of graph.blockedReasons.slice(0, 20))
+        lines.push(`  ${reason}`);
+    lines.push("");
+    lines.push("Nodes");
+    for (const node of graph.nodes.slice(0, 80)) {
+        lines.push(`  [${node.status}] ${node.kind} ${node.id}${node.synthetic ? ` (summary of ${node.synthetic.collapsedNodeCount})` : ""}`);
+    }
+    if (graph.nodes.length > 80)
+        lines.push(`  ... ${graph.nodes.length - 80} more`);
+    lines.push("");
+    lines.push("Next Action");
+    lines.push(`  ${graph.nextAction}`);
+    return lines.join("\n");
+}
+function formatBlackboardDigest(record) {
+    const lines = [];
+    lines.push(`Blackboard Digest: ${record.runId}${record.blackboardId ? ` (${record.blackboardId})` : ""}`);
+    lines.push(`  freshness=${record.status}; included=${record.includedCount}; omitted=${record.omittedCount}`);
+    const section = (title, entries) => {
+        lines.push("");
+        lines.push(title);
+        if (!entries.length) {
+            lines.push("  none");
+            return;
+        }
+        for (const entry of entries.slice(0, 25))
+            lines.push(`  [${entry.status}] ${entry.label}; expand: ${entry.expansionCommand}`);
+        if (entries.length > 25)
+            lines.push(`  ... ${entries.length - 25} more`);
+    };
+    section("Topic Rollups", record.topicRollups);
+    section("Thread Summaries", record.threadSummaries);
+    section("Unresolved Questions", record.unresolvedQuestions);
+    section("Conflicts", record.conflicts);
+    section("Decisions", record.decisions);
+    section("Artifacts", record.artifacts);
+    section("Adopted Evidence", record.adoptedEvidence);
+    section("Missing Evidence", record.missingEvidence);
+    section("Policy Violations", record.policyViolations);
+    section("Judge Rationale", record.judgeRationale);
+    section("Recent Changes", record.recentChanges);
+    section("High-Signal Records", record.highSignal);
+    lines.push("");
+    lines.push("Next Action");
+    lines.push(`  ${record.nextAction}`);
+    return lines.join("\n");
+}
+function stateExplosionReportLines(report) {
+    // Markdown lines for inclusion in the run report.md State Size section.
+    const size = report.stateSize;
+    const lines = [
+        `- Records: ${size.total}; graph nodes: ${size.graphNodes}; graph edges: ${size.graphEdges}; messages: ${size.messages}`,
+        `- Compaction: ${size.compactionRecommended ? "recommended" : "not needed"}`,
+        `- Summary freshness: ${report.freshness.status}`
+    ];
+    for (const reason of size.reasons)
+        lines.push(`  - ${reason}`);
+    if (report.compactGraph.collapsedNodeCount > 0) {
+        lines.push(`- Graph compacted: ${report.compactGraph.collapsedNodeCount} nodes collapsed into ${report.compactGraph.syntheticNodes.length} summary nodes`);
+        lines.push(`  - Use: \`node scripts/cw.js multi-agent graph ${report.runId} --view full --json\``);
+    }
+    if (report.hiddenSourceRecords.length) {
+        for (const hidden of report.hiddenSourceRecords) {
+            lines.push(`- Hidden ${hidden.kind}: ${hidden.count} records; expand: \`${hidden.expansionCommand}\``);
+        }
+    }
+    lines.push(`- Next: \`${report.nextAction}\``);
+    return lines;
+}
+function normalizeStateExplosionForEval(run) {
+    const report = buildStateExplosionReport(run);
+    const graph = report.compactGraph;
+    return {
+        summaryFreshness: [
+            stableLine({
+                compactionRecommended: report.stateSize.compactionRecommended,
+                total: report.stateSize.total,
+                deterministic: graph.deterministic
+            })
+        ],
+        compactGraphShape: [
+            stableLine({
+                view: graph.view,
+                fullNodeCount: graph.fullNodeCount,
+                fullEdgeCount: graph.fullEdgeCount,
+                compactNodeCount: graph.compactNodeCount,
+                compactEdgeCount: graph.compactEdgeCount,
+                collapsedNodeCount: graph.collapsedNodeCount,
+                syntheticNodes: graph.syntheticNodes.map((s) => ({
+                    kind: s.id.split(":summary:")[1] || s.kind,
+                    collapsedNodeCount: s.collapsedNodeCount,
+                    collapsedEdgeCount: s.collapsedEdgeCount,
+                    dominantStatus: s.dominantStatus
+                }))
+            })
+        ],
+        blackboardDigest: [
+            stableLine({
+                topics: report.blackboardDigest.topicRollups.length,
+                threads: report.blackboardDigest.threadSummaries.length,
+                unresolved: report.blackboardDigest.unresolvedQuestions.map((q) => q.id),
+                conflicts: report.blackboardDigest.conflicts.map((c) => c.id),
+                decisions: report.blackboardDigest.decisions.length,
+                artifacts: report.blackboardDigest.artifacts.length,
+                policyViolations: report.blackboardDigest.policyViolations.map((p) => p.id),
+                judgeRationale: report.blackboardDigest.judgeRationale.map((j) => j.id),
+                missingEvidence: report.blackboardDigest.missingEvidence.map((m) => m.label)
+            })
+        ],
+        criticalPath: graph.criticalPath.map((id) => stripRunId(run, id)).sort(),
+        evidenceDigest: [
+            stableLine({
+                adopted: report.operatorDigest.evidenceDigest.adopted,
+                missing: report.operatorDigest.evidenceDigest.missing,
+                rejected: report.operatorDigest.evidenceDigest.rejected
+            })
+        ],
+        expansionRefs: report.hiddenSourceRecords.map((h) => `${h.kind}=${h.count}`).sort()
+    };
+}
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function isProtectedStatus(status) {
+    return ["failed", "blocked", "rejected", "conflicting"].includes(status);
+}
+function dominantStatus(statuses) {
+    for (const priority of ["failed", "blocked", "rejected", "conflicting", "running", "pending"]) {
+        if (statuses.includes(priority))
+            return priority;
+    }
+    return statuses[0] || "completed";
+}
+function parentMap(edges) {
+    const parents = new Map();
+    for (const edge of edges) {
+        if (!parents.has(edge.to))
+            parents.set(edge.to, edge.from);
+    }
+    return parents;
+}
+function fingerprintRecords(records) {
+    return fingerprintStrings(records.map((r) => `${r.id}:${r.status || ""}`).sort());
+}
+function fingerprintStrings(values) {
+    const hash = node_crypto_1.default.createHash("sha256");
+    hash.update(JSON.stringify([...values].sort()));
+    return `sha256:${hash.digest("hex").slice(0, 32)}`;
+}
+function stableLine(value) {
+    return JSON.stringify(sortKeys(value));
+}
+function sortKeys(value) {
+    if (Array.isArray(value))
+        return value.map(sortKeys);
+    if (value && typeof value === "object") {
+        const record = value;
+        const result = {};
+        for (const key of Object.keys(record).sort())
+            result[key] = sortKeys(record[key]);
+        return result;
+    }
+    return value;
+}
+function stripRunId(run, id) {
+    return id.startsWith(`${run.id}:`) ? id.slice(run.id.length + 1) : id;
+}
+function unique(values) {
+    return Array.from(new Set(values.filter(Boolean))).sort();
+}
+function byId(a, b) {
+    return a.id.localeCompare(b.id);
+}
+function truncate(value) {
+    const single = value.replace(/\s+/g, " ").trim();
+    return single.length > 80 ? `${single.slice(0, 77)}...` : single;
+}
+function slug(value) {
+    return value.replace(/[^a-zA-Z0-9._:-]/g, "-");
+}