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

package/dist/client.js

@@ -2,6 +2,7 @@ import { jsx as _jsx, jsxs as _jsxs } from "@shapeshift-labs/frontier-dom/jsx-ru
 const contentTabs = [
     { id: 'work', label: 'Overview' },
     { id: 'board', label: 'Board' },
+    { id: 'running', label: 'Running' },
     { id: 'swarm', label: 'Swarm' },
     { id: 'lanes', label: 'Lanes' },
     { id: 'performance', label: 'Performance' },
@@ -18,6 +19,7 @@ let renderedDashboardSignature;
 let pendingFocusTab;
 let selectedTaskCardId = initialRoute.taskId;
 let selectedTicketId = initialRoute.ticket;
+let runningGraphFilter = { lane: 'all', task: 'all' };
 let chartPopover;
 let activeContributionTarget;
 const taskDetailsCache = new Map();
@@ -56,6 +58,24 @@ root?.addEventListener('click', (event) => {
         closeTaskDialog();
         return;
     }
+    const runningFilter = event.target instanceof Element
+        ? event.target.closest('[data-running-filter-kind]')
+        : null;
+    if (runningFilter) {
+        event.preventDefault();
+        event.stopPropagation();
+        const kind = runningFilter.dataset.runningFilterKind;
+        const value = runningFilter.dataset.runningFilterValue || 'all';
+        if (kind === 'lane') {
+            runningGraphFilter = { lane: value, task: 'all' };
+        }
+        else if (kind === 'task') {
+            runningGraphFilter = { ...runningGraphFilter, task: value };
+        }
+        if (currentDashboard)
+            renderDashboard(currentDashboard);
+        return;
+    }
     const tab = event.target instanceof Element
         ? event.target.closest('[data-content-tab]')
         : null;
@@ -272,6 +292,7 @@ function dashboardSignature(dashboard) {
         events: dashboard.events,
         routing: dashboard.routing,
         backlog: dashboard.backlog,
+        capacity: dashboard.capacity,
         semantic: dashboard.semantic,
         sources: dashboard.sources
     });
@@ -309,6 +330,10 @@ function contentPanel(tab, input) {
         return _jsx(Panel, { title: "Overview", meta: `${text(input.visibleJobs.length)} tasks`, hideHead: true, children: _jsx(WorkOverview, { dashboard: input.dashboard, lanes: input.lanes, jobs: input.visibleJobs, attention: input.attention, audit: input.audit, success: input.success }) });
     if (tab === 'board')
         return _jsx(Panel, { title: "Task board", meta: boardPanelMeta(input.dashboard, boardItems, input.visibleJobs), children: _jsx(TaskBoard, { dashboard: input.dashboard, jobs: input.visibleJobs }) });
+    if (tab === 'running') {
+        const activeCount = activeAgentTaskCount(input.dashboard, input.visibleJobs);
+        return _jsx(Panel, { title: "Running graph", meta: activeCount ? `${text(activeCount)} active tasks` : 'none running', children: _jsx(RunningGraphView, { dashboard: input.dashboard, jobs: input.visibleJobs }) });
+    }
     if (tab === 'swarm') {
         const sourceKind = dashboardSourceKind(input.dashboard);
         const activeCount = activeAgentTaskCount(input.dashboard, input.visibleJobs);
@@ -424,6 +449,204 @@ function TaskBoard({ dashboard, jobs }) {
                             ? column.items.map((job) => _jsx(TaskBoardCard, { job: job }))
                             : _jsx("p", { className: "empty tight", children: column.empty }) })] })) }) });
 }
+function RunningGraphView({ dashboard, jobs }) {
+    const graph = buildRunningGraph(dashboard, jobs, runningGraphFilter);
+    return _jsxs("div", { className: "running-layout", "data-scroll-id": "running", "data-smoke-marker": "running-tab", children: [_jsxs("section", { className: "running-filters", "aria-label": "Running graph filters", children: [_jsxs("div", { className: "running-filter-group", children: [_jsx("span", { children: "Scope" }), _jsxs("div", { children: [_jsx(RunningFilterButton, { kind: "lane", value: "all", active: graph.filter.lane === 'all', label: `Global · ${text(graph.totalActiveJobCount)}` }), graph.laneOptions.map((lane) => _jsx(RunningFilterButton, { kind: "lane", value: lane.id, active: graph.filter.lane === lane.id, label: `${lane.label} · ${text(lane.count)}` }))] })] }), _jsxs("div", { className: "running-filter-group", children: [_jsx("span", { children: "Tasks" }), _jsxs("div", { children: [_jsx(RunningFilterButton, { kind: "task", value: "all", active: graph.filter.task === 'all', label: "All active" }), graph.taskOptions.map((task) => _jsx(RunningFilterButton, { kind: "task", value: task.id, active: graph.filter.task === task.id, label: `${task.ticket} · ${task.label}` }))] })] })] }), _jsxs("section", { className: "work-section running-graph-section", children: [_jsxs("div", { className: "metric-section-head", children: [_jsx("h3", { children: "Live execution graph" }), _jsxs("span", { children: [text(graph.activeAgentCount), " agents \u00B7 ", text(graph.activeJobCount), " active tasks"] })] }), _jsx(RunningGraphCanvas, { graph: graph })] })] });
+}
+function RunningFilterButton({ kind, value, active, label }) {
+    return _jsx("button", { type: "button", className: active ? 'running-filter active' : 'running-filter', "data-running-filter-kind": kind, "data-running-filter-value": value, children: label });
+}
+function RunningGraphCanvas({ graph }) {
+    if (!graph.activeJobCount)
+        return _jsx("p", { className: "empty tight", children: "No active jobs are running right now." });
+    return _jsx("div", { className: "running-graph-viewport", "data-scroll-id": "running-graph-viewport", "aria-label": "Current running swarm graph", children: _jsxs("div", { className: "running-graph-canvas", style: `width:${graph.width}px; height:${graph.height}px`, children: [_jsx("svg", { className: "running-graph-svg", viewBox: `0 0 ${graph.width} ${graph.height}`, width: graph.width, height: graph.height, "aria-hidden": "true", children: graph.edges.map((edge) => _jsx("path", { className: `running-edge ${edge.tone}`, d: edge.path })) }), graph.nodes.map((node) => _jsx(RunningGraphNodeView, { node: node }))] }) });
+}
+function RunningGraphNodeView({ node }) {
+    const style = `left:${node.x}px; top:${node.y}px; width:${node.width}px; height:${node.height}px; --node-color:${node.color ?? 'var(--line-strong)'}`;
+    if (node.taskCardId)
+        return _jsx("button", { type: "button", className: `running-node ${node.kind} ${node.tone}`, style: style, "data-task-card": node.taskCardId, "aria-label": `${node.label}: ${node.detail}. ${node.meta}`, children: _jsx(RunningGraphNodeContent, { node: node }) });
+    return _jsx("article", { className: `running-node ${node.kind} ${node.tone}`, style: style, "aria-label": `${node.label}: ${node.detail}. ${node.meta}`, children: _jsx(RunningGraphNodeContent, { node: node }) });
+}
+function RunningGraphNodeContent({ node }) {
+    return _jsxs("div", { className: "running-node-inner", children: [_jsx("span", { children: node.kind }), _jsx("b", { children: node.label }), _jsx("small", { children: node.detail }), _jsx("em", { children: node.meta })] });
+}
+function buildRunningGraph(dashboard, jobs, filter) {
+    const now = timeValue(dashboard.generatedAt) ?? Date.now();
+    const activeItems = taskBoardItems(dashboard, jobs).filter(isActiveAgentJob);
+    const laneCounts = runningLaneCounts(activeItems);
+    const laneOptions = Array.from(laneCounts.entries())
+        .map(([id, count]) => ({ id, label: laneDisplayLabel(id), count }))
+        .sort((left, right) => right.count - left.count || left.label.localeCompare(right.label));
+    const laneFilter = filter.lane !== 'all' && laneCounts.has(filter.lane) ? filter.lane : 'all';
+    const laneScopedItems = laneFilter === 'all'
+        ? activeItems
+        : activeItems.filter((job) => laneOf(job) === laneFilter);
+    const taskOptions = laneScopedItems
+        .map((job) => ({ id: taskCardId(job), label: taskTitle(job), ticket: ticketId(job), lane: laneOf(job) }))
+        .sort((left, right) => left.ticket.localeCompare(right.ticket));
+    const taskIds = new Set(taskOptions.map((task) => task.id));
+    const taskFilter = filter.task !== 'all' && taskIds.has(filter.task) ? filter.task : 'all';
+    const scopedItems = taskFilter === 'all'
+        ? laneScopedItems
+        : laneScopedItems.filter((job) => taskCardId(job) === taskFilter);
+    const dimensions = {
+        source: { x: 28, width: 196, height: 92 },
+        lane: { x: 276, width: 220, height: 92 },
+        agent: { x: 560, width: 286, height: 104 },
+        task: { x: 918, width: 430, height: 112 },
+        rowHeight: 148,
+        paddingY: 38,
+        groupGap: 40
+    };
+    const nodes = [];
+    const laneNodes = [];
+    const agentNodes = [];
+    const taskNodes = [];
+    const edges = [];
+    let yCursor = dimensions.paddingY;
+    const laneIds = uniqueStrings(scopedItems.map(laneOf)).sort((left, right) => laneDisplayLabel(left).localeCompare(laneDisplayLabel(right)));
+    for (const laneId of laneIds) {
+        const laneJobs = scopedItems.filter((job) => laneOf(job) === laneId);
+        const workers = agentWorkers(laneJobs);
+        const laneStartY = yCursor;
+        let laneRows = 0;
+        workers.forEach((worker, workerIndex) => {
+            const workerJobs = worker.currentJobs.length ? worker.currentJobs : worker.jobs;
+            const workerStartRow = laneRows;
+            workerJobs.forEach((job) => {
+                const y = laneStartY + laneRows * dimensions.rowHeight;
+                taskNodes.push({
+                    id: `task:${taskCardId(job)}`,
+                    kind: 'task',
+                    label: taskTitle(job),
+                    detail: `${ticketId(job)} · ${taskCardStatus(job)}`,
+                    meta: `${agentModelLabel(job)} · ${jobRuntimeLabel(job, now)}`,
+                    x: dimensions.task.x,
+                    y,
+                    width: dimensions.task.width,
+                    height: dimensions.task.height,
+                    tone: 'good',
+                    taskCardId: taskCardId(job)
+                });
+                laneRows += 1;
+            });
+            const workerRowCount = Math.max(1, workerJobs.length);
+            const workerY = laneStartY
+                + workerStartRow * dimensions.rowHeight
+                + ((workerRowCount - 1) * dimensions.rowHeight) / 2;
+            agentNodes.push({
+                id: `agent:${laneId}:${worker.key}`,
+                kind: 'agent',
+                label: agentDisplayName(worker, workerIndex),
+                detail: `${agentModelSummary(worker)} · ${agentRuntimeValue(worker, now)}`,
+                meta: `${text(workerJobs.length)} ${workerJobs.length === 1 ? 'task' : 'tasks'} · ${agentTokenValue(worker)} input`,
+                x: dimensions.agent.x,
+                y: workerY,
+                width: dimensions.agent.width,
+                height: dimensions.agent.height,
+                tone: 'neutral',
+                color: worker.color
+            });
+        });
+        const safeLaneRows = Math.max(1, laneRows);
+        const laneY = laneStartY + ((safeLaneRows - 1) * dimensions.rowHeight) / 2;
+        laneNodes.push({
+            id: `lane:${laneId}`,
+            kind: 'lane',
+            label: laneDisplayLabel(laneId),
+            detail: `${text(laneJobs.length)} active ${laneJobs.length === 1 ? 'task' : 'tasks'}`,
+            meta: laneModelSummary(laneJobs),
+            x: dimensions.lane.x,
+            y: laneY,
+            width: dimensions.lane.width,
+            height: dimensions.lane.height,
+            tone: 'neutral'
+        });
+        yCursor += safeLaneRows * dimensions.rowHeight + dimensions.groupGap;
+    }
+    const height = Math.max(360, yCursor + dimensions.paddingY - dimensions.groupGap);
+    const width = dimensions.task.x + dimensions.task.width + 32;
+    const activeAgentCount = agentNodes.length;
+    const sourceKind = dashboardSourceKind(dashboard);
+    const sourceNode = {
+        id: 'source:global',
+        kind: 'source',
+        label: sourceKind === 'lifetime' ? 'Global swarm' : 'Current swarm',
+        detail: sourceKind === 'lifetime' ? 'Workspace lifetime' : 'Active run',
+        meta: `${text(activeAgentCount)} agents · ${text(scopedItems.length)} active tasks`,
+        x: dimensions.source.x,
+        y: Math.max(dimensions.paddingY, height / 2 - dimensions.source.height / 2),
+        width: dimensions.source.width,
+        height: dimensions.source.height,
+        tone: 'neutral'
+    };
+    nodes.push(sourceNode, ...laneNodes, ...agentNodes, ...taskNodes);
+    const byId = new Map(nodes.map((node) => [node.id, node]));
+    for (const lane of laneNodes) {
+        edges.push(runningGraphEdge(sourceNode, lane, 'neutral'));
+        const laneId = lane.id.slice('lane:'.length);
+        for (const agent of agentNodes.filter((node) => node.id.startsWith(`agent:${laneId}:`))) {
+            edges.push(runningGraphEdge(lane, agent, 'neutral'));
+            const workerKey = agent.id.slice(`agent:${laneId}:`.length);
+            const workerJobs = scopedItems.filter((job) => laneOf(job) === laneId && agentIdentityKey(job) === workerKey);
+            for (const job of workerJobs) {
+                const taskNode = byId.get(`task:${taskCardId(job)}`);
+                if (taskNode)
+                    edges.push(runningGraphEdge(agent, taskNode, 'good'));
+            }
+        }
+    }
+    return {
+        nodes,
+        edges,
+        laneOptions,
+        taskOptions,
+        filter: { lane: laneFilter, task: taskFilter },
+        width,
+        height,
+        totalActiveJobCount: activeItems.length,
+        activeJobCount: scopedItems.length,
+        activeAgentCount
+    };
+}
+function runningLaneCounts(jobs) {
+    const counts = new Map();
+    for (const job of jobs) {
+        const lane = laneOf(job);
+        counts.set(lane, (counts.get(lane) ?? 0) + 1);
+    }
+    return counts;
+}
+function laneDisplayLabel(id) {
+    if (!id || id === 'unassigned')
+        return 'Unassigned';
+    return sentenceCaseIdentifier(id);
+}
+function laneModelSummary(jobs) {
+    const models = uniqueStrings(jobs.map(agentModelLabel).filter((model) => model !== 'model unknown'));
+    if (!models.length)
+        return 'model unknown';
+    if (models.length === 1)
+        return models[0];
+    return `${models.slice(0, 2).join(' + ')}${models.length > 2 ? ` +${models.length - 2}` : ''}`;
+}
+function runningGraphEdge(from, to, tone) {
+    return {
+        id: `${from.id}->${to.id}`,
+        from: from.id,
+        to: to.id,
+        path: runningGraphEdgePath(from, to),
+        tone
+    };
+}
+function runningGraphEdgePath(from, to) {
+    const x1 = from.x + from.width;
+    const y1 = from.y + from.height / 2;
+    const x2 = to.x;
+    const y2 = to.y + to.height / 2;
+    const curve = Math.max(38, Math.min(120, (x2 - x1) / 2));
+    return `M ${x1} ${y1} C ${x1 + curve} ${y1}, ${x2 - curve} ${y2}, ${x2} ${y2}`;
+}
 function AgentWork({ dashboard, jobs }) {
     const items = taskBoardItems(dashboard, jobs).filter(isActiveAgentJob);
     const workers = agentWorkers(items);
@@ -521,7 +744,7 @@ function AgentWorkerCard({ worker, index, now }) {
     const model = agentModelSummary(worker);
     const files = agentTouchedFiles(worker);
     const evidenceCount = agentEvidenceCount(worker);
-    const fileFallback = evidenceCount ? 'Evidence only' : worker.status === 'active' ? 'Files pending' : 'No source files';
+    const fileFallback = agentFileFallback(worker, evidenceCount);
     const visibleJobs = worker.currentJobs.slice(0, 2);
     const hiddenJobCount = Math.max(0, worker.currentJobs.length - visibleJobs.length);
     return _jsxs("article", { className: `agent-worker-card ${worker.status}`, style: `--agent-color:${worker.color}`, draggable: "false", "aria-label": `${agentDisplayName(worker, index)} assigned to ${text(worker.currentJobs.length)} current tasks`, children: [_jsxs("div", { className: "agent-cell agent-cell-agent", children: [_jsx("span", { className: "agent-status-dot", "aria-hidden": "true" }), _jsxs("div", { children: [_jsx("b", { children: agentDisplayName(worker, index) }), _jsx("small", { children: agentStatusLabel(worker.status) })] })] }), _jsx("div", { className: "agent-cell agent-cell-task", children: _jsxs("div", { className: "agent-task-list", children: [visibleJobs.map((job) => _jsxs("button", { type: "button", className: "agent-task-row", "data-task-card": taskCardId(job), children: [_jsx("code", { children: ticketId(job) }), _jsx("span", { children: taskTitle(job) }), _jsx("small", { children: jobRuntimeLabel(job, now) })] })), hiddenJobCount ? _jsxs("small", { className: "agent-overflow-note", children: ["+", text(hiddenJobCount), " more active ", hiddenJobCount === 1 ? 'ticket' : 'tickets'] }) : null] }) }), _jsx("div", { className: "agent-cell agent-cell-model", children: _jsx("span", { className: "agent-model-pill", children: _jsx("span", { children: model }) }) }), _jsxs("div", { className: "agent-cell agent-cell-runtime", children: [_jsx("b", { children: agentRuntimeValue(worker, now) }), _jsx("small", { children: worker.currentJobs.length === 1 ? 'current ticket' : `${text(worker.currentJobs.length)} tickets` })] }), _jsxs("div", { className: "agent-cell agent-cell-cost", children: [_jsx("b", { children: agentTokenValue(worker) }), _jsxs("small", { children: [agentUncachedTokenValue(worker), " uncached"] })] }), _jsxs("div", { className: "agent-cell agent-cell-files", children: [_jsxs("div", { className: "agent-file-list", children: [files.slice(0, 2).map((file) => _jsx(ArtifactLink, { path: file, label: artifactLabel(file), className: "agent-file-tag" })), files.length > 2 ? _jsxs("span", { className: "agent-file-more", children: ["+", text(files.length - 2)] }) : null, !files.length ? _jsx("span", { className: "agent-file-empty", children: fileFallback }) : null] }), evidenceCount ? _jsxs("small", { children: [text(evidenceCount), " evidence ", evidenceCount === 1 ? 'artifact' : 'artifacts'] }) : null] })] });
@@ -552,8 +775,8 @@ function TaskFileDiffs({ job, details }) {
                         return _jsxs("details", { className: "task-file-diff", "data-task-file-diff-key": keys[0] ?? '', "data-task-file-diff-keys": keys.join('\t'), open: isTaskFileDiffOpen(job, file) ? 'open' : undefined, children: [_jsxs("summary", { children: [_jsx("span", { className: "task-file-name", children: file.path }), _jsxs("small", { children: ["+", text(file.additions), " -", text(file.deletions), file.truncated ? ' · truncated' : ''] }), _jsx(ArtifactLink, { path: file.artifactPath ?? file.path, label: "Reveal", className: "task-file-reveal" })] }), _jsx(DiffRenderer, { file: file })] });
                     }) })] });
     if (changedPaths.length)
-        return _jsxs("section", { className: "task-dialog-section", children: [_jsx("h4", { children: "Files changed" }), _jsx("p", { className: "empty tight", children: details?.error ? `Diff unavailable: ${details.error}` : 'No patch diff was available in the collected evidence.' }), _jsx(ArtifactPathList, { paths: changedPaths })] });
-    return _jsxs("section", { className: "task-dialog-section", children: [_jsx("h4", { children: "Files changed" }), _jsx("p", { className: "empty tight", children: job.boardKind === 'backlog' ? 'No files yet. This item has not produced an implementation patch.' : 'No changed files reported.' })] });
+        return _jsxs("section", { className: "task-dialog-section", children: [_jsx("h4", { children: "Files changed" }), _jsx("p", { className: "empty tight", children: fileDiffFallbackText(job, details) }), _jsx(ArtifactPathList, { paths: changedPaths })] });
+    return _jsxs("section", { className: "task-dialog-section", children: [_jsx("h4", { children: "Files changed" }), _jsx("p", { className: "empty tight", children: noChangedFilesText(job) })] });
 }
 function TaskResultDetails({ job, details }) {
     const evidenceArtifacts = artifactListFromDetails(job, details).slice(0, 10);
@@ -981,6 +1204,16 @@ function agentEvidenceCount(worker) {
         return paths.length;
     return worker.jobs.reduce((sum, job) => sum + numberValue(job.evidencePathCount), 0);
 }
+function agentFileFallback(worker, evidenceCount) {
+    const summaries = worker.jobs.map(sourceOutputSummary);
+    if (summaries.some((summary) => summary.state === 'recovered-patch-failed'))
+        return 'Patch failed';
+    if (summaries.some((summary) => summary.state === 'recovered-patch'))
+        return 'Recovered patch';
+    if (evidenceCount)
+        return 'Evidence only';
+    return worker.status === 'active' ? 'Files pending' : 'No source files';
+}
 function agentWorkerSort(left, right) {
     return agentStatusRank(agentStatus(left)) - agentStatusRank(agentStatus(right))
         || taskBoardJobSort(left, right);
@@ -1119,9 +1352,11 @@ function taskDetailSummary(job) {
 function taskMarkdownSummary(job) {
     const changed = formatNumber(numberValue(job.changedPathCount));
     const evidence = formatNumber(numberValue(job.evidencePathCount));
+    const sourceOutput = sourceOutputSummary(job);
     const reasons = taskReasonItems(job);
     const reasonText = reasons.length ? ` Main signal: ${reasons[0]}.` : '';
-    return `${taskTitle(job)} is in ${taskBoardColumnTitle(taskBoardColumnId(job)).toLowerCase()} with ${changed} changed paths and ${evidence} evidence artifacts.${reasonText}`;
+    const sourceText = sourceOutput.detail ? ` ${sourceOutput.detail}` : '';
+    return `${taskTitle(job)} is in ${taskBoardColumnTitle(taskBoardColumnId(job)).toLowerCase()} with ${changed} changed paths and ${evidence} evidence artifacts.${sourceText}${reasonText}`;
 }
 function coordinatorDecisionStatus(job) {
     return textValue(job.coordinatorDecisionStatus ?? recordValue(job.coordinatorDecision).status, '');
@@ -2433,20 +2668,124 @@ function pathSummaryText(job) {
     const changedPathCount = numberValue(job.changedPathCount);
     const evidencePathCount = numberValue(job.evidencePathCount);
     const ignoredCount = ignoredOwnership.length + ignoredChangedPathCount;
+    const sourceOutput = sourceOutputSummary(job);
     if (sourceOwnership.length)
         return `${text(sourceOwnership.length)} source issue`;
     if (quarantinedChangedPathCount)
         return `${text(quarantinedChangedPathCount)} quarantined`;
     if (ignoredCount)
         return `${text(ignoredCount)} generated noise`;
+    if (sourceOutput.state === 'recovered-patch' || sourceOutput.state === 'recovered-patch-failed')
+        return sourceOutput.label;
     if (!changedPathCount && hasPatchArtifact(job))
         return 'patch not indexed yet';
     if (!changedPathCount && evidencePathCount)
-        return 'evidence only';
+        return sourceOutput.label;
     if (!changedPathCount && isActiveAgentJob(job))
         return 'files pending';
     return `${text(changedPathCount)} changed ${changedPathCount === 1 ? 'path' : 'paths'}`;
 }
+function sourceOutputSummary(job) {
+    const explicitState = normalized(job.sourceOutputState);
+    const explicitLabel = textValue(job.sourceOutputLabel, '');
+    const explicitDetail = textValue(job.sourceOutputDetail, '');
+    if (explicitState)
+        return {
+            state: sourceOutputStateValue(explicitState),
+            label: explicitLabel || sentenceCaseIdentifier(explicitState),
+            detail: explicitDetail
+        };
+    const changedPathCount = numberValue(job.changedPathCount) || stringArray(job.changedPaths).length;
+    const evidencePathCount = numberValue(job.evidencePathCount) || stringArray(job.evidencePaths).length;
+    const hasPatch = hasPatchArtifact(job);
+    const signals = sourceOutputSignals(job);
+    const recoveryStatus = sourceOutputRecoveryStatus(job);
+    const workspaceRecovery = 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 ? `${text(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 ? `${text(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 sourceOutputStateValue(value) {
+    if (value === 'recovered-patch')
+        return 'recovered-patch';
+    if (value === 'recovered-patch-failed')
+        return 'recovered-patch-failed';
+    if (value === 'patch-unindexed')
+        return 'patch-unindexed';
+    if (value === 'evidence-only')
+        return 'evidence-only';
+    if (value === 'no-source-files')
+        return 'no-source-files';
+    return '';
+}
+function sourceOutputSignals(job) {
+    return uniqueStrings([
+        ...stringArray(job.collectReasonClasses),
+        ...stringArray(job.reasons),
+        ...stringArray(job.semanticReadinessReasons),
+        textValue(job.disposition, ''),
+        textValue(job.mergeReadiness, ''),
+        textValue(job.status, '')
+    ].map(normalized));
+}
+function sourceOutputRecoveryStatus(job) {
+    const metadata = recordValue(job.metadata);
+    const swarmCodex = recordValue(metadata.frontierSwarmCodex);
+    const workspaceOnly = recordValue(swarmCodex.workspaceOnlyCollection);
+    return normalized(workspaceOnly.recoveryStatus);
+}
+function fileDiffFallbackText(job, details) {
+    if (details?.error)
+        return `Diff unavailable: ${details.error}`;
+    const sourceOutput = sourceOutputSummary(job);
+    if (sourceOutput.state === 'recovered-patch-failed')
+        return 'Source changed, but recovered patch generation failed. Review the listed paths and evidence.';
+    if (sourceOutput.state === 'recovered-patch')
+        return 'Recovered source paths are known, but patch text is not available in the dashboard.';
+    return 'No patch diff was available in the collected evidence.';
+}
+function noChangedFilesText(job) {
+    const sourceOutput = sourceOutputSummary(job);
+    if (sourceOutput.state === 'evidence-only')
+        return 'No source files changed; this task produced evidence only.';
+    if (job.boardKind === 'backlog')
+        return 'No files yet. This item has not produced an implementation patch.';
+    return 'No changed files reported.';
+}
 function hasPatchArtifact(job) {
     const paths = [
         textValue(job.patchPath, ''),
@@ -2751,6 +3090,8 @@ function tabMeta(tab, input) {
         return `${text(input.jobs)} tasks`;
     if (tab === 'board')
         return 'AI tasks';
+    if (tab === 'running')
+        return 'live graph';
     if (tab === 'swarm')
         return 'active agents';
     if (tab === 'lanes')
@@ -4011,25 +4352,369 @@ function semanticMetrics(value) {
     const script = recordValue(edit.script);
     const replay = recordValue(input.replay);
     const admission = recordValue(input.admission);
+    const health = recordValue(input.health);
+    const parser = recordValue(health.parser);
+    const ledger = recordValue(health.ledger);
+    const merge = recordValue(health.merge);
+    const gates = recordValue(health.gates);
+    const outcomes = recordValue(health.outcomes);
+    const admissionHealth = recordValue(health.admission);
     const admissionRows = [
         ...semanticAdmissionRows(admission.jobs, 'Jobs'),
         ...semanticAdmissionRows(admission.scripts, 'Scripts')
     ];
     const metrics = {
-        expected: numberValue(imports.expectedCount),
-        satisfied: numberValue(imports.expectedSatisfiedCount),
-        candidates: numberValue(imports.candidateCount),
-        autoMerge: numberValue(script.autoMergeCandidateCount),
-        acceptedClean: numberValue(replay.acceptedCleanCount),
-        conflicts: numberValue(replay.conflictCount)
+        expected: firstNumber(imports.expectedCount, input.expected),
+        satisfied: firstNumber(imports.expectedSatisfiedCount, input.satisfied),
+        candidates: firstNumber(imports.candidateCount, input.candidates),
+        autoMerge: firstNumber(script.autoMergeCandidateCount, input.autoMerge),
+        acceptedClean: firstNumber(replay.acceptedCleanCount, input.acceptedClean),
+        conflicts: firstNumber(merge.conflictCount, replay.conflictCount, input.conflicts)
+    };
+    const admissionReasonCodeCounts = numberRecordValue(recordValue(admissionHealth.reasonCodeCounts));
+    const admissionStatusCounts = semanticAdmissionStatusCounts(admission, admissionHealth, {
+        safeMerged: Math.max(metrics.autoMerge, metrics.acceptedClean, numberValue(replay.alreadyAppliedCount), numberValue(ledger.landedCount)),
+        safeWithLosses: numberValue(admissionReasonCodeCounts['lossy-import']) || firstNumber(parser.lossCount, imports.lossCount),
+        conflict: metrics.conflicts,
+        stale: numberValue(merge.staleCount) || numberValue(admissionReasonCodeCounts['stale-source-hash']),
+        missingSidecar: numberValue(admissionReasonCodeCounts['missing-sidecar']),
+        coordinatorReview: Math.max(numberValue(merge.reviewRequiredCount), numberValue(outcomes.openCoordinatorReviewCount)),
+        testsMissing: numberValue(admissionReasonCodeCounts['tests-missing'])
+    });
+    const semanticHealth = {
+        parserLosses: firstNumber(parser.lossCount, imports.lossCount),
+        parserWarnings: firstNumber(parser.warningCount, imports.warningCount),
+        ledgerFailed: numberValue(ledger.failedCount),
+        ledgerSkipped: numberValue(ledger.skippedCount),
+        ledgerLanded: numberValue(ledger.landedCount),
+        autoMergeCandidates: firstNumber(merge.autoMergeCandidateCount, metrics.autoMerge),
+        reviewRequired: numberValue(merge.reviewRequiredCount),
+        conflicts: metrics.conflicts,
+        gateStatus: textValue(gates.status, 'unknown'),
+        gatePassed: numberValue(gates.passedCount),
+        gateWarnings: numberValue(gates.warningCount),
+        gateFailed: numberValue(gates.failedCount),
+        synthesizedResearchComplete: numberValue(outcomes.synthesizedResearchCompleteCount),
+        openCoordinatorReview: numberValue(outcomes.openCoordinatorReviewCount),
+        admissionStatusCounts,
+        admissionReasonCodeCounts,
+        reasonCodes: uniqueStrings([
+            ...stringArray(parser.expectedMissingReasonCodes),
+            ...stringArray(merge.reasonCodes),
+            ...stringArray(gates.reasonCodes)
+        ]).slice(0, 6)
     };
     return {
         ...metrics,
-        total: metrics.expected + metrics.satisfied + metrics.candidates + metrics.autoMerge + metrics.acceptedClean + metrics.conflicts,
+        total: metrics.expected + metrics.satisfied + metrics.candidates + metrics.autoMerge + metrics.acceptedClean + metrics.conflicts +
+            semanticHealth.parserLosses + semanticHealth.reviewRequired,
         admissionRows,
-        admissionTotal: admissionRows.reduce((sum, row) => sum + row.value, 0)
+        admissionTotal: admissionRows.reduce((sum, row) => sum + row.value, 0),
+        health: semanticHealth
+    };
+}
+function decisionGraphSummary(dashboard) {
+    const graph = recordValue(dashboard.graph ?? recordValue(dashboard.summary).graph);
+    const nodeCount = numberValue(graph.nodeCount);
+    const edgeCount = numberValue(graph.edgeCount);
+    const blockerCount = numberValue(graph.blockerCount);
+    const humanQuestionCount = numberValue(graph.humanQuestionCount);
+    const safeMergeCandidateCount = numberValue(graph.safeMergeCandidateCount);
+    const decisionCount = numberValue(graph.decisionCount);
+    const terminalDecisionCount = numberValue(graph.terminalDecisionCount);
+    const gateCount = numberValue(graph.gateCount);
+    const recentEvents = arrayRecords(graph.recentEvents).map((event) => ({
+        type: textValue(event.type, ''),
+        at: timeValue(event.at),
+        jobId: textValue(event.jobId, ''),
+        taskId: textValue(event.taskId, ''),
+        status: textValue(event.status, ''),
+        message: textValue(event.message, '')
+    }));
+    const graphMissingWarnings = stringArray(graph.graphMissingWarnings);
+    if (!nodeCount && !edgeCount && !blockerCount && !humanQuestionCount && !safeMergeCandidateCount && !decisionCount && !terminalDecisionCount && !gateCount && !recentEvents.length && !graphMissingWarnings.length) {
+        return undefined;
+    }
+    return {
+        sourceFile: textValue(graph.sourceFile, ''),
+        sourceFiles: stringArray(graph.sourceFiles),
+        sourceKind: textValue(graph.sourceKind, ''),
+        sourceKinds: stringArray(graph.sourceKinds),
+        sourceStatus: textValue(graph.sourceStatus, ''),
+        sourceStatuses: stringArray(graph.sourceStatuses),
+        graphMissing: graph.graphMissing === true,
+        graphMissingWarningCount: numberValue(graph.graphMissingWarningCount),
+        graphMissingWarnings,
+        liveEventCount: numberValue(graph.liveEventCount),
+        nodeCount,
+        edgeCount,
+        blockerCount,
+        openBlockerCount: numberValue(graph.openBlockerCount),
+        humanQuestionCount,
+        openHumanQuestionCount: numberValue(graph.openHumanQuestionCount),
+        safeMergeCandidateCount,
+        decisionCount,
+        terminalDecisionCount,
+        terminalAcceptedCount: numberValue(graph.terminalAcceptedCount),
+        terminalRejectedCount: numberValue(graph.terminalRejectedCount),
+        terminalRerunCount: numberValue(graph.terminalRerunCount),
+        gateCount,
+        gatePassedCount: numberValue(graph.gatePassedCount),
+        gateFailedCount: numberValue(graph.gateFailedCount),
+        staleCount: numberValue(graph.staleCount),
+        openStaleCount: numberValue(graph.openStaleCount),
+        rerunCount: numberValue(graph.rerunCount),
+        openRerunCount: numberValue(graph.openRerunCount),
+        staleRerunCleanupCount: numberValue(graph.staleRerunCleanupCount),
+        status: textValue(graph.status, 'unknown'),
+        summaryLine: textValue(graph.summaryLine, ''),
+        recentEvents
     };
 }
+function decisionGraphRows(graph) {
+    const sourceKinds = (graph.sourceKinds?.length ? graph.sourceKinds : [graph.sourceKind]).filter(Boolean).join(', ') || 'unknown source';
+    const sourceStatuses = (graph.sourceStatuses?.length ? graph.sourceStatuses : [graph.sourceStatus]).filter(Boolean).join(', ') || 'unknown status';
+    const warnings = graph.graphMissingWarnings?.slice(0, 2).join(' ') || '';
+    const recent = graph.recentEvents?.slice(-3).map((event) => {
+        const label = event.message || event.type || 'graph event';
+        const subject = event.taskId || event.jobId;
+        return `${label}${subject ? ` (${subject})` : ''}`;
+    }).filter(Boolean).join('; ') || 'no recent graph events';
+    return [
+        {
+            label: 'Decision graph source',
+            value: graphSourceStatusLabel(graph),
+            detail: warnings || `${sourceKinds} · ${sourceStatuses}${graph.liveEventCount ? ` · ${formatNumber(graph.liveEventCount)} live events` : ''}`
+        },
+        {
+            label: 'Graph shape',
+            value: `${formatNumber(numberValue(graph.nodeCount))} / ${formatNumber(numberValue(graph.edgeCount))}`,
+            detail: graph.summaryLine || `${formatNumber(numberValue(graph.nodeCount))} nodes and ${formatNumber(numberValue(graph.edgeCount))} edges`
+        },
+        {
+            label: 'Terminal decisions',
+            value: formatNumber(numberValue(graph.terminalDecisionCount)),
+            detail: `${formatNumber(numberValue(graph.terminalAcceptedCount))} accepted · ${formatNumber(numberValue(graph.terminalRejectedCount))} rejected · ${formatNumber(numberValue(graph.terminalRerunCount))} rerun`
+        },
+        {
+            label: 'Open blockers',
+            value: formatNumber(numberValue(graph.openBlockerCount)),
+            detail: `${formatNumber(numberValue(graph.blockerCount))} blockers tracked`
+        },
+        {
+            label: 'Human questions',
+            value: formatNumber(numberValue(graph.openHumanQuestionCount)),
+            detail: `${formatNumber(numberValue(graph.humanQuestionCount))} questions tracked`
+        },
+        {
+            label: 'Stale/rerun cleanup',
+            value: formatNumber(numberValue(graph.staleRerunCleanupCount)),
+            detail: `${formatNumber(numberValue(graph.openStaleCount))} stale open · ${formatNumber(numberValue(graph.openRerunCount))} rerun open`
+        },
+        {
+            label: 'Safe merge candidates',
+            value: formatNumber(numberValue(graph.safeMergeCandidateCount)),
+            detail: `${formatNumber(numberValue(graph.decisionCount))} decisions · ${formatNumber(numberValue(graph.gateCount))} gates`
+        },
+        {
+            label: 'Recent graph events',
+            value: formatNumber(graph.recentEvents?.length ?? 0),
+            detail: recent
+        }
+    ];
+}
+function graphSourceStatusLabel(graph) {
+    const status = normalized(graph.sourceStatus);
+    if (graph.graphMissing || status === 'missing')
+        return 'Graph missing warning';
+    if (status === 'live')
+        return 'Live graph';
+    if (status === 'collected')
+        return 'Collected graph';
+    if (status === 'mixed')
+        return 'Mixed graph';
+    return 'Graph source';
+}
+function decisionGraphStatusLabel(value) {
+    const status = normalized(value);
+    if (status === 'blocked')
+        return 'Blocked';
+    if (status === 'questions')
+        return 'Questions';
+    if (status === 'review')
+        return 'Review';
+    if (status === 'rerun')
+        return 'Rerun';
+    if (status === 'missing')
+        return 'Missing';
+    if (status === 'ready')
+        return 'Ready';
+    if (status === 'clear')
+        return 'Clear';
+    return 'Unknown';
+}
+function semanticHealthRows(semantic) {
+    const health = semantic.health;
+    const ledgerLosses = health.ledgerFailed + health.ledgerSkipped;
+    const reasonDetail = health.reasonCodes.length ? health.reasonCodes.join(', ') : 'no reason codes';
+    return [
+        { label: 'Parser losses', value: formatNumber(health.parserLosses), detail: `${formatNumber(health.parserWarnings)} warnings · ${reasonDetail}` },
+        { label: 'Ledger losses', value: formatNumber(ledgerLosses), detail: `${formatNumber(health.ledgerFailed)} failed · ${formatNumber(health.ledgerSkipped)} skipped · ${formatNumber(health.ledgerLanded)} landed` },
+        { label: 'Auto-merge candidates', value: formatNumber(health.autoMergeCandidates), detail: `${formatNumber(semantic.acceptedClean)} replay clean` },
+        ...semanticAdmissionHealthRows(semantic),
+        { label: 'Review-required reasons', value: formatNumber(health.reviewRequired), detail: reasonDetail },
+        { label: 'Conflicts', value: formatNumber(health.conflicts), detail: 'semantic script, replay, or admission conflicts' },
+        { label: 'Gate status', value: semanticGateLabel(health.gateStatus), detail: `${formatNumber(health.gateFailed)} failed · ${formatNumber(health.gateWarnings)} review · ${formatNumber(health.gatePassed)} pass` },
+        { label: 'Synthesized/research complete', value: formatNumber(health.synthesizedResearchComplete), detail: 'completed discovery or synthesized outputs' },
+        { label: 'Open coordinator review', value: formatNumber(health.openCoordinatorReview), detail: 'outputs still waiting on coordinator decision' }
+    ];
+}
+const SEMANTIC_ADMISSION_STATUS_KEYS = [
+    'safe-merged',
+    'safe-with-losses',
+    'conflict',
+    'no-op',
+    'stale',
+    'missing-sidecar',
+    'coordinator-review',
+    'tests-missing'
+];
+const SEMANTIC_ADMISSION_STATUS_ROWS = [
+    { key: 'safe-merged', label: 'Safe merged', detail: 'semantic admission passed or replay is already clean', reasonCodes: [] },
+    { key: 'safe-with-losses', label: 'Safe with losses', detail: 'safe admission with parser or import losses attached', reasonCodes: ['lossy-import'] },
+    { key: 'conflict', label: 'Conflict', detail: 'symbol, effect, replay, or admission conflicts', reasonCodes: ['symbol-conflict', 'effect-conflict'] },
+    { key: 'no-op', label: 'No-op', detail: 'semantic evidence produced no source edit to apply', reasonCodes: [] },
+    { key: 'stale', label: 'Stale', detail: 'semantic anchor or source hash is stale against head', reasonCodes: ['stale-source-hash'] },
+    { key: 'missing-sidecar', label: 'Missing sidecar', detail: 'semantic import sidecar was expected but unavailable', reasonCodes: ['missing-sidecar'] },
+    { key: 'coordinator-review', label: 'Coordinator review', detail: 'semantic admission requires coordinator review or porting', reasonCodes: ['coordinator-review'] },
+    { key: 'tests-missing', label: 'Tests missing', detail: 'patch changed source without reported verification commands', reasonCodes: ['tests-missing'] }
+];
+function semanticAdmissionHealthRows(semantic) {
+    return SEMANTIC_ADMISSION_STATUS_ROWS.map((row) => ({
+        label: row.label,
+        value: formatNumber(numberValue(semantic.health.admissionStatusCounts[row.key])),
+        detail: admissionReasonDetail(semantic.health.admissionReasonCodeCounts, row.reasonCodes, row.detail)
+    }));
+}
+function admissionReasonDetail(reasonCounts, reasonCodes, fallback) {
+    const reasons = reasonCodes
+        .map((code) => {
+        const count = numberValue(reasonCounts[code]);
+        return count > 0 ? `${code} ${formatNumber(count)}` : '';
+    })
+        .filter(Boolean);
+    return reasons.length ? `${fallback} · ${reasons.join(', ')}` : fallback;
+}
+function semanticAdmissionStatusCounts(admission, admissionHealth, fallback) {
+    const counts = emptySemanticAdmissionStatusCounts();
+    const healthCounts = numberRecordValue(recordValue(admissionHealth.statusCounts));
+    if (Object.keys(healthCounts).length) {
+        addSemanticAdmissionStatusCounts(counts, healthCounts);
+    }
+    else {
+        addSemanticAdmissionStatusCounts(counts, numberRecordValue(recordValue(recordValue(admission.jobs).statusCounts)));
+        addSemanticAdmissionStatusCounts(counts, numberRecordValue(recordValue(recordValue(admission.scripts).statusCounts)));
+    }
+    setRecordMinimum(counts, 'safe-merged', fallback.safeMerged);
+    setRecordMinimum(counts, 'safe-with-losses', fallback.safeWithLosses);
+    setRecordMinimum(counts, 'conflict', fallback.conflict);
+    setRecordMinimum(counts, 'stale', fallback.stale);
+    setRecordMinimum(counts, 'missing-sidecar', fallback.missingSidecar);
+    setRecordMinimum(counts, 'coordinator-review', fallback.coordinatorReview);
+    setRecordMinimum(counts, 'tests-missing', fallback.testsMissing);
+    return counts;
+}
+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 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 setRecordMinimum(record, key, value) {
+    if (value > (record[key] ?? 0))
+        record[key] = value;
+}
+function semanticGateLabel(value) {
+    const status = normalized(value);
+    if (status === 'pass')
+        return 'Pass';
+    if (status === 'review')
+        return 'Review';
+    if (status === 'blocked')
+        return 'Blocked';
+    return 'Unknown';
+}
+function firstNumber(...values) {
+    for (const value of values) {
+        if (typeof value === 'number' && Number.isFinite(value))
+            return value;
+    }
+    return 0;
+}
 function semanticSuccessRows(value) {
     const input = recordValue(value);
     const imports = recordValue(input.import);
@@ -4082,6 +4767,15 @@ function admissionTone(value) {
 function recordValue(value) {
     return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
 }
+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 arrayRecords(value) {
     return Array.isArray(value) ? value.map(recordValue).filter((entry) => Object.keys(entry).length > 0) : [];
 }
@@ -4091,6 +4785,9 @@ function stringArray(value) {
 function normalized(value) {
     return textValue(value, '').toLowerCase();
 }
+function normalizedStatusKey(value) {
+    return textValue(value, '').trim().replace(/[\s_]+/g, '-').toLowerCase();
+}
 function formatTime(value) {
     const number = Number(value);
     if (!Number.isFinite(number) || number <= 0)