@shapeshift-labs/frontier-loom-ui 0.1.2 → 0.1.4

package/dist/server.js

@@ -1,10 +1,14 @@
-import { watch } from 'node:fs';
+import { existsSync, watch } from 'node:fs';
 import { spawn, spawnSync } from 'node:child_process';
 import fs from 'node:fs/promises';
 import http from 'node:http';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
+import { FRONTIER_RUN_VERSION } from '@shapeshift-labs/frontier-run';
+import { FRONTIER_SEMANTIC_LEASE_EVENT_KIND, FRONTIER_SEMANTIC_LEASE_RECORD_KIND, FRONTIER_SEMANTIC_LEASE_STATE_KIND } from '@shapeshift-labs/frontier-lease';
+import { FRONTIER_SWARM_GIT_APPLY_LEDGER_KIND, FRONTIER_SWARM_GIT_LINK_REPAIR_KIND, FRONTIER_SWARM_GIT_WORKSPACE_MANIFEST_KIND, FRONTIER_SWARM_GIT_WORKSPACE_PROOF_KIND } from '@shapeshift-labs/frontier-swarm-git';
 import { estimateCodexModelCost, readCodexDashboardSnapshot } from '@shapeshift-labs/frontier-swarm-codex';
+import { FRONTIER_TEST_GATE_EXECUTION_KIND } from '@shapeshift-labs/frontier-test';
 const packageDir = path.dirname(fileURLToPath(import.meta.url));
 const HEALTH_JSON_PARSE_MAX_BYTES = 16 * 1024 * 1024;
 const TASK_DETAIL_PATCH_MAX_BYTES = 512 * 1024;
@@ -22,11 +26,15 @@ const LIFETIME_DASHBOARD_MAX_AUTONOMOUS_DECISION_FILES = 400;
 const LIFETIME_DASHBOARD_MAX_DRAIN_RUNS = 6;
 const LIFETIME_DASHBOARD_MAX_ACTIVE_PID_RUNS = 32;
 const LIFETIME_DASHBOARD_MAX_QUEUE_TASKS = 500;
-const LIFETIME_DASHBOARD_SOURCE_TIMEOUT_MS = 2500;
+const LIFETIME_DASHBOARD_SOURCE_TIMEOUT_MS = 8000;
+const LIFETIME_DASHBOARD_MAX_SUBSTRATE_FILES = 800;
+const LIFETIME_DASHBOARD_SUBSTRATE_MAX_BYTES = 4 * 1024 * 1024;
 const LIFETIME_DASHBOARD_RESET_FILE = '.loom-ui-reset.json';
 const REVIEW_DECISIONS_FILE = '.loom-ui-review-decisions.json';
-const dashboardStreamListeners = new Set();
+const LIVE_RUN_GRAPH_EVENTS_FILE = 'live-run-graph-events.jsonl';
 let dashboardSnapshotCache;
+let dashboardSnapshotCacheGeneration = 0;
+const dashboardStreamListeners = new Set();
 export function createLoomUiServer(options = {}) {
     const normalized = normalizeServerOptions(options);
     const server = http.createServer(async (request, response) => {
@@ -96,6 +104,9 @@ async function handleRequest(request, response, options) {
     else if (request.method === 'GET' && url.pathname === '/vendor/frontier-dom/jsx-runtime.js') {
         await serveFile(response, resolveFrontierDomRuntime(), 'application/javascript; charset=utf-8');
     }
+    else if (request.method === 'GET' && url.pathname === '/favicon.ico') {
+        serveFavicon(response);
+    }
     else if (request.method === 'GET') {
         const file = staticFile(options.staticDir, url.pathname);
         await serveFile(response, file, contentType(file));
@@ -115,29 +126,48 @@ async function streamDashboard(request, response, options) {
     response.write(': connected\n\n');
     let closed = false;
     let pending = false;
+    let queued = false;
     let lastSignature = '';
+    let lastSnapshot;
+    const writeSnapshot = (snapshot) => {
+        const signature = dashboardStreamSignature(snapshot);
+        const body = JSON.stringify(snapshot);
+        if (signature !== lastSignature) {
+            lastSignature = signature;
+            lastSnapshot = snapshot;
+            response.write(`data: ${body}\n\n`);
+        }
+    };
     const send = async () => {
-        if (closed || pending)
+        if (closed)
             return;
+        if (pending) {
+            queued = true;
+            return;
+        }
         pending = true;
+        queued = false;
         try {
             const snapshot = await readDashboardSnapshotCached(options);
-            const signature = dashboardStreamSignature(snapshot);
-            const body = JSON.stringify(snapshot);
-            if (signature !== lastSignature) {
-                lastSignature = signature;
-                response.write(`data: ${body}\n\n`);
-            }
+            writeSnapshot(snapshot);
         }
         catch (error) {
             response.write(`event: error\ndata: ${JSON.stringify({ ok: false, error: errorMessage(error) })}\n\n`);
         }
         finally {
             pending = false;
+            if (queued && !closed) {
+                queued = false;
+                setTimeout(() => {
+                    void send();
+                }, 0);
+            }
         }
     };
     const trigger = debounce(send, 120);
-    const directTrigger = () => {
+    const directTrigger = (hint) => {
+        if (hint && lastSnapshot)
+            writeSnapshot(applyDashboardStreamHint(lastSnapshot, hint));
         void send();
     };
     const watchers = await createDashboardWatchers(options, trigger);
@@ -168,6 +198,27 @@ function dashboardStreamSignature(snapshot) {
     const { generatedAt: _generatedAt, ...stableSnapshot } = snapshot;
     return JSON.stringify(stableSnapshot);
 }
+function applyDashboardStreamHint(snapshot, hint) {
+    if (!hint.humanActionAnswer || !snapshot || typeof snapshot !== 'object' || Array.isArray(snapshot))
+        return snapshot;
+    const record = snapshot;
+    const existing = recordArray(record.humanActionAnswers);
+    const alreadyPresent = existing.some((row) => {
+        return textValue(row.code, '') === hint.humanActionAnswer?.code
+            && textValue(row.answer, '') === hint.humanActionAnswer?.answer
+            && numberValue(row.at) === hint.humanActionAnswer?.at;
+    });
+    const humanActionAnswers = alreadyPresent ? existing : [...existing, hint.humanActionAnswer];
+    return {
+        ...record,
+        generatedAt: Date.now(),
+        humanActionAnswers,
+        sources: {
+            ...recordValue(record.sources),
+            ...(hint.answerPath ? { humanActionAnswers: hint.answerPath } : {})
+        }
+    };
+}
 function debounce(fn, delayMs) {
     let timer;
     return () => {
@@ -216,23 +267,16 @@ function watchDirectory(root, recursive, onChange) {
     }
 }
 async function dashboardWatchRoots(options) {
-    const inputs = [options.run, options.collection, options.continuation].filter((value) => Boolean(value));
     const roots = [];
-    for (const input of inputs) {
-        const absolute = path.resolve(options.cwd, input);
-        const stat = await fs.lstat(absolute).catch(() => undefined);
-        if (!stat)
-            continue;
-        roots.push(stat.isDirectory() ? absolute : path.dirname(absolute));
-    }
-    if (!inputs.length) {
-        const agentRuns = path.join(options.cwd, 'agent-runs');
-        if (await fileExists(agentRuns))
-            roots.push(agentRuns);
-        const loomQueues = path.join(options.cwd, '.loom', 'queues');
-        if (await fileExists(loomQueues))
-            roots.push(loomQueues);
-    }
+    const agentRuns = path.join(options.cwd, 'agent-runs');
+    if (await fileExists(agentRuns))
+        roots.push(agentRuns);
+    const loomRoot = path.join(options.cwd, '.loom');
+    if (await fileExists(loomRoot))
+        roots.push(loomRoot);
+    const loomQueues = path.join(options.cwd, '.loom', 'queues');
+    if (await fileExists(loomQueues))
+        roots.push(loomQueues);
     return uniquePaths(roots);
 }
 function uniquePaths(values) {
@@ -240,7 +284,6 @@ function uniquePaths(values) {
 }
 function normalizeServerOptions(options) {
     return {
-        ...options,
         cwd: path.resolve(options.cwd ?? process.cwd()),
         host: options.host ?? '127.0.0.1',
         port: normalizePort(options.port),
@@ -266,13 +309,12 @@ function dashboardInput(options) {
     };
 }
 async function readDashboardSnapshot(options) {
-    if (!options.run && !options.collection && !options.continuation)
-        return readLifetimeDashboardSnapshot(options);
-    return readScopedDashboardSnapshot(options);
+    return readLifetimeDashboardSnapshot(options);
 }
 async function readDashboardSnapshotCached(options) {
     const key = JSON.stringify(dashboardInput(options));
     const now = Date.now();
+    const previousValue = dashboardSnapshotCache?.key === key ? dashboardSnapshotCache.value : undefined;
     if (dashboardSnapshotCache?.key === key) {
         if (dashboardSnapshotCache.value !== undefined && now - dashboardSnapshotCache.at < DASHBOARD_SNAPSHOT_CACHE_MS) {
             return dashboardSnapshotCache.value;
@@ -280,21 +322,52 @@ async function readDashboardSnapshotCached(options) {
         if (dashboardSnapshotCache.pending)
             return dashboardSnapshotCache.pending;
     }
+    const generation = dashboardSnapshotCacheGeneration;
     const pending = readDashboardSnapshot(options).then((value) => {
-        dashboardSnapshotCache = { key, at: Date.now(), value };
-        return value;
+        const stableValue = stableDashboardSnapshotValue(previousValue, value);
+        if (generation === dashboardSnapshotCacheGeneration) {
+            dashboardSnapshotCache = { key, at: Date.now(), value: stableValue };
+        }
+        return stableValue;
     }, (error) => {
-        if (dashboardSnapshotCache?.key === key) {
+        if (generation === dashboardSnapshotCacheGeneration && dashboardSnapshotCache?.key === key) {
             dashboardSnapshotCache = dashboardSnapshotCache.value === undefined
                 ? undefined
                 : { key, at: dashboardSnapshotCache.at, value: dashboardSnapshotCache.value };
         }
         throw error;
     });
-    dashboardSnapshotCache = { key, at: now, value: dashboardSnapshotCache?.key === key ? dashboardSnapshotCache.value : undefined, pending };
+    dashboardSnapshotCache = { key, at: now, value: previousValue, pending };
     return pending;
 }
+function stableDashboardSnapshotValue(previous, next) {
+    if (!shouldKeepPreviousDashboardSnapshot(previous, next))
+        return next;
+    return previous;
+}
+function shouldKeepPreviousDashboardSnapshot(previous, next) {
+    const previousRecord = recordValue(previous);
+    const nextRecord = recordValue(next);
+    if (!Object.keys(previousRecord).length || !Object.keys(nextRecord).length)
+        return false;
+    const nextSources = recordValue(nextRecord.sources);
+    const timedOutSources = numberValue(nextSources.timedOutSourceCount);
+    if (!timedOutSources)
+        return false;
+    const previousJobCount = dashboardSnapshotJobCount(previousRecord);
+    const nextJobCount = dashboardSnapshotJobCount(nextRecord);
+    if (!previousJobCount || previousJobCount <= nextJobCount)
+        return false;
+    const previousSources = recordValue(previousRecord.sources);
+    const previousLoaded = numberValue(previousSources.loadedSourceCount);
+    const nextLoaded = numberValue(nextSources.loadedSourceCount);
+    return nextJobCount === 0 || !nextLoaded || nextLoaded < previousLoaded;
+}
+function dashboardSnapshotJobCount(snapshot) {
+    return recordArray(snapshot.jobs).length || numberValue(recordValue(snapshot.summary).jobCount);
+}
 function invalidateDashboardSnapshotCache() {
+    dashboardSnapshotCacheGeneration += 1;
     dashboardSnapshotCache = undefined;
 }
 async function readScopedDashboardSnapshot(options, readOptions = {}) {
@@ -307,16 +380,25 @@ async function readScopedDashboardSnapshot(options, readOptions = {}) {
         return activeRunSnapshot ?? snapshot;
     const answers = await readHumanActionAnswers(options);
     const record = snapshot;
+    const collectionGraph = await readDashboardRunGraphSummary(options, record);
     const jobs = Array.isArray(record.jobs) ? record.jobs : [];
     const activeJobs = recordArray(activeRunSnapshot?.jobs);
     if (shouldPreferActiveRunSnapshot(jobs, activeJobs)) {
         const activeAgentRows = activeAgentsFromJobs(activeJobs);
+        const activeGraph = recordValue(activeRunSnapshot?.graph);
+        const graph = Object.keys(activeGraph).length ? activeGraph : collectionGraph;
         return {
             ...activeRunSnapshot,
             collectionJobs: jobs,
             activeAgents: activeAgentRows,
+            health: lifetimeHealthSummary(activeJobs),
             humanActions: recordArray(record.humanActions),
             humanActionAnswers: answers,
+            ...(graph ? { graph } : {}),
+            summary: {
+                ...recordValue(activeRunSnapshot?.summary),
+                ...(graph ? { graph } : {})
+            },
             sources: {
                 ...recordValue(record.sources),
                 ...recordValue(activeRunSnapshot?.sources),
@@ -334,9 +416,26 @@ async function readScopedDashboardSnapshot(options, readOptions = {}) {
             }
         };
     }
+    const normalizedSnapshot = normalizeCoordinatorFacingSnapshot(record);
     const mergedJobs = applyCoordinatorReviewDecisions(mergeActiveRunJobTelemetry(jobs, activeJobs), decisions).map(withRecomputedCostFields);
+    const normalizedSummary = recordValue(normalizedSnapshot.summary);
+    const adjustedSummary = reviewDecisionAdjustedSummary(normalizedSummary, mergedJobs);
+    const rawCollectionSummary = recordValue(recordValue(recordValue(record.raw).collection).summary);
+    const semanticSummary = {
+        ...rawCollectionSummary,
+        ...adjustedSummary,
+        bucketCounts: recordValue(normalizedSummary.bucketCounts)
+    };
+    const graph = withDashboardRunGraphJobHealth(collectionGraph, mergedJobs);
     return {
-        ...normalizeCoordinatorFacingSnapshot(record),
+        ...normalizedSnapshot,
+        ...(graph ? { graph } : {}),
+        summary: {
+            ...adjustedSummary,
+            ...(graph ? { graph } : {})
+        },
+        health: lifetimeHealthSummary(mergedJobs),
+        semantic: semanticWithHealth(recordValue(normalizedSnapshot.semantic), semanticSummary, mergedJobs),
         jobs: mergedJobs,
         activeAgents: activeAgentsFromJobs(mergedJobs),
         humanActionAnswers: answers,
@@ -348,31 +447,316 @@ async function readScopedDashboardSnapshot(options, readOptions = {}) {
         }
     };
 }
+async function readDashboardRunGraphSummary(options, snapshot) {
+    const embedded = recordValue(recordValue(recordValue(snapshot.raw).collection).runGraph);
+    if (Object.keys(embedded).length) {
+        return summarizeDashboardRunGraph(embedded, {
+            sourceFile: textValue(embedded.id, 'embedded'),
+            sourceKind: 'embedded-run-graph',
+            sourceStatus: 'collected'
+        });
+    }
+    const source = await resolveDashboardRunGraphSource(options, snapshot);
+    if (source?.file) {
+        return summarizeDashboardRunGraph(recordValue(await readJsonFile(source.file)), {
+            sourceFile: path.relative(options.cwd, source.file).replaceAll(path.sep, '/'),
+            sourceKind: 'collected-run-graph',
+            sourceStatus: 'collected'
+        });
+    }
+    if (source?.expectedFile) {
+        return missingDashboardRunGraphSummary(options.cwd, {
+            expectedFile: source.expectedFile,
+            sourceKind: 'collected-run-graph',
+            warning: 'Collected dashboard source has no run-graph.json.'
+        });
+    }
+    return undefined;
+}
+async function resolveDashboardRunGraphSource(options, snapshot) {
+    const sources = recordValue(snapshot.sources);
+    const candidates = uniquePaths([
+        textValue(options.collection, ''),
+        textValue(sources.collectionDir, ''),
+        path.dirname(textValue(sources.collectionFile, ''))
+    ].filter(Boolean));
+    let expectedFile;
+    for (const candidate of candidates) {
+        const absolute = path.resolve(options.cwd, candidate);
+        if (!isPathInside(options.cwd, absolute))
+            continue;
+        const stat = await fs.lstat(absolute).catch(() => undefined);
+        if (!stat)
+            continue;
+        const file = stat.isDirectory()
+            ? path.join(absolute, 'run-graph.json')
+            : path.basename(absolute) === 'run-graph.json'
+                ? absolute
+                : path.join(path.dirname(absolute), 'run-graph.json');
+        expectedFile ??= file;
+        const fileStat = await fs.stat(file).catch(() => undefined);
+        if (fileStat?.isFile() && isPathInside(options.cwd, file))
+            return { file, expectedFile: file };
+    }
+    return expectedFile ? { expectedFile } : undefined;
+}
+function missingDashboardRunGraphSummary(cwd, input) {
+    const sourceFile = path.relative(cwd, input.expectedFile).replaceAll(path.sep, '/');
+    const warning = `${input.warning} Expected ${sourceFile}.`;
+    return {
+        sourceFile,
+        sourceFiles: [sourceFile],
+        sourceKind: input.sourceKind,
+        sourceKinds: [input.sourceKind],
+        sourceStatus: 'missing',
+        sourceStatuses: ['missing'],
+        graphMissing: true,
+        graphMissingWarningCount: 1,
+        graphMissingWarnings: [warning],
+        nodeCount: 0,
+        edgeCount: 0,
+        blockerCount: 0,
+        openBlockerCount: 0,
+        humanQuestionCount: 0,
+        openHumanQuestionCount: 0,
+        safeMergeCandidateCount: 0,
+        decisionCount: 0,
+        terminalDecisionCount: 0,
+        terminalAcceptedCount: 0,
+        terminalRejectedCount: 0,
+        terminalRerunCount: 0,
+        gateCount: 0,
+        gatePassedCount: 0,
+        gateFailedCount: 0,
+        staleCount: 0,
+        openStaleCount: 0,
+        rerunCount: 0,
+        openRerunCount: 0,
+        staleRerunCleanupCount: 0,
+        status: 'missing',
+        summaryLine: warning,
+        recentEvents: []
+    };
+}
+function summarizeDashboardRunGraph(graph, input) {
+    const summary = recordValue(graph.summary);
+    const nodes = recordArray(graph.nodes);
+    const edges = recordArray(graph.edges);
+    const nodeCount = numberValue(summary.nodeCount) || nodes.length;
+    const edgeCount = numberValue(summary.edgeCount) || edges.length;
+    if (!nodeCount && !edgeCount && !input.graphMissing)
+        return undefined;
+    const gateNodes = nodes.filter((node) => normalized(node.kind) === 'gate');
+    const decisionNodes = nodes.filter((node) => normalized(node.kind) === 'decision');
+    const terminalDecisionNodes = decisionNodes.filter(runGraphNodeIsTerminalDecision);
+    const recentEvents = nodes
+        .filter((node) => numberValue(node.generatedAt))
+        .sort((left, right) => numberValue(left.generatedAt) - numberValue(right.generatedAt))
+        .slice(-8)
+        .map((node) => ({
+        type: textValue(node.kind, 'graph'),
+        at: numberValue(node.generatedAt),
+        jobId: textValue(node.jobId, ''),
+        taskId: textValue(node.taskId, ''),
+        status: textValue(node.status ?? node.outcome, ''),
+        message: textValue(node.label ?? node.id, 'graph node')
+    }));
+    const blockerCount = nodes.filter(runGraphNodeIsBlocker).length;
+    const humanQuestionCount = nodes.filter(runGraphNodeIsHumanQuestion).length;
+    const safeMergeCandidateCount = nodes.filter(runGraphNodeIsSafeMergeCandidate).length;
+    const terminalAcceptedCount = terminalDecisionNodes.filter(runGraphNodeIsAcceptedTerminalDecision).length;
+    const terminalRejectedCount = terminalDecisionNodes.filter(runGraphNodeIsRejectedTerminalDecision).length;
+    const terminalRerunCount = terminalDecisionNodes.filter(runGraphNodeIsRerunTerminalDecision).length;
+    const gateFailedCount = gateNodes.filter((node) => normalized(node.status) === 'failed').length;
+    const staleCount = firstNumber(summary.staleCount, summary.staleAgainstHeadCount, summary['stale-against-head']) || nodes.filter(runGraphNodeIsStale).length;
+    const rerunCount = firstNumber(summary.rerunCount, summary['rerun-work']) || nodes.filter(runGraphNodeIsRerun).length;
+    const staleRerunCleanupCount = nodes.filter(runGraphNodeIsStaleRerunCleanup).length;
+    const graphMissingWarnings = uniquePaths(input.graphMissingWarnings ?? []);
+    const status = blockerCount
+        ? 'blocked'
+        : humanQuestionCount
+            ? 'questions'
+            : gateFailedCount
+                ? 'review'
+                : terminalRerunCount
+                    ? 'rerun'
+                    : input.graphMissing && !safeMergeCandidateCount
+                        ? 'missing'
+                        : safeMergeCandidateCount || terminalAcceptedCount
+                            ? 'ready'
+                            : 'clear';
+    return {
+        sourceFile: input.sourceFile,
+        sourceFiles: input.sourceFile ? [input.sourceFile] : [],
+        sourceKind: input.sourceKind,
+        sourceKinds: [input.sourceKind],
+        sourceStatus: input.sourceStatus,
+        sourceStatuses: [input.sourceStatus],
+        graphMissing: input.graphMissing === true,
+        graphMissingWarningCount: graphMissingWarnings.length,
+        graphMissingWarnings,
+        ...(input.liveEventCount !== undefined ? { liveEventCount: input.liveEventCount } : {}),
+        nodeCount,
+        edgeCount,
+        blockerCount,
+        openBlockerCount: blockerCount,
+        humanQuestionCount,
+        openHumanQuestionCount: humanQuestionCount,
+        safeMergeCandidateCount,
+        decisionCount: numberValue(summary.decisionCount) || decisionNodes.length,
+        terminalDecisionCount: terminalDecisionNodes.length,
+        terminalAcceptedCount,
+        terminalRejectedCount,
+        terminalRerunCount,
+        gateCount: numberValue(summary.gateCount) || gateNodes.length,
+        gatePassedCount: gateNodes.filter((node) => normalized(node.status) === 'passed').length,
+        gateFailedCount,
+        staleCount,
+        openStaleCount: staleCount,
+        rerunCount,
+        openRerunCount: rerunCount,
+        staleRerunCleanupCount,
+        status,
+        summaryLine: `${nodeCount} nodes, ${edgeCount} edges, ${numberValue(summary.decisionCount) || decisionNodes.length} decisions, and ${numberValue(summary.gateCount) || gateNodes.length} gates.`,
+        recentEvents
+    };
+}
+function runGraphNodeIsBlocker(node) {
+    const status = normalized(node.status);
+    const outcome = normalized(node.outcome);
+    return status === 'blocked' || outcome === 'blocked' || outcome === 'conflict' || outcome === 'human-needed';
+}
+function runGraphNodeIsHumanQuestion(node) {
+    const status = normalized(node.status);
+    const outcome = normalized(node.outcome);
+    return status.includes('human') || outcome.includes('human') || status.includes('question') || outcome.includes('question');
+}
+function runGraphNodeIsSafeMergeCandidate(node) {
+    if (normalized(node.kind) !== 'candidate')
+        return false;
+    const bucket = normalized(node.bucket);
+    const data = recordValue(node.data);
+    return bucket === 'ready-to-apply' || data.autoMergeable === true || normalized(data.mergeReadiness) === 'ready-to-apply';
+}
+function runGraphNodeIsTerminalDecision(node) {
+    const kind = normalized(node.kind);
+    if (kind === 'terminal-outcome')
+        return true;
+    if (kind !== 'decision')
+        return false;
+    return textValue(node.id, '').startsWith('decision:terminal:')
+        || normalized(recordValue(node.data).terminal) === 'true'
+        || runGraphTerminalOutcome(node) !== '';
+}
+function runGraphNodeIsAcceptedTerminalDecision(node) {
+    return ['accepted', 'accepted-applied', 'applied', 'committed', 'completed', 'ok', 'ready', 'ready-to-apply', 'verified-patch'].includes(runGraphTerminalOutcome(node));
+}
+function runGraphNodeIsRejectedTerminalDecision(node) {
+    return ['blocked', 'conflict', 'conflict-blocked', 'failed', 'rejected'].includes(runGraphTerminalOutcome(node));
+}
+function runGraphNodeIsRerunTerminalDecision(node) {
+    return ['needs-rerun', 'rerun', 'rerun-work', 'stale', 'stale-against-head'].includes(runGraphTerminalOutcome(node));
+}
+function runGraphTerminalOutcome(node) {
+    const data = recordValue(node.data);
+    const values = [
+        node.outcome,
+        node.status,
+        data.outcome,
+        data.status,
+        data.mergeReadiness,
+        data.disposition
+    ].map(normalized).filter(Boolean);
+    return values.find((value) => [
+        'accepted',
+        'accepted-applied',
+        'applied',
+        'blocked',
+        'committed',
+        'completed',
+        'conflict',
+        'conflict-blocked',
+        'failed',
+        'needs-rerun',
+        'ok',
+        'ready',
+        'ready-to-apply',
+        'rejected',
+        'rerun',
+        'rerun-work',
+        'stale',
+        'stale-against-head',
+        'verified-patch'
+    ].includes(value)) ?? '';
+}
+function runGraphNodeIsStale(node) {
+    if (normalized(node.kind) === 'bucket')
+        return false;
+    const data = recordValue(node.data);
+    const values = [
+        node.bucket,
+        node.status,
+        node.outcome,
+        data.disposition,
+        data.mergeReadiness,
+        ...(stringArray(data.reasons))
+    ].map(normalized);
+    return data.staleAgainstHead === true || values.some((value) => value.includes('stale'));
+}
+function runGraphNodeIsRerun(node) {
+    if (normalized(node.kind) === 'bucket')
+        return false;
+    const data = recordValue(node.data);
+    const values = [
+        node.bucket,
+        node.status,
+        node.outcome,
+        data.disposition,
+        data.mergeReadiness,
+        ...(stringArray(data.reasons))
+    ].map(normalized);
+    return values.some((value) => value.includes('rerun'));
+}
+function runGraphNodeIsStaleRerunCleanup(node) {
+    if (!runGraphNodeIsTerminalDecision(node))
+        return false;
+    if (!runGraphNodeIsStale(node) && !runGraphNodeIsRerun(node))
+        return false;
+    return runGraphNodeIsAcceptedTerminalDecision(node) || runGraphNodeIsRejectedTerminalDecision(node) || runGraphNodeIsRerunTerminalDecision(node);
+}
 async function readLifetimeDashboardSnapshot(options) {
     const sources = await discoverLifetimeDashboardSources(options.cwd);
     const snapshots = [];
     let skippedSourceCount = 0;
     let timedOutSourceCount = 0;
-    for (const source of sources.slice(0, LIFETIME_DASHBOARD_MAX_SOURCES)) {
+    const sourceResults = await Promise.all(sources.slice(0, LIFETIME_DASHBOARD_MAX_SOURCES).map(async (source) => {
         try {
-            const snapshot = await withTimeout((async () => {
-                const scopedSnapshot = await readScopedDashboardSnapshot({
-                    ...options,
-                    run: source.run,
-                    collection: source.collection,
-                    continuation: source.continuation
-                }, { includeActiveRun: false });
-                return enrichLifetimeRunSnapshotEvidence(options.cwd, source, recordValue(scopedSnapshot));
-            })(), LIFETIME_DASHBOARD_SOURCE_TIMEOUT_MS, `lifetime source timed out: ${source.path}`);
-            if (Object.keys(snapshot).length)
-                snapshots.push({ source, snapshot });
+            return {
+                source,
+                snapshot: await withTimeout((async () => {
+                    const scopedSnapshot = await readScopedDashboardSnapshot({
+                        ...options,
+                        run: source.run,
+                        collection: source.collection,
+                        continuation: source.continuation
+                    }, { includeActiveRun: false });
+                    return enrichLifetimeRunSnapshotEvidence(options.cwd, source, recordValue(scopedSnapshot));
+                })(), LIFETIME_DASHBOARD_SOURCE_TIMEOUT_MS, `lifetime source timed out: ${source.path}`)
+            };
         }
         catch (error) {
+            return { source, error };
+        }
+    }));
+    for (const result of sourceResults) {
+        if ('error' in result) {
             skippedSourceCount++;
-            if (error instanceof Error && error.message.startsWith('lifetime source timed out:'))
+            if (result.error instanceof Error && result.error.message.startsWith('lifetime source timed out:'))
                 timedOutSourceCount++;
             continue;
         }
+        if (Object.keys(result.snapshot).length)
+            snapshots.push({ source: result.source, snapshot: result.snapshot });
     }
     const lifetime = await combineLifetimeDashboardSnapshots(options, sources, snapshots, mergeReviewDecisionLists(await readCoordinatorReviewDecisions(options.cwd), await readAutonomousMergeDecisions(options.cwd)), await readLifetimeQueueBacklog(options.cwd));
     const lifetimeWithSourceHealth = {
@@ -819,6 +1203,339 @@ async function findLifetimeDashboardArtifactFiles(root, input) {
     await walk(root, 0);
     return out;
 }
+async function readDashboardSubstrateSummary(cwd) {
+    const roots = uniquePaths([
+        path.join(cwd, 'agent-runs'),
+        path.join(cwd, '.loom')
+    ]);
+    const files = [];
+    for (const root of roots) {
+        const stat = await fs.stat(root).catch(() => undefined);
+        if (!stat?.isDirectory())
+            continue;
+        files.push(...await findDashboardSubstrateFiles(root, {
+            maxDepth: LIFETIME_DASHBOARD_SCAN_MAX_DEPTH + 1,
+            maxFiles: Math.max(1, LIFETIME_DASHBOARD_MAX_SUBSTRATE_FILES - files.length)
+        }));
+        if (files.length >= LIFETIME_DASHBOARD_MAX_SUBSTRATE_FILES)
+            break;
+    }
+    const records = [];
+    for (const file of uniquePaths(files)) {
+        for (const record of await readDashboardSubstrateRecords(file)) {
+            records.push({ file, record });
+        }
+    }
+    return summarizeDashboardSubstrateRecords(cwd, records);
+}
+async function findDashboardSubstrateFiles(root, input) {
+    const out = [];
+    const skipDirs = new Set(['.git', 'node_modules', 'dist', 'coverage', '.cache', 'patch-scores', 'artifact-index']);
+    async function walk(current, depth) {
+        if (out.length >= input.maxFiles || depth > input.maxDepth)
+            return;
+        const entries = await fs.readdir(current, { withFileTypes: true }).catch(() => []);
+        for (const entry of entries) {
+            if (out.length >= input.maxFiles)
+                return;
+            const absolute = path.join(current, entry.name);
+            if (entry.isDirectory()) {
+                if (skipDirs.has(entry.name))
+                    continue;
+                await walk(absolute, depth + 1);
+            }
+            else if (entry.isFile() && dashboardSubstrateFileNameMatches(entry.name)) {
+                out.push(absolute);
+            }
+        }
+    }
+    await walk(root, 0);
+    return out;
+}
+function dashboardSubstrateFileNameMatches(name) {
+    return name === 'run-events.jsonl'
+        || name === LIVE_RUN_GRAPH_EVENTS_FILE
+        || name === 'apply-ledger.json'
+        || name === 'workspace-proof.json'
+        || name === 'workspace-manifest.json'
+        || name === 'link-repair.json'
+        || /(?:semantic-)?lease(?:s|-state|-events|-records)?\.(?:json|jsonl)$/u.test(name)
+        || /gate-executions?\.(?:json|jsonl)$/u.test(name);
+}
+async function readDashboardSubstrateRecords(file) {
+    const stat = await fs.stat(file).catch(() => undefined);
+    if (!stat?.isFile() || stat.size > LIFETIME_DASHBOARD_SUBSTRATE_MAX_BYTES)
+        return [];
+    const text = await fs.readFile(file, 'utf8').catch(() => '');
+    if (!text.trim())
+        return [];
+    if (file.endsWith('.jsonl')) {
+        return text.split(/\r?\n/u)
+            .map((line) => line.trim())
+            .filter(Boolean)
+            .map(parseJsonRecord)
+            .filter((record) => Boolean(record && dashboardSubstrateRecordKind(record)));
+    }
+    const parsed = parseJsonValue(text);
+    return flattenDashboardSubstrateRecords(parsed).filter((record) => Boolean(dashboardSubstrateRecordKind(record)));
+}
+function parseJsonRecord(text) {
+    return recordValue(parseJsonValue(text));
+}
+function parseJsonValue(text) {
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return undefined;
+    }
+}
+function flattenDashboardSubstrateRecords(value) {
+    const record = recordValue(value);
+    if (!Object.keys(record).length) {
+        return Array.isArray(value) ? value.flatMap(flattenDashboardSubstrateRecords) : [];
+    }
+    if (dashboardSubstrateRecordKind(record))
+        return [record];
+    const out = [];
+    for (const key of ['events', 'leases', 'records', 'executions', 'entries']) {
+        out.push(...recordArray(record[key]).flatMap(flattenDashboardSubstrateRecords));
+    }
+    return out;
+}
+function dashboardSubstrateRecordKind(record) {
+    const kind = textValue(record.kind, '');
+    if (kind === 'frontier.run.event' && numberValue(record.version) === FRONTIER_RUN_VERSION)
+        return kind;
+    if (kind === 'frontier.run.dashboard' && numberValue(record.version) === FRONTIER_RUN_VERSION)
+        return kind;
+    if (kind === FRONTIER_SEMANTIC_LEASE_STATE_KIND)
+        return kind;
+    if (kind === FRONTIER_SEMANTIC_LEASE_RECORD_KIND)
+        return kind;
+    if (kind === FRONTIER_SEMANTIC_LEASE_EVENT_KIND)
+        return kind;
+    if (kind === FRONTIER_TEST_GATE_EXECUTION_KIND)
+        return kind;
+    if (kind === FRONTIER_SWARM_GIT_WORKSPACE_MANIFEST_KIND)
+        return kind;
+    if (kind === FRONTIER_SWARM_GIT_WORKSPACE_PROOF_KIND)
+        return kind;
+    if (kind === FRONTIER_SWARM_GIT_APPLY_LEDGER_KIND)
+        return kind;
+    if (kind === FRONTIER_SWARM_GIT_LINK_REPAIR_KIND)
+        return kind;
+    return '';
+}
+function summarizeDashboardSubstrateRecords(cwd, records) {
+    const runIds = new Set();
+    const eventTypeCounts = {};
+    const gateKindCounts = {};
+    const sourceFiles = uniquePaths(records.map(({ file }) => path.relative(cwd, file).replaceAll(path.sep, '/')));
+    const summary = {
+        kind: 'frontier.loom-ui.dashboard-substrate',
+        version: 1,
+        generatedAt: Date.now(),
+        sourceFiles,
+        sourceCount: sourceFiles.length,
+        run: { eventCount: 0, dashboardCount: 0, runIds: [], eventTypeCounts },
+        leases: { stateCount: 0, recordCount: 0, eventCount: 0, activeCount: 0, grantedCount: 0, deniedCount: 0, releasedCount: 0, expiredCount: 0, scopeCount: 0 },
+        gates: { executionCount: 0, passedCount: 0, failedCount: 0, warningCount: 0, requiredFailedCount: 0, durationMs: 0, kindCounts: gateKindCounts },
+        git: { workspaceManifestCount: 0, workspaceProofCount: 0, applyLedgerCount: 0, linkRepairCount: 0, appliedCount: 0, committedCount: 0, failedCount: 0, skippedCount: 0, changedPathCount: 0 }
+    };
+    for (const { record } of records) {
+        switch (dashboardSubstrateRecordKind(record)) {
+            case 'frontier.run.event':
+                summary.run.eventCount += 1;
+                if (textValue(record.runId, ''))
+                    runIds.add(textValue(record.runId, ''));
+                incrementRecordCount(eventTypeCounts, textValue(record.type, 'unknown'));
+                break;
+            case 'frontier.run.dashboard':
+                summary.run.dashboardCount += 1;
+                if (textValue(record.runId, ''))
+                    runIds.add(textValue(record.runId, ''));
+                break;
+            case FRONTIER_SEMANTIC_LEASE_STATE_KIND:
+                summary.leases.stateCount += 1;
+                summarizeLeaseRecords(summary, recordArray(record.leases));
+                for (const event of recordArray(record.events)) {
+                    summary.leases.eventCount += 1;
+                    summarizeLeaseEvent(summary, event);
+                }
+                break;
+            case FRONTIER_SEMANTIC_LEASE_RECORD_KIND:
+                summarizeLeaseRecords(summary, [record]);
+                break;
+            case FRONTIER_SEMANTIC_LEASE_EVENT_KIND:
+                summary.leases.eventCount += 1;
+                summarizeLeaseEvent(summary, record);
+                break;
+            case FRONTIER_TEST_GATE_EXECUTION_KIND:
+                summarizeGateExecution(summary, record);
+                break;
+            case FRONTIER_SWARM_GIT_WORKSPACE_MANIFEST_KIND:
+                summary.git.workspaceManifestCount += 1;
+                break;
+            case FRONTIER_SWARM_GIT_WORKSPACE_PROOF_KIND:
+                summary.git.workspaceProofCount += 1;
+                summary.git.changedPathCount += stringArray(record.reportedChangedPaths).length;
+                break;
+            case FRONTIER_SWARM_GIT_APPLY_LEDGER_KIND:
+                summarizeGitApplyLedger(summary, record);
+                break;
+            case FRONTIER_SWARM_GIT_LINK_REPAIR_KIND:
+                summary.git.linkRepairCount += 1;
+                break;
+        }
+    }
+    summary.run.runIds = Array.from(runIds).sort();
+    summary.graph = substrateDashboardGraphSummary(summary);
+    return summary;
+}
+function summarizeLeaseRecords(summary, leases) {
+    for (const lease of leases) {
+        summary.leases.recordCount += 1;
+        summary.leases.scopeCount += Math.max(stringArray(lease.scopeKeys).length, recordArray(lease.scopes).length);
+        const status = normalized(lease.status);
+        if (status === 'granted') {
+            summary.leases.grantedCount += 1;
+            summary.leases.activeCount += 1;
+        }
+        else if (status === 'denied')
+            summary.leases.deniedCount += 1;
+        else if (status === 'released')
+            summary.leases.releasedCount += 1;
+        else if (status === 'expired')
+            summary.leases.expiredCount += 1;
+    }
+}
+function summarizeLeaseEvent(summary, event) {
+    const type = normalized(event.type);
+    if (type.endsWith('granted'))
+        summary.leases.grantedCount += 1;
+    else if (type.endsWith('denied'))
+        summary.leases.deniedCount += 1;
+    else if (type.endsWith('released'))
+        summary.leases.releasedCount += 1;
+    else if (type.endsWith('expired'))
+        summary.leases.expiredCount += 1;
+}
+function summarizeGateExecution(summary, execution) {
+    summary.gates.executionCount += 1;
+    summary.gates.durationMs += numberValue(execution.durationMs);
+    incrementRecordCount(summary.gates.kindCounts, textValue(execution.gateKind, 'unknown'));
+    const status = normalized(execution.status);
+    if (status === 'passed')
+        summary.gates.passedCount += 1;
+    else if (status === 'failed') {
+        summary.gates.failedCount += 1;
+        if (execution.required !== false)
+            summary.gates.requiredFailedCount += 1;
+    }
+    else if (status === 'warning' || status === 'blocked' || status === 'unknown') {
+        summary.gates.warningCount += 1;
+    }
+}
+function summarizeGitApplyLedger(summary, ledger) {
+    summary.git.applyLedgerCount += 1;
+    const ledgerSummary = recordValue(ledger.summary);
+    summary.git.appliedCount += numberValue(ledgerSummary.applied);
+    summary.git.committedCount += numberValue(ledgerSummary.committed);
+    summary.git.failedCount += numberValue(ledgerSummary.failed);
+    summary.git.skippedCount += numberValue(ledgerSummary.skipped);
+    for (const entry of recordArray(ledger.entries)) {
+        summary.git.changedPathCount += stringArray(entry.changedPaths).length;
+    }
+}
+function substrateDashboardGraphSummary(substrate) {
+    const nodeCount = substrate.run.eventCount
+        + substrate.run.dashboardCount
+        + substrate.leases.recordCount
+        + substrate.leases.eventCount
+        + substrate.gates.executionCount
+        + substrate.git.workspaceManifestCount
+        + substrate.git.workspaceProofCount
+        + substrate.git.applyLedgerCount
+        + substrate.git.linkRepairCount;
+    if (!nodeCount)
+        return undefined;
+    const gateFailedCount = substrate.gates.failedCount;
+    const blockerCount = substrate.gates.requiredFailedCount + substrate.git.failedCount + substrate.leases.deniedCount;
+    return {
+        sourceFile: substrate.sourceFiles[0],
+        sourceFiles: substrate.sourceFiles,
+        sourceKind: 'frontier-substrate-rollup',
+        sourceKinds: dashboardSubstrateSourceKinds(substrate),
+        sourceStatus: 'collected',
+        sourceStatuses: ['collected'],
+        nodeCount,
+        edgeCount: 0,
+        blockerCount,
+        openBlockerCount: blockerCount,
+        humanQuestionCount: 0,
+        openHumanQuestionCount: 0,
+        safeMergeCandidateCount: substrate.git.appliedCount + substrate.git.committedCount,
+        decisionCount: substrate.leases.eventCount,
+        terminalDecisionCount: 0,
+        terminalAcceptedCount: substrate.git.appliedCount + substrate.git.committedCount,
+        terminalRejectedCount: substrate.git.failedCount,
+        terminalRerunCount: 0,
+        gateCount: substrate.gates.executionCount,
+        gatePassedCount: substrate.gates.passedCount,
+        gateFailedCount,
+        staleCount: 0,
+        openStaleCount: 0,
+        rerunCount: 0,
+        openRerunCount: 0,
+        staleRerunCleanupCount: 0,
+        status: blockerCount ? 'blocked' : gateFailedCount ? 'review' : substrate.git.appliedCount || substrate.git.committedCount ? 'ready' : 'clear',
+        summaryLine: `${nodeCount} substrate records, ${substrate.gates.executionCount} gate executions, ${substrate.leases.activeCount} active leases.`,
+        recentEvents: []
+    };
+}
+function dashboardSubstrateSourceKinds(substrate) {
+    const kinds = [];
+    if (substrate.run.eventCount || substrate.run.dashboardCount)
+        kinds.push('frontier-run');
+    if (substrate.leases.recordCount || substrate.leases.eventCount || substrate.leases.stateCount)
+        kinds.push('frontier-lease');
+    if (substrate.gates.executionCount)
+        kinds.push('frontier-test');
+    if (substrate.git.workspaceManifestCount || substrate.git.workspaceProofCount || substrate.git.applyLedgerCount || substrate.git.linkRepairCount)
+        kinds.push('frontier-swarm-git');
+    return kinds;
+}
+function mergeDashboardGraphSummaries(left, right) {
+    if (!left)
+        return right;
+    if (!right)
+        return left;
+    const sourceFiles = uniquePaths([...stringArray(left.sourceFiles), ...stringArray(right.sourceFiles), textValue(left.sourceFile, ''), textValue(right.sourceFile, '')].filter(Boolean));
+    const sourceKinds = uniquePaths([...stringArray(left.sourceKinds), ...stringArray(right.sourceKinds), textValue(left.sourceKind, ''), textValue(right.sourceKind, '')].filter(Boolean));
+    const sourceStatuses = uniquePaths([...stringArray(left.sourceStatuses), ...stringArray(right.sourceStatuses), textValue(left.sourceStatus, ''), textValue(right.sourceStatus, '')].filter(Boolean));
+    const sumKeys = ['nodeCount', 'edgeCount', 'blockerCount', 'openBlockerCount', 'humanQuestionCount', 'openHumanQuestionCount', 'safeMergeCandidateCount', 'decisionCount', 'terminalDecisionCount', 'terminalAcceptedCount', 'terminalRejectedCount', 'terminalRerunCount', 'gateCount', 'gatePassedCount', 'gateFailedCount', 'staleCount', 'openStaleCount', 'rerunCount', 'openRerunCount', 'staleRerunCleanupCount'];
+    const out = {
+        ...left,
+        sourceFile: sourceFiles[0],
+        sourceFiles,
+        sourceKind: 'lifetime-rollup',
+        sourceKinds,
+        sourceStatus: sourceStatuses.length === 1 ? sourceStatuses[0] : 'mixed',
+        sourceStatuses,
+        recentEvents: [...recordArray(left.recentEvents), ...recordArray(right.recentEvents)].slice(-12)
+    };
+    for (const key of sumKeys)
+        out[key] = numberValue(left[key]) + numberValue(right[key]);
+    const blockerCount = numberValue(out.openBlockerCount);
+    const gateFailedCount = numberValue(out.gateFailedCount);
+    out.status = blockerCount ? 'blocked' : gateFailedCount ? 'review' : numberValue(out.safeMergeCandidateCount) ? 'ready' : 'clear';
+    out.summaryLine = `${numberValue(out.nodeCount)} nodes, ${numberValue(out.edgeCount)} edges, ${numberValue(out.decisionCount)} decisions, and ${numberValue(out.gateCount)} gates across loaded runs and substrate records.`;
+    return out;
+}
+function incrementRecordCount(record, key) {
+    record[key || 'unknown'] = (record[key || 'unknown'] ?? 0) + 1;
+}
 async function combineLifetimeDashboardSnapshots(options, discoveredSources, snapshots, reviewDecisions, queueBacklog) {
     const drainedRunRoots = new Set(snapshots
         .filter((entry) => entry.source.kind === 'run' && isDrainedAutonomousRunSnapshot(entry.snapshot))
@@ -852,13 +1569,19 @@ async function combineLifetimeDashboardSnapshots(options, discoveredSources, sna
         });
     }), reviewDecisions))).slice(0, LIFETIME_DASHBOARD_MAX_JOBS);
     const humanActionAnswers = await readHumanActionAnswers(options);
+    const substrate = await readDashboardSubstrateSummary(options.cwd);
+    const substrateGraph = recordValue(substrate.graph);
+    const graph = withDashboardRunGraphJobHealth(mergeDashboardGraphSummaries(lifetimeDecisionGraphSummary(visibleSnapshots), Object.keys(substrateGraph).length ? substrateGraph : undefined), jobs);
     const summary = {
         ...lifetimeDashboardSummary(jobs),
         coordinationDelayCount: autoDrainDelays.length,
-        dirtyAutoDrainSkipCount: autoDrainDelays.filter((record) => record.skippedReason === 'dirty-worktree').length
+        dirtyAutoDrainSkipCount: autoDrainDelays.filter((record) => record.skippedReason === 'dirty-worktree').length,
+        substrateRecordCount: numberValue(substrateGraph.nodeCount),
+        substrateSourceCount: substrate.sourceCount,
+        ...(graph ? { graph } : {})
     };
     const queueOverlay = lifetimeQueueBacklogOverlay(queueBacklog, jobs);
-    const latestGeneratedAt = Math.max(Date.now(), numberValue(queueBacklog.generatedAt), ...visibleSnapshots.map((entry) => numberValue(entry.snapshot.generatedAt)), ...discoveredSources.map((source) => source.mtimeMs));
+    const latestGeneratedAt = Math.max(Date.now(), numberValue(queueBacklog.generatedAt), substrate.generatedAt, ...visibleSnapshots.map((entry) => numberValue(entry.snapshot.generatedAt)), ...discoveredSources.map((source) => source.mtimeMs));
     const events = visibleSnapshots.flatMap(({ source, snapshot }) => recordArray(snapshot.events).map((event) => ({
         ...event,
         sourceLabel: source.label,
@@ -880,14 +1603,18 @@ async function combineLifetimeDashboardSnapshots(options, discoveredSources, sna
             suppressedCollectionSourceCount: snapshots.length - visibleSnapshots.length,
             queueSourceCount: queueBacklog.sourceCount,
             coordinationDelayCount: autoDrainDelays.length,
+            substrateSourceCount: substrate.sourceCount,
+            ...(substrate.sourceCount ? { substrateFiles: substrate.sourceFiles } : {}),
             ...(humanActionAnswers.length ? { humanActionAnswers: await humanActionAnswerLogPath(options) } : {}),
             ...(reviewDecisions.length ? { coordinatorReviewDecisions: coordinatorReviewDecisionPath(options.cwd) } : {})
         },
         summary,
-        semantic: lifetimeSemanticSummary(jobs),
+        semantic: semanticWithHealth(lifetimeSemanticSummary(jobs), summary, jobs),
         health: lifetimeHealthSummary(jobs),
         quality: {},
         timeSeries: lifetimeTimeSeries(jobs, events),
+        ...(graph ? { graph } : {}),
+        substrate,
         lanes: lifetimeLaneRows(jobs),
         capacity: lifetimeCapacitySummary(queueBacklog, jobs, queueOverlay.entries),
         jobs,
@@ -912,6 +1639,8 @@ async function combineLifetimeDashboardSnapshots(options, discoveredSources, sna
                 loadedSourceCount: visibleSnapshots.length,
                 suppressedCollectionSourceCount: snapshots.length - visibleSnapshots.length,
                 autoDrainDelays,
+                ...(graph ? { graphSourceFiles: graph.sourceFiles } : {}),
+                ...(substrate.sourceCount ? { substrate } : {}),
                 sources: discoveredSources.slice(0, LIFETIME_DASHBOARD_MAX_SOURCES),
                 manifests: queueBacklog.manifests,
                 queueSources: queueBacklog.paths
@@ -919,6 +1648,136 @@ async function combineLifetimeDashboardSnapshots(options, discoveredSources, sna
         }
     };
 }
+function lifetimeDecisionGraphSummary(snapshots) {
+    const graphs = snapshots.map(({ source, snapshot }) => {
+        const graph = recordValue(snapshot.graph ?? recordValue(snapshot.summary).graph);
+        return Object.keys(graph).length ? { source, graph } : undefined;
+    }).filter((entry) => Boolean(entry));
+    if (!graphs.length)
+        return undefined;
+    const sourceFiles = uniquePaths(graphs.flatMap(({ graph }) => stringArray(graph.sourceFiles).length
+        ? stringArray(graph.sourceFiles)
+        : [textValue(graph.sourceFile, '')]).filter(Boolean));
+    const sourceKinds = uniquePaths(graphs.map(({ graph }) => textValue(graph.sourceKind, '')).filter(Boolean));
+    const sourceStatuses = uniquePaths(graphs.map(({ graph }) => textValue(graph.sourceStatus, '')).filter(Boolean));
+    const graphMissingWarnings = uniquePaths(graphs.flatMap(({ graph }) => stringArray(graph.graphMissingWarnings)));
+    const nodeCount = graphNumberSum(graphs, 'nodeCount');
+    const edgeCount = graphNumberSum(graphs, 'edgeCount');
+    const blockerCount = graphNumberSum(graphs, 'blockerCount');
+    const openBlockerCount = graphNumberSum(graphs, 'openBlockerCount');
+    const humanQuestionCount = graphNumberSum(graphs, 'humanQuestionCount');
+    const openHumanQuestionCount = graphNumberSum(graphs, 'openHumanQuestionCount');
+    const safeMergeCandidateCount = graphNumberSum(graphs, 'safeMergeCandidateCount');
+    const decisionCount = graphNumberSum(graphs, 'decisionCount');
+    const terminalDecisionCount = graphNumberSum(graphs, 'terminalDecisionCount');
+    const terminalAcceptedCount = graphNumberSum(graphs, 'terminalAcceptedCount');
+    const terminalRejectedCount = graphNumberSum(graphs, 'terminalRejectedCount');
+    const terminalRerunCount = graphNumberSum(graphs, 'terminalRerunCount');
+    const gateCount = graphNumberSum(graphs, 'gateCount');
+    const gateFailedCount = graphNumberSum(graphs, 'gateFailedCount');
+    const staleCount = graphNumberSum(graphs, 'staleCount');
+    const openStaleCount = graphNumberSum(graphs, 'openStaleCount');
+    const rerunCount = graphNumberSum(graphs, 'rerunCount');
+    const openRerunCount = graphNumberSum(graphs, 'openRerunCount');
+    const staleRerunCleanupCount = graphNumberSum(graphs, 'staleRerunCleanupCount');
+    const recentEvents = graphs.flatMap(({ source, graph }) => recordArray(graph.recentEvents).map((event) => ({
+        ...event,
+        sourceLabel: source.label,
+        at: numberValue(event.at) || source.mtimeMs
+    }))).sort((left, right) => numberValue(left.at) - numberValue(right.at)).slice(-12);
+    const status = openBlockerCount ? 'blocked' : openHumanQuestionCount ? 'questions' : gateFailedCount ? 'review' : safeMergeCandidateCount ? 'ready' : 'clear';
+    return {
+        sourceFile: sourceFiles[0],
+        sourceFiles,
+        sourceKind: 'lifetime-rollup',
+        sourceKinds,
+        sourceStatus: sourceStatuses.length === 1 ? sourceStatuses[0] : sourceStatuses.length ? 'mixed' : 'unknown',
+        sourceStatuses,
+        graphMissing: graphMissingWarnings.length > 0,
+        graphMissingWarningCount: graphMissingWarnings.length,
+        graphMissingWarnings: graphMissingWarnings.slice(0, 12),
+        nodeCount,
+        edgeCount,
+        blockerCount,
+        openBlockerCount,
+        humanQuestionCount,
+        openHumanQuestionCount,
+        safeMergeCandidateCount,
+        decisionCount,
+        terminalDecisionCount,
+        terminalAcceptedCount,
+        terminalRejectedCount,
+        terminalRerunCount,
+        gateCount,
+        gatePassedCount: graphNumberSum(graphs, 'gatePassedCount'),
+        gateFailedCount,
+        staleCount,
+        openStaleCount,
+        rerunCount,
+        openRerunCount,
+        staleRerunCleanupCount,
+        status,
+        summaryLine: `${nodeCount} nodes, ${edgeCount} edges, ${decisionCount} decisions, and ${gateCount} gates across loaded runs.`,
+        recentEvents
+    };
+}
+function graphNumberSum(graphs, key) {
+    return graphs.reduce((sum, entry) => sum + numberValue(entry.graph[key]), 0);
+}
+function withDashboardRunGraphJobHealth(graph, jobs) {
+    if (!graph)
+        return undefined;
+    const staleJobs = jobs.filter(dashboardGraphJobIsStale);
+    const rerunJobs = jobs.filter(dashboardGraphJobIsRerun);
+    const staleCleanupCount = staleJobs.filter(dashboardGraphJobIsCleanup).length;
+    const rerunCleanupCount = rerunJobs.filter(dashboardGraphJobIsCleanup).length;
+    const staleCount = Math.max(numberValue(graph.staleCount), staleJobs.length);
+    const rerunCount = Math.max(numberValue(graph.rerunCount), rerunJobs.length);
+    const staleRerunCleanupCount = Math.max(numberValue(graph.staleRerunCleanupCount), staleCleanupCount + rerunCleanupCount);
+    return {
+        ...graph,
+        staleCount,
+        rerunCount,
+        staleRerunCleanupCount,
+        openStaleCount: Math.max(numberValue(graph.openStaleCount), Math.max(0, staleJobs.length - staleCleanupCount)),
+        openRerunCount: Math.max(numberValue(graph.openRerunCount), Math.max(0, rerunJobs.length - rerunCleanupCount))
+    };
+}
+function dashboardGraphJobIsStale(job) {
+    const values = [
+        job.bucket,
+        job.originalBucket,
+        job.status,
+        job.originalStatus,
+        job.disposition,
+        job.originalDisposition,
+        job.mergeReadiness,
+        ...(stringArray(job.reasons)),
+        ...(stringArray(job.originalReasons))
+    ].map(normalized);
+    return job.staleAgainstHead === true || values.some((value) => value.includes('stale'));
+}
+function dashboardGraphJobIsRerun(job) {
+    const values = [
+        job.bucket,
+        job.originalBucket,
+        job.status,
+        job.originalStatus,
+        job.disposition,
+        job.originalDisposition,
+        job.mergeReadiness,
+        ...(stringArray(job.reasons)),
+        ...(stringArray(job.originalReasons))
+    ].map(normalized);
+    return values.some((value) => value.includes('rerun'));
+}
+function dashboardGraphJobIsCleanup(job) {
+    if (isResolvedCoordinatorReviewRecord(job))
+        return true;
+    const status = normalized(job.status);
+    const decision = normalized(job.coordinatorDecisionStatus ?? recordValue(job.coordinatorDecision).status);
+    return status === 'completed' && ['accepted', 'accepted-applied', 'applied', 'committed', 'rejected', 'rerun', 'superseded'].includes(decision);
+}
 function lifetimeScopedId(source, id) {
     return `${source.id}:${id}`.replaceAll(/[^\w:.-]+/g, '-');
 }
@@ -1217,6 +2076,7 @@ function readDrainPidManifestJob(cwd, coordinatorRunDir, entry, planJob, now) {
     const lane = textValue(planJob?.lane ?? task.lane, drainCoordinatorLane(jobId, runKind));
     return withRecomputedCostFields({
         id: jobId,
+        jobId,
         originalJobId: jobId,
         taskId: textValue(planJob?.taskId ?? task.id, jobId),
         title: textValue(planJob?.title ?? task.title, runKind === 'coordinator' ? `Coordinate lane review for ${lane}` : `Continue ${lane} work`),
@@ -1408,7 +2268,7 @@ function mergeLifetimeDrainCoordinatorSnapshot(lifetime, drain) {
             ...recordValue(lifetime.sources),
             ...recordValue(drain?.sources)
         },
-        summary: lifetimeDashboardSummary(jobs),
+        summary: lifetimeSummaryWithExistingGraph(lifetime, jobs),
         health: lifetimeHealthSummary(jobs),
         lanes: lifetimeLaneRows(jobs),
         jobs,
@@ -1437,7 +2297,7 @@ function mergeLifetimeActiveRunSnapshot(lifetime, active) {
             ...recordValue(lifetime.sources),
             ...recordValue(active?.sources)
         },
-        summary: lifetimeDashboardSummary(jobs),
+        summary: lifetimeSummaryWithExistingGraph(lifetime, jobs),
         health: lifetimeHealthSummary(jobs),
         lanes: lifetimeLaneRows(jobs),
         capacity: lifetimeCapacitySummary({
@@ -1795,6 +2655,22 @@ function applyCoordinatorReviewDecisions(jobs, decisions) {
         return resolved ? markCoordinatorReviewResolved(decided, status) : decided;
     });
 }
+function reviewDecisionAdjustedSummary(summary, jobs) {
+    const recomputed = lifetimeDashboardSummary(jobs);
+    const bucketCounts = countJobsByBucket(jobs);
+    const openReviewCount = jobs.filter(isOpenCoordinatorReviewRecord).length;
+    const resolvedReviewCount = jobs.filter(isResolvedCoordinatorReviewRecord).length;
+    return {
+        ...summary,
+        ...recomputed,
+        bucketCounts: {
+            total: jobs.length,
+            ...bucketCounts
+        },
+        needsCoordinatorReviewCount: openReviewCount,
+        reviewResolvedCount: resolvedReviewCount
+    };
+}
 function normalizeCoordinatorFacingJob(record) {
     const status = coordinatorFacingMachineLabel(record.status);
     let bucket = coordinatorFacingMachineLabel(record.bucket);
@@ -1813,11 +2689,56 @@ function normalizeCoordinatorFacingJob(record) {
         disposition: coordinatorFacingMachineLabel(record.disposition),
         mergeReadiness: coordinatorFacingMachineLabel(record.mergeReadiness)
     };
+    normalizedRecord = normalizeUnreasonedBlockedJob(normalizedRecord);
     normalizedRecord = normalizeHistoricalEvidenceFailureJob(normalizedRecord);
     if (!isResolvedCoordinatorReviewRecord(normalizedRecord))
         return normalizedRecord;
     return markCoordinatorReviewResolved(normalizedRecord, textValue(normalizedRecord.coordinatorDecisionStatus ?? normalizedRecord.disposition, 'review-resolved'));
 }
+function normalizeUnreasonedBlockedJob(record) {
+    const status = normalized(record.status);
+    const bucket = normalized(record.bucket);
+    if (status !== 'blocked' && bucket !== 'blocked')
+        return record;
+    if (hasExplicitBlockedEvidence(record))
+        return record;
+    return {
+        ...record,
+        originalBucket: record.originalBucket ?? record.bucket,
+        originalStatus: record.originalStatus ?? record.status,
+        originalDisposition: record.originalDisposition ?? record.disposition,
+        bucket: 'needs-coordinator-review',
+        status: 'completed',
+        disposition: 'needs-coordinator-review',
+        mergeReadiness: 'needs-coordinator-review',
+        reasons: uniquePaths([...stringArray(record.reasons), 'blocked-status-without-blocker-evidence']),
+        collectReasonClasses: uniquePaths([...stringArray(record.collectReasonClasses), 'run status needs coordinator classification'])
+    };
+}
+function hasExplicitBlockedEvidence(record) {
+    const fields = [
+        record.disposition,
+        record.mergeReadiness,
+        record.semanticReadiness,
+        record.outcome,
+        record.health
+    ].map(normalized);
+    if (fields.some((field) => ['blocked', 'conflict', 'conflict-blocked', 'human-blocked', 'human-needed'].includes(field)))
+        return true;
+    if (numberValue(record.blockerCount) > 0 || numberValue(record.openBlockerCount) > 0)
+        return true;
+    if (numberValue(record.humanActionCount) > 0 || numberValue(record.openHumanQuestionCount) > 0)
+        return true;
+    if (numberValue(record.commandsFailed) > 0 || numberValue(record.failedCheckCount) > 0)
+        return true;
+    const classes = [
+        ...stringArray(record.reasons),
+        ...stringArray(record.collectReasonClasses),
+        ...stringArray(record.blockers),
+        ...stringArray(record.humanQuestions)
+    ].map(normalized);
+    return classes.some((value) => /\b(?:blocked|blocker|conflict|human-needed|human-blocked|human-question|failed-evidence|quota-deferred|timeout|denied)\b/u.test(value));
+}
 function normalizeHistoricalEvidenceFailureJob(record) {
     if (!isHistoricalOwnershipRescopeCandidate(record))
         return record;
@@ -1965,10 +2886,10 @@ function coordinatorReviewDecisionMatches(job, decision) {
     if (!idMatches)
         return false;
     const decisionSource = textValue(decision.source ?? decision.sourceCollection ?? decision.sourceRun ?? decision.sourceLabel, '');
+    if (isHistoricalReviewDrainDecision(decision) && historicalReviewDrainDecisionMatches(job, decision))
+        return true;
     if (!decisionSource)
         return true;
-    if (isHistoricalReviewDrainDecision(decision))
-        return historicalReviewDrainDecisionMatches(job, decision);
     const jobSources = [
         textValue(job.sourceLabel, ''),
         textValue(job.sourceCollection, ''),
@@ -2081,6 +3002,13 @@ function lifetimeDashboardSummary(jobs) {
         bucketCounts: countJobsByBucket(jobs)
     };
 }
+function lifetimeSummaryWithExistingGraph(lifetime, jobs) {
+    const graph = recordValue(lifetime.graph ?? recordValue(lifetime.summary).graph);
+    return {
+        ...lifetimeDashboardSummary(jobs),
+        ...(Object.keys(graph).length ? { graph } : {})
+    };
+}
 function countJobsByBucket(jobs) {
     const counts = {};
     for (const job of jobs) {
@@ -2346,6 +3274,404 @@ function lifetimeSemanticSummary(jobs) {
         conflicts: jobs.filter((job) => textValue(job.semanticReadiness, '') === 'blocked').length
     };
 }
+function semanticWithHealth(semantic, summary, jobs) {
+    const existingHealth = recordValue(semantic.health);
+    const sourceSummary = { ...recordValue(summary.bucketCounts), ...summary };
+    const imports = recordValue(semantic.import);
+    const edit = recordValue(semantic.edit);
+    const script = recordValue(edit.script);
+    const projection = recordValue(edit.projection);
+    const replay = recordValue(semantic.replay);
+    const admission = recordValue(semantic.admission);
+    const jobAdmission = recordValue(admission.jobs);
+    const scriptAdmission = recordValue(admission.scripts);
+    const jobAdmissionStatusCounts = numberRecordValue(recordValue(jobAdmission.statusCounts));
+    const scriptAdmissionStatusCounts = numberRecordValue(recordValue(scriptAdmission.statusCounts));
+    const parserLosses = firstNumber(sourceSummary.semanticImportLossCount, imports.lossCount);
+    const parserLossSeverityCounts = numberRecordValue(recordValue(sourceSummary.semanticImportLossesBySeverity ?? imports.lossSeverityCounts));
+    const parserWarnings = firstNumber(sourceSummary.semanticImportWarningCount, imports.warningCount);
+    const expectedMissingReasonCodes = uniquePaths([
+        ...stringArray(sourceSummary.semanticImportExpectedMissingReasonCodes),
+        ...stringArray(imports.expectedMissingReasonCodes)
+    ]);
+    const ledger = recordValue(sourceSummary.applyLedger);
+    const ledgerFailed = numberValue(ledger.failed);
+    const ledgerSkipped = numberValue(ledger.skipped);
+    const ledgerLanded = firstNumber(ledger.landed, sourceSummary.landed);
+    const autoMergeCandidates = Math.max(firstNumber(sourceSummary.semanticEditScriptAutoMergeCandidates, script.autoMergeCandidateCount, semantic.autoMerge), numberValue(jobAdmission.autoMergeCandidateCount), numberValue(scriptAdmission.autoMergeCandidateCount));
+    const scriptConflicts = firstNumber(sourceSummary.semanticEditScriptConflicts, script.conflictCount);
+    const replayConflicts = firstNumber(sourceSummary.semanticEditReplayConflicts, replay.conflictCount, semantic.conflicts);
+    const conflictCount = scriptConflicts + replayConflicts +
+        admissionStatusCount(jobAdmissionStatusCounts, 'conflict') +
+        admissionStatusCount(scriptAdmissionStatusCounts, 'conflict');
+    const scriptBlocked = firstNumber(sourceSummary.semanticEditScriptBlocked, script.blockedCount);
+    const projectionBlocked = firstNumber(sourceSummary.semanticEditProjectionBlocked, projection.blockedCount);
+    const replayBlocked = firstNumber(sourceSummary.semanticEditReplayBlocked, replay.blockedCount);
+    const lineageBlocked = firstNumber(sourceSummary.semanticLineageBlocked);
+    const blockedCount = scriptBlocked + projectionBlocked + replayBlocked + lineageBlocked +
+        admissionStatusCount(jobAdmissionStatusCounts, 'blocked') +
+        admissionStatusCount(scriptAdmissionStatusCounts, 'blocked');
+    const staleCount = firstNumber(sourceSummary.semanticEditScriptStale, script.staleCount) +
+        firstNumber(sourceSummary.semanticEditReplayStale, replay.staleCount);
+    const needsPortCount = firstNumber(sourceSummary.semanticEditScriptNeedsPort, script.needsPortCount) +
+        firstNumber(sourceSummary.semanticEditReplayNeedsPort, replay.needsPortCount);
+    const reviewRequiredCount = firstNumber(sourceSummary.semanticEditScriptReviewRequired, script.reviewRequiredCount) +
+        firstNumber(sourceSummary.semanticLineageNeedsReview) +
+        firstNumber(sourceSummary.semanticLineageAmbiguous) +
+        admissionStatusCount(jobAdmissionStatusCounts, 'review-required') +
+        admissionStatusCount(scriptAdmissionStatusCounts, 'review-required');
+    const reviewReasonCodes = uniquePaths([
+        ...expectedMissingReasonCodes,
+        ...stringArray(sourceSummary.semanticLineageReasonCodes),
+        ...stringArray(sourceSummary.semanticEditScriptReasonCodes),
+        ...stringArray(sourceSummary.semanticEditProjectionReasonCodes),
+        ...stringArray(sourceSummary.semanticEditReplayReasonCodes),
+        ...stringArray(replay.reasonCodes)
+    ]).slice(0, 12);
+    const proofFailed = firstNumber(sourceSummary.semanticProofSpecFailedObligations);
+    const openCoordinatorReviewCount = jobs.filter(isOpenCoordinatorReviewRecord).length;
+    const synthesizedResearchCompleteCount = jobs.filter(isSynthesizedResearchCompleteRecord).length;
+    const failedCount = numberValue(parserLossSeverityCounts.error) + proofFailed + ledgerFailed + conflictCount + blockedCount;
+    const warningCount = parserWarnings + reviewRequiredCount + ledgerSkipped + staleCount + needsPortCount + openCoordinatorReviewCount;
+    const passedCount = firstNumber(replay.acceptedCleanCount, semantic.acceptedClean) +
+        numberValue(replay.alreadyAppliedCount) +
+        ledgerLanded +
+        autoMergeCandidates;
+    const gateReasonCodes = uniquePaths([
+        ...reviewReasonCodes,
+        ...(numberValue(parserLossSeverityCounts.error) ? ['semantic-parser-error-loss'] : []),
+        ...(proofFailed ? ['semantic-proof-obligation-failed'] : []),
+        ...(ledgerFailed ? ['apply-ledger-failed'] : []),
+        ...(conflictCount ? ['semantic-conflict'] : []),
+        ...(blockedCount ? ['semantic-blocked'] : []),
+        ...(openCoordinatorReviewCount ? ['open-coordinator-review'] : [])
+    ]).slice(0, 12);
+    const parserHealth = {
+        lossCount: parserLosses,
+        lossSeverityCounts: parserLossSeverityCounts,
+        warningCount: parserWarnings,
+        expectedMissingReasonCodes
+    };
+    const ledgerHealth = {
+        totalCount: numberValue(ledger.total),
+        landedCount: ledgerLanded,
+        skippedCount: ledgerSkipped,
+        failedCount: ledgerFailed
+    };
+    const mergeHealth = {
+        autoMergeCandidateCount: autoMergeCandidates,
+        reviewRequiredCount,
+        conflictCount,
+        staleCount,
+        blockedCount,
+        needsPortCount,
+        reasonCodes: reviewReasonCodes
+    };
+    const gatesHealth = {
+        status: semanticGateStatus({ failedCount, warningCount, passedCount }),
+        passedCount,
+        warningCount,
+        failedCount,
+        reasonCodes: gateReasonCodes
+    };
+    const outcomesHealth = {
+        openCoordinatorReviewCount,
+        synthesizedResearchCompleteCount
+    };
+    return {
+        ...semantic,
+        import: {
+            ...imports,
+            lossCount: parserLosses,
+            lossSeverityCounts: parserLossSeverityCounts
+        },
+        health: {
+            ...existingHealth,
+            parser: { ...parserHealth, ...recordValue(existingHealth.parser) },
+            ledger: { ...ledgerHealth, ...recordValue(existingHealth.ledger) },
+            merge: { ...mergeHealth, ...recordValue(existingHealth.merge) },
+            gates: { ...gatesHealth, ...recordValue(existingHealth.gates) },
+            outcomes: { ...outcomesHealth, ...recordValue(existingHealth.outcomes) },
+            admission: semanticAdmissionHealth({
+                sourceSummary,
+                semantic,
+                existingHealth,
+                imports,
+                replay,
+                jobAdmission,
+                scriptAdmission,
+                jobAdmissionStatusCounts,
+                scriptAdmissionStatusCounts,
+                jobs,
+                parserLosses,
+                parserWarnings,
+                ledgerLanded,
+                autoMergeCandidates,
+                conflictCount,
+                staleCount,
+                reviewRequiredCount,
+                openCoordinatorReviewCount,
+                expectedMissingReasonCodes
+            })
+        }
+    };
+}
+const SEMANTIC_ADMISSION_STATUS_KEYS = [
+    'safe-merged',
+    'safe-with-losses',
+    'conflict',
+    'no-op',
+    'stale',
+    'missing-sidecar',
+    'coordinator-review',
+    'tests-missing'
+];
+function semanticAdmissionHealth(input) {
+    const existingAdmission = recordValue(input.existingHealth.admission);
+    const reasonCodeCounts = semanticAdmissionReasonCodeCounts(input);
+    const statusCounts = emptySemanticAdmissionStatusCounts();
+    addSemanticAdmissionStatusCounts(statusCounts, input.jobAdmissionStatusCounts);
+    addSemanticAdmissionStatusCounts(statusCounts, input.scriptAdmissionStatusCounts);
+    addSemanticAdmissionStatusCounts(statusCounts, numberRecordValue(recordValue(existingAdmission.statusCounts)));
+    const replaySafeCount = firstNumber(input.replay.acceptedCleanCount, input.semantic.acceptedClean) +
+        numberValue(input.replay.alreadyAppliedCount);
+    setRecordMinimum(statusCounts, 'safe-merged', Math.max(replaySafeCount, input.ledgerLanded, input.autoMergeCandidates));
+    setRecordMinimum(statusCounts, 'safe-with-losses', Math.max(numberValue(reasonCodeCounts['lossy-import']), input.parserLosses + input.parserWarnings > 0 && numberValue(statusCounts['safe-merged']) > 0 ? input.parserLosses + input.parserWarnings : 0));
+    setRecordMinimum(statusCounts, 'conflict', Math.max(input.conflictCount, numberValue(reasonCodeCounts['symbol-conflict']) + numberValue(reasonCodeCounts['effect-conflict'])));
+    setRecordMinimum(statusCounts, 'stale', Math.max(input.staleCount, numberValue(reasonCodeCounts['stale-source-hash']), numberValue(input.sourceSummary['stale-against-head'])));
+    setRecordMinimum(statusCounts, 'missing-sidecar', Math.max(numberValue(reasonCodeCounts['missing-sidecar']), input.expectedMissingReasonCodes.filter((reason) => semanticAdmissionReasonCode(reason) === 'missing-sidecar').length));
+    setRecordMinimum(statusCounts, 'coordinator-review', Math.max(input.reviewRequiredCount, input.openCoordinatorReviewCount, numberValue(input.sourceSummary['needs-coordinator-review'])));
+    setRecordMinimum(statusCounts, 'tests-missing', numberValue(reasonCodeCounts['tests-missing']));
+    return {
+        ...existingAdmission,
+        statusCounts,
+        reasonCodeCounts,
+        totalCount: sumNumberRecordValues(statusCounts),
+        reasonTotalCount: sumNumberRecordValues(reasonCodeCounts)
+    };
+}
+function emptySemanticAdmissionStatusCounts() {
+    return SEMANTIC_ADMISSION_STATUS_KEYS.reduce((out, key) => {
+        out[key] = 0;
+        return out;
+    }, {});
+}
+function addSemanticAdmissionStatusCounts(out, counts) {
+    for (const [status, count] of Object.entries(counts)) {
+        const key = semanticAdmissionStateKey(status);
+        if (key && count > 0)
+            out[key] += count;
+    }
+}
+function semanticAdmissionReasonCodeCounts(input) {
+    const counts = {};
+    const existingAdmission = recordValue(input.existingHealth.admission);
+    const admission = recordValue(input.semantic.admission);
+    addReasonCodeCountRecord(counts, recordValue(input.sourceSummary.semanticAdmissionReasonCodeCounts));
+    addReasonCodeCountRecord(counts, recordValue(input.sourceSummary.semanticCollectAdmissionReasonCodeCounts));
+    addReasonCodeCountRecord(counts, recordValue(input.sourceSummary.semanticEditAdmissionReasonCodeCounts));
+    addReasonCodeCountRecord(counts, recordValue(input.sourceSummary.semanticEditScriptAdmissionReasonCodeCounts));
+    addReasonCodeCountRecord(counts, recordValue(admission.reasonCodeCounts));
+    addReasonCodeCountRecord(counts, recordValue(input.jobAdmission.reasonCodeCounts));
+    addReasonCodeCountRecord(counts, recordValue(input.scriptAdmission.reasonCodeCounts));
+    addReasonCodeCountRecord(counts, recordValue(existingAdmission.reasonCodeCounts));
+    addReasonCodeSignals(counts, [
+        ...stringArray(input.sourceSummary.semanticAdmissionReasonCodes),
+        ...stringArray(input.sourceSummary.semanticCollectAdmissionReasonCodes),
+        ...stringArray(input.sourceSummary.semanticImportExpectedMissingReasonCodes),
+        ...stringArray(input.sourceSummary.semanticLineageReasonCodes),
+        ...stringArray(input.sourceSummary.semanticEditScriptReasonCodes),
+        ...stringArray(input.sourceSummary.semanticEditProjectionReasonCodes),
+        ...stringArray(input.sourceSummary.semanticEditReplayReasonCodes),
+        ...input.expectedMissingReasonCodes,
+        ...stringArray(input.imports.expectedMissingReasonCodes),
+        ...stringArray(input.replay.reasonCodes)
+    ]);
+    for (const job of input.jobs) {
+        addReasonCodeSignals(counts, [
+            textValue(job.semanticAdmissionStatus, ''),
+            textValue(job.semanticReadiness, ''),
+            textValue(job.bucket, ''),
+            textValue(job.disposition, ''),
+            textValue(job.mergeReadiness, ''),
+            ...stringArray(job.semanticReadinessReasons),
+            ...stringArray(job.collectReasonClasses),
+            ...stringArray(job.reasons)
+        ]);
+    }
+    setRecordMinimum(counts, 'lossy-import', input.parserLosses + input.parserWarnings);
+    setRecordMinimum(counts, 'stale-source-hash', input.staleCount);
+    setRecordMinimum(counts, 'symbol-conflict', input.conflictCount);
+    setRecordMinimum(counts, 'coordinator-review', input.reviewRequiredCount + input.openCoordinatorReviewCount);
+    return counts;
+}
+function addReasonCodeCountRecord(out, counts) {
+    for (const [key, value] of Object.entries(counts)) {
+        const count = numberValue(value);
+        if (count <= 0)
+            continue;
+        const code = semanticAdmissionReasonCode(key) ?? normalizedStatusKey(key);
+        out[code] = (out[code] ?? 0) + count;
+    }
+}
+function addReasonCodeSignals(out, values) {
+    for (const value of values) {
+        const code = semanticAdmissionReasonCode(value);
+        if (code)
+            out[code] = (out[code] ?? 0) + 1;
+    }
+}
+function semanticAdmissionStateKey(value) {
+    const signal = normalizedStatusKey(value);
+    if (!signal)
+        return undefined;
+    if (signal === 'safe-merged' ||
+        signal === 'safe' ||
+        signal === 'accepted' ||
+        signal === 'accepted-clean' ||
+        signal === 'clean' ||
+        signal === 'ready' ||
+        signal === 'pass' ||
+        signal === 'auto-merge-candidate' ||
+        signal === 'already-applied' ||
+        signal === 'portable')
+        return 'safe-merged';
+    if (signal === 'safe-with-losses' ||
+        signal === 'lossy' ||
+        signal === 'lossy-import' ||
+        signal === 'warning' ||
+        signal === 'warnings' ||
+        signal === 'clean-with-losses')
+        return 'safe-with-losses';
+    if (signal === 'conflict' ||
+        signal === 'conflicts' ||
+        signal === 'symbol-conflict' ||
+        signal === 'effect-conflict' ||
+        signal === 'blocked')
+        return 'conflict';
+    if (signal === 'no-op' ||
+        signal === 'noop' ||
+        signal === 'not-applicable' ||
+        signal === 'no-semantic-edit-script' ||
+        signal === 'evidence-only')
+        return 'no-op';
+    if (signal === 'stale' ||
+        signal === 'rerun' ||
+        signal === 'stale-against-head' ||
+        signal === 'stale-source-hash')
+        return 'stale';
+    if (signal === 'missing-sidecar' ||
+        signal === 'empty-sidecar')
+        return 'missing-sidecar';
+    if (signal === 'coordinator-review' ||
+        signal === 'needs-coordinator-review' ||
+        signal === 'needs-coordinator-port' ||
+        signal === 'needs-human-port' ||
+        signal === 'needs-human-review' ||
+        signal === 'review' ||
+        signal === 'review-required' ||
+        signal === 'needs-review' ||
+        signal === 'needs-port')
+        return 'coordinator-review';
+    if (signal === 'tests-missing' ||
+        signal === 'missing-tests')
+        return 'tests-missing';
+    return undefined;
+}
+function semanticAdmissionReasonCode(value) {
+    const signal = normalizedStatusKey(value);
+    if (!signal)
+        return undefined;
+    if (signal.includes('tests-missing') || signal.includes('missing-tests') || (signal.includes('test') && signal.includes('missing')))
+        return 'tests-missing';
+    if (signal.includes('missing-sidecar') ||
+        signal.includes('empty-sidecar') ||
+        signal.includes('missing-semantic-import-sidecar') ||
+        (signal.includes('missing') && signal.includes('sidecar')))
+        return 'missing-sidecar';
+    if (signal.includes('stale-source-hash') ||
+        signal.includes('stale-against-head') ||
+        signal.includes('stale') ||
+        ((signal.includes('current') || signal.includes('head')) && (signal.includes('hash') || signal.includes('anchor') || signal.includes('source') || signal.includes('base'))))
+        return 'stale-source-hash';
+    if (signal.includes('effect-conflict') || (signal.includes('effect') && (signal.includes('conflict') || signal.includes('mismatch') || signal.includes('blocked'))))
+        return 'effect-conflict';
+    if (signal.includes('symbol-conflict') ||
+        signal.includes('semantic-conflict') ||
+        signal.includes('symbol-anchor') ||
+        signal.includes('anchor-content-mismatch') ||
+        signal.includes('anchor-changed') ||
+        signal.includes('conflict'))
+        return 'symbol-conflict';
+    if (signal.includes('lossy-import') ||
+        signal.includes('parser-error-loss') ||
+        signal.includes('loss'))
+        return 'lossy-import';
+    if (signal.includes('coordinator-review') ||
+        signal.includes('open-coordinator-review') ||
+        signal.includes('review-required') ||
+        signal.includes('needs-review') ||
+        signal.includes('needs-port') ||
+        signal.includes('human-port'))
+        return 'coordinator-review';
+    return undefined;
+}
+function setRecordMinimum(record, key, value) {
+    if (value > (record[key] ?? 0))
+        record[key] = value;
+}
+function sumNumberRecordValues(record) {
+    return Object.values(record).reduce((sum, value) => sum + numberValue(value), 0);
+}
+function isSynthesizedResearchCompleteRecord(job) {
+    if (normalized(job.status) !== 'completed' || isOpenCoordinatorReviewRecord(job))
+        return false;
+    const signals = [
+        job.lane,
+        job.title,
+        job.workKind,
+        job.disposition,
+        job.mergeReadiness,
+        ...stringArray(job.reasons),
+        ...stringArray(job.collectReasonClasses)
+    ].map(normalized);
+    return signals.some((signal) => signal === 'discovery-only' ||
+        signal.includes('research') ||
+        signal.includes('synthesized') ||
+        signal.includes('collector-workspace-only-recovery') ||
+        signal.includes('generated-by-collector'));
+}
+function numberRecordValue(value) {
+    const out = {};
+    for (const [key, entry] of Object.entries(value)) {
+        const count = numberValue(entry);
+        if (count > 0)
+            out[key] = count;
+    }
+    return out;
+}
+function admissionStatusCount(record, wanted) {
+    return Object.entries(record).reduce((sum, [key, value]) => normalizedStatusKey(key) === wanted ? sum + value : sum, 0);
+}
+function normalizedStatusKey(value) {
+    return textValue(value, '').trim().replace(/[\s_]+/g, '-').toLowerCase();
+}
+function semanticGateStatus(input) {
+    if (input.failedCount > 0)
+        return 'blocked';
+    if (input.warningCount > 0)
+        return 'review';
+    if (input.passedCount > 0)
+        return 'pass';
+    return 'unknown';
+}
+function firstNumber(...values) {
+    for (const value of values) {
+        if (typeof value === 'number' && Number.isFinite(value))
+            return value;
+    }
+    return 0;
+}
 async function lifetimeRoutingSummary(cwd, entries) {
     const routingRows = entries.map(({ snapshot }) => recordValue(snapshot.routing)).filter((entry) => Object.keys(entry).length);
     const sidecars = await readLifetimeRoutingSidecars(cwd, entries.map(({ source }) => source));
@@ -2462,6 +3788,7 @@ async function readActiveRunSnapshot(options, readOptions = {}) {
     const actualInputTokens = jobs.reduce((sum, job) => sum + numberValue(job.actualInputTokens), 0);
     const estimatedInputTokens = jobs.reduce((sum, job) => sum + numberValue(job.estimatedInputTokens), 0);
     const cachedInputTokens = jobs.reduce((sum, job) => sum + numberValue(job.cachedInputTokens), 0);
+    const graph = await readDashboardLiveRunGraphSummary(options.cwd, runDir, jobs, now);
     return {
         ok: true,
         generatedAt: now,
@@ -2482,16 +3809,20 @@ async function readActiveRunSnapshot(options, readOptions = {}) {
                 running: runningCount,
                 completed: completedCount,
                 'failed-evidence': failedCount
-            }
+            },
+            ...(graph ? { graph } : {})
         },
+        health: lifetimeHealthSummary(jobs),
         lanes: activeRunLanes(jobs),
         jobs,
         activeAgents: activeAgentsFromJobs(jobs),
         events: activeRunEvents(jobs),
+        ...(graph ? { graph } : {}),
         sources: {
             run: runDir,
             activeRun: pidPath,
-            plan: planPath
+            plan: planPath,
+            ...(graph ? { graph: textValue(graph.sourceFile, '') } : {})
         },
         raw: {
             activeRun: {
@@ -2502,6 +3833,143 @@ async function readActiveRunSnapshot(options, readOptions = {}) {
         }
     };
 }
+async function readDashboardLiveRunGraphSummary(cwd, runDir, jobs, now) {
+    const file = path.join(runDir, LIVE_RUN_GRAPH_EVENTS_FILE);
+    const stat = await fs.stat(file).catch(() => undefined);
+    if (stat?.isFile() && stat.size <= CODEX_EVENTS_USAGE_MAX_BYTES) {
+        const events = await readLiveRunGraphEvents(file);
+        if (events.length) {
+            return summarizeDashboardRunGraph(liveRunGraphFromEvents(events, path.basename(runDir), now), {
+                sourceFile: path.relative(cwd, file).replaceAll(path.sep, '/'),
+                sourceKind: 'live-run-graph-events',
+                sourceStatus: 'live',
+                liveEventCount: events.length
+            });
+        }
+    }
+    return activeRunGraphFallback(cwd, runDir, jobs, now, stat?.isFile() && stat.size > CODEX_EVENTS_USAGE_MAX_BYTES
+        ? `${LIVE_RUN_GRAPH_EVENTS_FILE} is too large to parse for dashboard health.`
+        : `${LIVE_RUN_GRAPH_EVENTS_FILE} is missing; projected graph health from the active PID manifest.`);
+}
+async function readLiveRunGraphEvents(file) {
+    const text = await fs.readFile(file, 'utf8').catch(() => '');
+    const out = [];
+    for (const line of text.split(/\r?\n/u)) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        const parsed = safeJsonObject(trimmed);
+        if (parsed && textValue(parsed.kind, '') === 'frontier.swarm-codex.live-run-graph-event')
+            out.push(parsed);
+    }
+    return out;
+}
+function liveRunGraphFromEvents(events, runId, generatedAt) {
+    const nodes = new Map();
+    const edges = new Map();
+    let latestGeneratedAt = generatedAt;
+    for (const event of events) {
+        latestGeneratedAt = Math.max(latestGeneratedAt, numberValue(event.generatedAt));
+        for (const node of recordArray(event.nodes)) {
+            const id = textValue(node.id, '');
+            if (!id)
+                continue;
+            const current = nodes.get(id);
+            nodes.set(id, current ? mergeDashboardRunGraphNode(current, node) : node);
+        }
+        for (const edge of recordArray(event.edges)) {
+            const id = textValue(edge.id, `${textValue(edge.kind, 'edge')}:${textValue(edge.from, '')}->${textValue(edge.to, '')}`);
+            if (id)
+                edges.set(id, { ...edge, id });
+        }
+    }
+    const nodeList = Array.from(nodes.values());
+    const edgeList = Array.from(edges.values());
+    return {
+        kind: 'frontier.swarm-codex.run-graph',
+        version: 1,
+        id: `live:${runId}`,
+        generatedAt: latestGeneratedAt,
+        nodes: nodeList,
+        edges: edgeList,
+        summary: {
+            nodeCount: nodeList.length,
+            edgeCount: edgeList.length,
+            decisionCount: nodeList.filter((node) => normalized(node.kind) === 'decision').length,
+            gateCount: nodeList.filter((node) => normalized(node.kind) === 'gate').length
+        }
+    };
+}
+function mergeDashboardRunGraphNode(left, right) {
+    return {
+        ...left,
+        ...right,
+        data: {
+            ...recordValue(left.data),
+            ...recordValue(right.data)
+        }
+    };
+}
+function activeRunGraphFallback(cwd, runDir, jobs, now, warning) {
+    if (!jobs.length)
+        return undefined;
+    const nodes = [];
+    const edges = [];
+    for (const job of jobs) {
+        const jobId = textValue(job.id ?? job.jobId, 'job');
+        const jobNodeId = `job:${jobId}`;
+        nodes.push({
+            id: jobNodeId,
+            kind: 'job',
+            label: textValue(job.title ?? jobId, jobId),
+            jobId,
+            taskId: textValue(job.taskId, ''),
+            lane: textValue(job.lane, ''),
+            status: textValue(job.status, ''),
+            generatedAt: numberValue(job.generatedAt) || now
+        });
+        if (textValue(job.status, '') !== 'running') {
+            const decisionNodeId = `decision:terminal:${jobId}`;
+            nodes.push({
+                id: decisionNodeId,
+                kind: 'decision',
+                label: textValue(job.status, 'terminal'),
+                jobId,
+                taskId: textValue(job.taskId, ''),
+                lane: textValue(job.lane, ''),
+                status: textValue(job.status, ''),
+                outcome: textValue(job.disposition ?? job.mergeReadiness ?? job.status, ''),
+                generatedAt: numberValue(job.finishedAt) || numberValue(job.generatedAt) || now
+            });
+            edges.push({
+                id: `decides:${decisionNodeId}->${jobNodeId}`,
+                kind: 'decides',
+                from: decisionNodeId,
+                to: jobNodeId
+            });
+        }
+    }
+    return summarizeDashboardRunGraph({
+        kind: 'frontier.swarm-codex.run-graph',
+        version: 1,
+        id: `active-pid:${path.basename(runDir)}`,
+        generatedAt: now,
+        nodes,
+        edges,
+        summary: {
+            nodeCount: nodes.length,
+            edgeCount: edges.length,
+            decisionCount: nodes.filter((node) => normalized(node.kind) === 'decision').length,
+            gateCount: 0
+        }
+    }, {
+        sourceFile: path.relative(cwd, path.join(runDir, LIVE_RUN_GRAPH_EVENTS_FILE)).replaceAll(path.sep, '/'),
+        sourceKind: 'active-pid-fallback',
+        sourceStatus: 'live',
+        graphMissing: true,
+        graphMissingWarnings: [warning]
+    });
+}
 async function activeRunJob(cwd, runDir, entry, planJob, now, readOptions = {}) {
     const jobId = textValue(entry.jobId, 'job');
     const jobDir = path.join(runDir, jobId);
@@ -2537,6 +4005,8 @@ async function activeRunJob(cwd, runDir, entry, planJob, now, readOptions = {})
     const commandEvidence = commandEvidenceFromRecords(merge, evidenceRecord);
     return withRecomputedCostFields({
         id: jobId,
+        jobId,
+        originalJobId: jobId,
         taskId: textValue(planJob?.taskId ?? task.id, jobId),
         title: textValue(planJob?.title ?? task.title, jobId),
         lane: textValue(planJob?.lane ?? task.lane, 'active-run'),
@@ -2650,7 +4120,7 @@ function mergeActiveRunJobTelemetry(jobs, activeJobs) {
         return jobs;
     const byKey = new Map();
     for (const activeJob of activeJobs) {
-        if (!hasTokenTelemetry(activeJob))
+        if (!hasActiveRunJobState(activeJob))
             continue;
         for (const key of jobTelemetryKeys(activeJob))
             byKey.set(key, activeJob);
@@ -2666,6 +4136,7 @@ function mergeActiveRunJobTelemetry(jobs, activeJobs) {
             return record;
         return {
             ...record,
+            ...activeRunJobStateFields(activeJob),
             ...(numberValue(activeJob.actualInputTokens) ? { actualInputTokens: numberValue(activeJob.actualInputTokens) } : {}),
             ...(numberValue(activeJob.inputTokens) ? { inputTokens: numberValue(activeJob.inputTokens) } : {}),
             ...(numberValue(activeJob.estimatedInputTokens) ? { estimatedInputTokens: numberValue(activeJob.estimatedInputTokens) } : {}),
@@ -2681,6 +4152,31 @@ function mergeActiveRunJobTelemetry(jobs, activeJobs) {
         };
     });
 }
+function hasActiveRunJobState(job) {
+    return hasTokenTelemetry(job)
+        || Boolean(textValue(job.status, ''))
+        || stringArray(job.evidencePaths).length > 0
+        || stringArray(job.changedPaths).length > 0
+        || Boolean(textValue(job.patchPath, ''));
+}
+function activeRunJobStateFields(job) {
+    const evidencePaths = stringArray(job.evidencePaths);
+    const changedPaths = stringArray(job.changedPaths);
+    const artifactPaths = stringArray(job.artifactPaths);
+    return {
+        ...(textValue(job.status, '') ? { status: textValue(job.status, '') } : {}),
+        ...(textValue(job.bucket, '') ? { bucket: textValue(job.bucket, '') } : {}),
+        ...(textValue(job.disposition, '') ? { disposition: textValue(job.disposition, '') } : {}),
+        ...(textValue(job.mergeReadiness, '') ? { mergeReadiness: textValue(job.mergeReadiness, '') } : {}),
+        ...(textValue(job.patchPath, '') ? { patchPath: textValue(job.patchPath, '') } : {}),
+        ...(artifactPaths.length ? { artifactPaths: uniquePaths([...artifactPaths, ...stringArray(job.artifactPaths)]) } : {}),
+        ...(changedPaths.length ? { changedPaths, changedPathCount: changedPaths.length } : {}),
+        ...(evidencePaths.length ? { evidencePaths, evidencePathCount: evidencePaths.length } : {}),
+        ...(numberValue(job.commandsPassed) ? { commandsPassed: numberValue(job.commandsPassed) } : {}),
+        ...(numberValue(job.commandsFailed) ? { commandsFailed: numberValue(job.commandsFailed) } : {}),
+        ...(stringArray(job.collectReasonClasses).length ? { collectReasonClasses: stringArray(job.collectReasonClasses) } : {})
+    };
+}
 function jobTelemetryKeys(job) {
     return Array.from(new Set([
         textValue(job.id, ''),
@@ -2833,9 +4329,10 @@ async function readJsonFile(file) {
     }
 }
 function withRecomputedCostFields(record) {
+    const sourceRecord = withSourceOutputState(record);
     const model = textValue(record.model ?? record.pricingModel ?? record.pricingMatchedModel, '');
     if (!model || !hasCostTokenEvidence(record))
-        return record;
+        return sourceRecord;
     const cost = estimateCodexModelCost({
         model,
         estimatedInputTokens: firstCostTokenNumber(record.estimatedInputTokens, record.estimated_input_tokens),
@@ -2845,7 +4342,7 @@ function withRecomputedCostFields(record) {
         outputTokens: optionalCostTokenNumber(record.actualOutputTokens, record.outputTokens, record.completionTokens, record.responseTokens, record.actual_output_tokens, record.output_tokens, record.completion_tokens, record.response_tokens)
     });
     return {
-        ...record,
+        ...sourceRecord,
         billableInputTokens: cost.billableInputTokens,
         priceKnown: cost.priceKnown,
         ...(cost.pricingModel ? { pricingModel: cost.pricingModel } : {}),
@@ -2865,6 +4362,89 @@ function withRecomputedCostFields(record) {
         ...(cost.unknownPricingReason ? { unknownPricingReason: cost.unknownPricingReason } : { unknownPricingReason: undefined })
     };
 }
+function withSourceOutputState(record) {
+    if (textValue(record.sourceOutputState, ''))
+        return record;
+    const summary = sourceOutputSummary(record);
+    if (!summary.state)
+        return record;
+    return {
+        ...record,
+        sourceOutputState: summary.state,
+        sourceOutputLabel: summary.label,
+        sourceOutputDetail: summary.detail
+    };
+}
+function sourceOutputSummary(record) {
+    const changedPathCount = numberValue(record.changedPathCount) || stringArray(record.changedPaths).length;
+    const evidencePathCount = numberValue(record.evidencePathCount) || stringArray(record.evidencePaths).length;
+    const hasPatch = sourceOutputHasPatchArtifact(record);
+    const signals = sourceOutputSignals(record);
+    const recoveryStatus = sourceOutputRecoveryStatus(record);
+    const workspaceRecovery = Boolean(recoveryStatus) || signals.some((signal) => signal.includes('collector-workspace-only-recovery'));
+    const failedPatch = recoveryStatus === 'failed-patch'
+        || signals.some((signal) => signal.includes('collector-workspace-only-recovery-failed-patch') || signal === 'empty patch' || signal === 'empty-patch');
+    if (failedPatch)
+        return {
+            state: 'recovered-patch-failed',
+            label: changedPathCount ? `${changedPathCount} ${changedPathCount === 1 ? 'path' : 'paths'}, patch failed` : 'patch generation failed',
+            detail: changedPathCount
+                ? 'Source changed, but recovered patch generation failed.'
+                : 'Patch generation failed before a source diff could be attached.'
+        };
+    if (workspaceRecovery && (hasPatch || changedPathCount))
+        return {
+            state: 'recovered-patch',
+            label: changedPathCount ? `${changedPathCount} recovered ${changedPathCount === 1 ? 'path' : 'paths'}` : 'recovered patch',
+            detail: changedPathCount
+                ? 'Source changed and the collector recovered a patch from the worker workspace.'
+                : 'The collector recovered a patch, but changed paths are not indexed yet.'
+        };
+    if (!changedPathCount && hasPatch)
+        return {
+            state: 'patch-unindexed',
+            label: 'patch not indexed yet',
+            detail: 'A patch artifact exists, but changed paths are not indexed yet.'
+        };
+    if (!changedPathCount && evidencePathCount)
+        return {
+            state: 'evidence-only',
+            label: 'evidence only',
+            detail: 'No source files changed; this task produced evidence only.'
+        };
+    if (!changedPathCount)
+        return {
+            state: 'no-source-files',
+            label: 'no source files',
+            detail: 'No source files are reported for this task.'
+        };
+    return { state: '', label: '', detail: '' };
+}
+function sourceOutputSignals(record) {
+    return uniquePaths([
+        ...stringArray(record.collectReasonClasses),
+        ...stringArray(record.reasons),
+        ...stringArray(record.semanticReadinessReasons),
+        textValue(record.disposition, ''),
+        textValue(record.mergeReadiness, ''),
+        textValue(record.status, '')
+    ].map(normalized));
+}
+function sourceOutputRecoveryStatus(record) {
+    const metadata = recordValue(record.metadata);
+    const swarmCodex = recordValue(metadata.frontierSwarmCodex);
+    const workspaceOnly = recordValue(swarmCodex.workspaceOnlyCollection);
+    return normalized(workspaceOnly.recoveryStatus);
+}
+function sourceOutputHasPatchArtifact(record) {
+    const paths = [
+        textValue(record.patchPath, ''),
+        textValue(record.patchArtifactPath, ''),
+        ...stringArray(record.artifactPaths),
+        ...stringArray(record.evidencePaths)
+    ];
+    return paths.some((entry) => /\.patch(?:$|[?#])/.test(entry));
+}
 function hasCostTokenEvidence(record) {
     return [
         record.actualInputTokens,
@@ -3174,30 +4754,59 @@ function rawRunJobIdMatches(requestedId, jobId) {
     return requestedId === jobId || requestedId.endsWith(`:${jobId}`) || requestedId.endsWith(`-${jobId}`);
 }
 async function findCollectionBundle(options, jobId) {
-    const collectionFile = await resolveArtifactFile(options.cwd, options.collection, ['collection.json', 'coordinator-query.json']);
-    if (!collectionFile)
-        return undefined;
-    const collection = JSON.parse(await fs.readFile(collectionFile, 'utf8'));
-    const buckets = recordValue(collection.buckets);
-    for (const entries of Object.values(buckets)) {
-        if (!Array.isArray(entries))
-            continue;
-        for (const entry of entries) {
-            const row = recordValue(entry);
-            const bundle = recordValue(row.bundle);
-            if (textValue(row.jobId, '') === jobId || textValue(bundle.jobId, '') === jobId) {
-                return { bundle, outputDir: textValue(row.outputDir, '') };
+    const requestedIds = new Set([jobId, unscopedLifetimeTaskKey(jobId)]);
+    for (const collectionFile of await collectionBundleLookupFiles(options)) {
+        const collection = JSON.parse(await fs.readFile(collectionFile, 'utf8'));
+        const defaultOutputDir = textValue(collection.outDir, '') || path.dirname(collectionFile);
+        const buckets = recordValue(collection.buckets);
+        for (const entries of Object.values(buckets)) {
+            if (!Array.isArray(entries))
+                continue;
+            for (const entry of entries) {
+                const row = recordValue(entry);
+                const bundle = recordValue(row.bundle);
+                const ids = [textValue(row.jobId, ''), textValue(bundle.jobId, ''), textValue(bundle.taskId, '')].filter(Boolean);
+                if (ids.some((id) => requestedIds.has(id) || requestedIds.has(unscopedLifetimeTaskKey(id)))) {
+                    return { bundle, outputDir: textValue(row.outputDir, '') || defaultOutputDir };
+                }
+            }
+        }
+        const jobs = Array.isArray(collection.jobs) ? collection.jobs : [];
+        for (const job of jobs) {
+            const row = recordValue(job);
+            const ids = [textValue(row.id ?? row.jobId, ''), textValue(row.originalJobId, ''), textValue(row.taskId, '')].filter(Boolean);
+            if (ids.some((id) => requestedIds.has(id) || requestedIds.has(unscopedLifetimeTaskKey(id)))) {
+                return { bundle: row, outputDir: textValue(row.outputDir, '') || defaultOutputDir };
             }
         }
-    }
-    const jobs = Array.isArray(collection.jobs) ? collection.jobs : [];
-    for (const job of jobs) {
-        const row = recordValue(job);
-        if (textValue(row.id ?? row.jobId, '') === jobId)
-            return { bundle: row, outputDir: textValue(row.outputDir, '') };
     }
     return undefined;
 }
+async function collectionBundleLookupFiles(options) {
+    const direct = await resolveArtifactFile(options.cwd, options.collection, ['collection.json', 'coordinator-query.json']);
+    if (direct)
+        return [direct];
+    const out = [];
+    for (const source of await discoverLifetimeDashboardSources(options.cwd)) {
+        if (source.kind !== 'collection' || !source.collection)
+            continue;
+        const root = path.resolve(options.cwd, source.collection);
+        if (!isPathInside(options.cwd, root))
+            continue;
+        const stat = await fs.lstat(root).catch(() => undefined);
+        if (!stat)
+            continue;
+        const candidates = stat.isDirectory()
+            ? [path.join(root, 'collection.json'), path.join(root, 'coordinator-query.json')]
+            : [root];
+        for (const candidate of candidates) {
+            const candidateStat = await fs.stat(candidate).catch(() => undefined);
+            if (candidateStat?.isFile())
+                out.push(candidate);
+        }
+    }
+    return uniquePaths(out);
+}
 async function resolveArtifactFile(cwd, input, names) {
     if (!input)
         return undefined;
@@ -3236,13 +4845,13 @@ async function writeHumanActionAnswer(options, body) {
         source: 'frontier-loom-ui'
     };
     await fs.appendFile(answerPath, JSON.stringify(record) + '\n', 'utf8');
-    notifyDashboardStreams();
+    notifyDashboardStreams({ humanActionAnswer: record, answerPath });
     return { ok: true, code, answerPath };
 }
-function notifyDashboardStreams() {
+function notifyDashboardStreams(hint) {
     invalidateDashboardSnapshotCache();
     for (const listener of dashboardStreamListeners)
-        listener();
+        listener(hint);
 }
 async function readHumanActionAnswers(options) {
     const answerPath = await humanActionAnswerLogPath(options);
@@ -3714,6 +5323,10 @@ function writeJson(response, status, value) {
     response.writeHead(status, responseHeaders('application/json; charset=utf-8'));
     response.end(JSON.stringify(value, null, 2));
 }
+function serveFavicon(response) {
+    response.writeHead(200, responseHeaders('image/svg+xml; charset=utf-8'));
+    response.end('<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 16 16"><rect width="16" height="16" rx="4" fill="#0b0d0f"/><path d="M4 5h8v2H6v2h5v2H4z" fill="#d6d9de"/></svg>');
+}
 async function readJsonBody(request, maxBytes) {
     let bytes = 0;
     const chunks = [];
@@ -3737,7 +5350,11 @@ function responseHeaders(contentType) {
     };
 }
 function resolveFrontierDomRuntime() {
-    return path.join(packageDir, '..', 'node_modules', '@shapeshift-labs', 'frontier-dom', 'dist', 'jsx-runtime.js');
+    const candidates = [
+        path.join(packageDir, '..', 'node_modules', '@shapeshift-labs', 'frontier-dom', 'dist', 'jsx-runtime.js'),
+        path.join(packageDir, '..', '..', 'frontier-dom', 'dist', 'jsx-runtime.js')
+    ];
+    return candidates.find((candidate) => existsSync(candidate)) ?? candidates[0];
 }
 function contentType(file) {
     if (file.endsWith('.js'))