@shapeshift-labs/frontier-loom-ui 0.1.0

package/dist/client.js

@@ -0,0 +1,3827 @@
+import { jsx as _jsx, jsxs as _jsxs } from "@shapeshift-labs/frontier-dom/jsx-runtime";
+const contentTabs = [
+    { id: 'work', label: 'Overview' },
+    { id: 'board', label: 'Board' },
+    { id: 'swarm', label: 'Swarm' },
+    { id: 'performance', label: 'Performance' },
+    { id: 'history', label: 'History' },
+    { id: 'testing', label: 'Testing' },
+    { id: 'actions', label: 'Questions' }
+];
+const root = document.getElementById('app');
+const scrollPositions = new Map();
+const initialRoute = routeStateFromLocation();
+let selectedTab = initialRoute.tab;
+let currentDashboard;
+let renderedDashboardSignature;
+let pendingFocusTab;
+let selectedTaskCardId = initialRoute.taskId;
+let selectedTicketId = initialRoute.ticket;
+let chartPopover;
+let activeContributionTarget;
+const taskDetailsCache = new Map();
+const taskDetailsPending = new Set();
+const humanAnswerDrafts = new Map();
+const humanAnswerStates = new Map();
+root?.addEventListener('click', (event) => {
+    const copyTarget = event.target instanceof Element
+        ? event.target.closest('[data-copy-code]')
+        : null;
+    if (copyTarget) {
+        event.preventDefault();
+        event.stopPropagation();
+        const code = copyTarget.dataset.copyCode ?? '';
+        if (code)
+            void copyTextToClipboard(code, copyTarget);
+        return;
+    }
+    const revealTarget = event.target instanceof Element
+        ? event.target.closest('[data-reveal-artifact-path]')
+        : null;
+    if (revealTarget) {
+        event.preventDefault();
+        event.stopPropagation();
+        const artifactPath = revealTarget.dataset.revealArtifactPath ?? '';
+        if (artifactPath)
+            void revealArtifactInFinder(artifactPath);
+        return;
+    }
+    const modalClose = event.target instanceof Element
+        ? event.target.closest('[data-modal-close]')
+        : null;
+    const modalBackdrop = event.target instanceof HTMLElement && event.target.dataset.modalBackdrop === 'true';
+    if (modalClose || modalBackdrop) {
+        closeTaskDialog();
+        return;
+    }
+    const tab = event.target instanceof Element
+        ? event.target.closest('[data-content-tab]')
+        : null;
+    if (tab) {
+        selectContentTab(asContentTab(tab.dataset.contentTab));
+        return;
+    }
+    const taskCard = event.target instanceof Element
+        ? event.target.closest('[data-task-card]')
+        : null;
+    if (taskCard) {
+        openTaskCard(taskCard.dataset.taskCard);
+        return;
+    }
+    return;
+});
+root?.addEventListener('input', (event) => {
+    const target = event.target instanceof Element
+        ? event.target.closest('textarea[data-human-answer-code]')
+        : null;
+    if (!target)
+        return;
+    humanAnswerDrafts.set(target.dataset.humanAnswerCode ?? '', target.value);
+});
+root?.addEventListener('submit', (event) => {
+    const form = event.target instanceof Element
+        ? event.target.closest('[data-human-answer-form]')
+        : null;
+    if (!form)
+        return;
+    event.preventDefault();
+    void submitHumanActionAnswer(form);
+});
+root?.addEventListener('keydown', (event) => {
+    if (event.key === 'Escape' && selectedTaskCardId) {
+        closeTaskDialog();
+        return;
+    }
+    const taskCard = event.target instanceof Element
+        ? event.target.closest('[data-task-card]')
+        : null;
+    if (taskCard && (event.key === 'Enter' || event.key === ' ')) {
+        event.preventDefault();
+        openTaskCard(taskCard.dataset.taskCard);
+        return;
+    }
+    const target = event.target instanceof Element
+        ? event.target.closest('[data-content-tab]')
+        : null;
+    if (!target || !isTabNavigationKey(event.key))
+        return;
+    const tabs = contentTabButtons();
+    const currentIndex = tabs.indexOf(target);
+    if (currentIndex < 0)
+        return;
+    event.preventDefault();
+    const nextIndex = nextTabIndex(event.key, currentIndex, tabs.length);
+    const nextTab = asContentTab(tabs[nextIndex]?.dataset.contentTab);
+    pendingFocusTab = nextTab;
+    selectContentTab(nextTab);
+});
+root?.addEventListener('focusin', (event) => {
+    const target = chartTooltipTarget(event.target);
+    if (target)
+        showChartPopover(target);
+});
+root?.addEventListener('focusout', (event) => {
+    const target = chartTooltipTarget(event.target);
+    if (target)
+        hideChartPopover();
+});
+root?.addEventListener('wheel', (event) => {
+    const target = event.target instanceof Element
+        ? event.target.closest('.task-column-body, .task-board-column')
+        : null;
+    if (!target)
+        return;
+    const board = target.closest('.task-board-scroll');
+    if (!board)
+        return;
+    const horizontalDelta = event.deltaX || (event.shiftKey ? event.deltaY : 0);
+    if (!horizontalDelta || Math.abs(horizontalDelta) < Math.abs(event.deltaY))
+        return;
+    board.scrollLeft += horizontalDelta;
+    event.preventDefault();
+}, { passive: false });
+root?.addEventListener('pointerover', (event) => {
+    const target = nearestChartPopoverTarget(event);
+    if (!target) {
+        hideChartPopover();
+        return;
+    }
+    activeContributionTarget = target;
+    showChartPopover(target);
+});
+root?.addEventListener('mouseover', (event) => {
+    const target = nearestChartPopoverTarget(event);
+    if (!target) {
+        hideChartPopover();
+        return;
+    }
+    activeContributionTarget = target;
+    showChartPopover(target);
+});
+root?.addEventListener('pointermove', (event) => {
+    const target = nearestChartPopoverTarget(event);
+    if (!target) {
+        hideChartPopover();
+        return;
+    }
+    activeContributionTarget = target;
+    showChartPopover(target, event.clientX, event.clientY);
+});
+root?.addEventListener('mousemove', (event) => {
+    const target = nearestChartPopoverTarget(event);
+    if (!target) {
+        hideChartPopover();
+        return;
+    }
+    activeContributionTarget = target;
+    showChartPopover(target, event.clientX, event.clientY);
+});
+root?.addEventListener('pointerout', (event) => {
+    if (isStillInsideContributionGrid(event))
+        return;
+    hideChartPopover();
+});
+root?.addEventListener('mouseout', (event) => {
+    if (isStillInsideContributionGrid(event))
+        return;
+    hideChartPopover();
+});
+window.addEventListener('hashchange', () => {
+    const route = routeStateFromLocation();
+    selectedTab = route.tab;
+    selectedTaskCardId = route.taskId;
+    selectedTicketId = route.ticket;
+    if (currentDashboard)
+        renderDashboard(currentDashboard);
+});
+void refresh();
+const dashboardStreamConnected = connectDashboardStream();
+window.setInterval(refresh, dashboardStreamConnected ? 30000 : 2000);
+function connectDashboardStream() {
+    if (!('EventSource' in window))
+        return false;
+    const source = new EventSource('/api/dashboard/stream');
+    source.addEventListener('message', (event) => {
+        try {
+            const dashboard = JSON.parse(event.data);
+            currentDashboard = dashboard;
+            const signature = dashboardSignature(dashboard);
+            if (root?.hasChildNodes() && signature === renderedDashboardSignature)
+                return;
+            renderDashboard(dashboard, signature);
+        }
+        catch {
+            void refresh();
+        }
+    });
+    source.addEventListener('error', () => {
+        source.close();
+        window.setTimeout(connectDashboardStream, 2000);
+    });
+    return true;
+}
+async function refresh() {
+    let dashboard;
+    try {
+        const response = await fetch('/api/dashboard');
+        if (!response.ok)
+            throw new Error(`dashboard fetch failed: ${response.status}`);
+        dashboard = await response.json();
+    }
+    catch (error) {
+        dashboard = offlineDashboard(error);
+    }
+    currentDashboard = dashboard;
+    const signature = dashboardSignature(dashboard);
+    if (root?.hasChildNodes() && signature === renderedDashboardSignature)
+        return;
+    renderDashboard(dashboard, signature);
+}
+function renderDashboard(dashboard, signature = dashboardSignature(dashboard)) {
+    hideChartPopover();
+    captureScrollPositions();
+    pruneResolvedHumanActionDrafts(dashboard);
+    const lanes = laneRollups(dashboard);
+    root?.replaceChildren(_jsx(DashboardView, { dashboard: dashboard, lanes: lanes }));
+    renderedDashboardSignature = signature;
+    restoreScrollPositions();
+}
+function dashboardSignature(dashboard) {
+    return JSON.stringify({
+        ok: dashboard.ok,
+        cwd: dashboard.cwd,
+        summary: dashboard.summary,
+        health: dashboard.health,
+        quality: dashboard.quality,
+        timeSeries: dashboard.timeSeries,
+        lanes: dashboard.lanes,
+        jobs: dashboard.jobs,
+        humanActions: dashboard.humanActions,
+        humanActionAnswers: dashboard.humanActionAnswers,
+        events: dashboard.events,
+        routing: dashboard.routing,
+        backlog: dashboard.backlog,
+        semantic: dashboard.semantic,
+        sources: dashboard.sources
+    });
+}
+function DashboardView({ dashboard, lanes }) {
+    const attention = attentionSummary(dashboard.jobs);
+    const sourceEntries = sourceRows(dashboard);
+    const visibleJobs = dashboard.jobs;
+    const visibleEvents = dashboard.events;
+    const audit = auditSummary(dashboard, visibleJobs);
+    const success = successSummary(dashboard, visibleJobs);
+    const selectedTask = selectedTaskItem(dashboard, visibleJobs);
+    if (selectedTask)
+        void fetchTaskDetails(selectedTask);
+    return _jsxs("main", { className: "shell", children: [_jsx("section", { className: "operator-grid", children: _jsxs("section", { className: "operator-main", children: [_jsx("nav", { className: "content-tabs", role: "tablist", "aria-label": "Dashboard sections", children: contentTabs.map((tab) => contentTab(tab.id, tab.label, tabMeta(tab.id, {
+                                jobs: visibleJobs.length,
+                                questions: humanActionRows(visibleJobs, audit, dashboard).length,
+                                events: visibleEvents.length,
+                                sources: sourceEntries.length
+                            }))) }), _jsx("section", { id: `${selectedTab}-panel`, className: "content-shell", "data-scroll-id": `content-${selectedTab}`, role: "tabpanel", "aria-labelledby": `${selectedTab}-tab`, children: contentPanel(selectedTab, {
+                                dashboard,
+                                lanes,
+                                sourceEntries,
+                                visibleJobs,
+                                visibleEvents,
+                                attention,
+                                audit,
+                                success
+                            }) })] }) }), selectedTask ? _jsx(TaskDetailDialog, { job: selectedTask, dashboard: dashboard }) : null] });
+}
+function contentPanel(tab, input) {
+    const boardItems = taskBoardItems(input.dashboard, input.visibleJobs);
+    if (tab === 'work')
+        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: `${text(boardItems.length)} active-visible tasks`, children: _jsx(TaskBoard, { dashboard: input.dashboard, jobs: input.visibleJobs }) });
+    if (tab === 'swarm') {
+        const sourceKind = dashboardSourceKind(input.dashboard);
+        const activeCount = activeAgentTaskCount(input.dashboard, input.visibleJobs);
+        return _jsx(Panel, { title: sourceKind === 'demo' ? 'Demo agents' : 'Active agents', meta: sourceKind === 'demo' ? 'fixture examples' : activeCount ? `${text(activeCount)} running` : 'none running', children: _jsx(AgentWork, { dashboard: input.dashboard, jobs: input.visibleJobs }) });
+    }
+    if (tab === 'performance')
+        return _jsx(Panel, { title: "Performance", meta: performanceTabMeta(input.dashboard, input.visibleJobs), children: _jsx(PerformanceView, { dashboard: input.dashboard, jobs: input.visibleJobs, attention: input.attention, audit: input.audit }) });
+    if (tab === 'history')
+        return _jsx(Panel, { title: "History", meta: historyTabMeta(input.dashboard, input.visibleJobs, input.success), children: _jsx(HistoryView, { dashboard: input.dashboard, jobs: input.visibleJobs, events: input.visibleEvents, success: input.success, attention: input.attention }) });
+    if (tab === 'testing')
+        return _jsx(Panel, { title: "Testing", meta: testingTabMeta(input.visibleJobs), children: _jsx(TestingView, { jobs: input.visibleJobs, events: input.visibleEvents }) });
+    return _jsx(Panel, { title: "Questions for you", meta: `${text(humanActionRows(input.visibleJobs, input.audit, input.dashboard).length)} open`, children: _jsx(HumanActionQueue, { dashboard: input.dashboard, jobs: input.visibleJobs, audit: input.audit }) });
+}
+function Panel({ title, meta, children, className, hideHead = false }) {
+    return _jsxs("section", { className: className ? `panel ${className}` : 'panel', children: [hideHead ? null : _jsxs("div", { className: "panel-head", children: [_jsx("h2", { children: title }), meta ? _jsx("span", { children: meta }) : null] }), children] });
+}
+function contentTab(id, label, meta) {
+    const active = selectedTab === id;
+    return _jsxs("button", { id: `${id}-tab`, type: "button", className: active ? 'content-tab active' : 'content-tab', "data-content-tab": id, role: "tab", "aria-selected": active ? 'true' : 'false', "aria-controls": `${id}-panel`, tabIndex: active ? 0 : -1, children: [_jsx("span", { children: label }), _jsx("small", { children: meta })] });
+}
+function WorkOverview({ dashboard, lanes, jobs, attention, audit, success }) {
+    const health = dashboardHealthSummary(dashboard, jobs, attention);
+    const contribution = contributionGrid(dashboard, jobs, dashboard.events);
+    const successfulJobCount = successLikeJobCount(jobs);
+    const progressRatio = health.jobCount ? successfulJobCount / health.jobCount : 0;
+    const progressLabel = formatPercent(progressRatio);
+    const progressWidth = Math.max(0, Math.min(100, progressRatio * 100));
+    const cost = workCostSummary(dashboard, jobs);
+    void lanes;
+    void audit;
+    void success;
+    return _jsxs("div", { className: "work-layout", "data-scroll-id": "work", children: [_jsxs("section", { className: "goal-card", children: [_jsxs("div", { children: [_jsx("span", { children: "Goal" }), _jsx("h3", { children: currentGoalTitle(dashboard) }), _jsx("p", { children: goalProgressText(health, successfulJobCount) })] }), _jsxs("div", { className: "goal-progress", children: [_jsxs("div", { className: "goal-progress-head", children: [_jsx("b", { children: progressLabel }), _jsxs("span", { children: [text(successfulJobCount), " of ", text(health.jobCount), " tasks completed successfully"] })] }), _jsx("div", { className: "goal-progress-track", role: "img", "aria-label": `${progressLabel} successful task progress`, children: _jsx("span", { className: `goal-progress-fill ${health.tone}`, style: `width:${progressWidth}%` }) })] })] }), _jsxs("section", { className: "work-section work-contribution-section", children: [_jsxs("div", { className: "metric-section-head", children: [_jsx("h3", { children: "Progress by day" }), _jsxs("span", { children: [text(contribution.year), " \u00B7 January through December"] })] }), _jsx(ContributionGraph, { grid: contribution, prominent: true })] }), _jsxs("section", { className: "work-section", children: [_jsxs("div", { className: "metric-section-head", children: [_jsx("h3", { children: "Token cost estimate" }), _jsx("span", { children: cost.detail })] }), _jsxs("div", { className: "work-cost-metrics", children: [costMetric('Total input', cost.totalInput, cost.totalDetail), costMetric('Uncached input', cost.freshInput, cost.freshDetail), costMetric('Cached input', cost.cachedInput, cost.cachedDetail), costMetric('Budget warnings', cost.budgetWarnings, cost.budgetDetail)] })] })] });
+}
+function currentGoalTitle(dashboard) {
+    const backlog = recordValue(dashboard.backlog);
+    const explicit = textValue(backlog.title ?? backlog.goal ?? backlog.objective ?? backlog.summary, '');
+    if (explicit)
+        return explicit;
+    const id = textValue(backlog.id, '');
+    if (id && id !== 'backlog' && id !== 'next-backlog')
+        return sentenceCaseIdentifier(id);
+    return 'Rewrite the Frontier swarm dashboard';
+}
+function sentenceCaseIdentifier(value) {
+    const spaced = value
+        .replace(/[_-]+/g, ' ')
+        .replace(/\s+/g, ' ')
+        .trim();
+    if (!spaced)
+        return value;
+    return spaced[0].toUpperCase() + spaced.slice(1);
+}
+function goalProgressText(health, successfulJobCount) {
+    if (!health.jobCount)
+        return 'No active swarm work is loaded yet.';
+    const attentionCount = health.failedJobCount + health.blockedJobCount + health.warningJobCount;
+    if (successfulJobCount >= health.jobCount)
+        return 'Every tracked task has completed successfully.';
+    if (health.runningJobCount) {
+        return `The swarm is working through ${text(health.jobCount)} tracked tasks. ${text(health.runningJobCount)} are still running.`;
+    }
+    if (health.terminalJobCount >= health.jobCount) {
+        return `Execution has finished, but ${text(attentionCount)} tasks still need review or fixes.`;
+    }
+    return `No agents are running right now. ${text(Math.max(0, health.jobCount - health.terminalJobCount))} tasks remain queued and ${text(attentionCount)} need review or fixes.`;
+}
+function workCostSummary(dashboard, jobs) {
+    const telemetry = tokenTimeSummary(dashboard, jobs);
+    const context = contextPressureSummary(jobs);
+    return {
+        totalInput: telemetry.tokenValue,
+        totalDetail: telemetry.tokenDetail,
+        freshInput: context.uncachedInputTokens ? formatNumber(context.uncachedInputTokens) : '-',
+        freshDetail: context.estimatedInputTokens ? `${formatRatio(context.uncachedRatio)} of estimate` : 'uncached model input',
+        cachedInput: context.cachedInputTokens ? formatNumber(context.cachedInputTokens) : '-',
+        cachedDetail: context.actualInputTokens ? `${formatRatio(context.cachedInputTokens / Math.max(1, context.actualInputTokens))} of reported` : 'reported cache reuse',
+        budgetWarnings: formatNumber(context.warningCount + context.failedCount),
+        budgetDetail: `${formatNumber(context.failedCount)} failed budget`,
+        detail: telemetry.durationValue === '-' ? 'token estimates and budget pressure' : `${telemetry.durationValue} runtime estimate`
+    };
+}
+function costMetric(label, value, detail) {
+    return _jsxs("article", { className: "cost-metric", children: [_jsx("span", { children: label }), _jsx("b", { children: value }), _jsx("small", { children: detail })] });
+}
+function TaskBoard({ dashboard, jobs }) {
+    const items = taskBoardItems(dashboard, jobs);
+    const columns = taskBoardColumns(items);
+    const activeCount = columns.reduce((sum, column) => column.id === 'done' ? sum : sum + column.items.length, 0);
+    return _jsx("div", { className: "task-board-layout", "data-scroll-id": "task-board", children: _jsx("div", { className: "task-board-scroll", "data-scroll-id": "task-board-x", "aria-label": `${text(items.length)} AI-managed tasks, ${text(activeCount)} not done`, children: columns.map((column) => _jsxs("section", { className: `task-board-column ${column.id}`, "aria-label": `${column.title}: ${text(column.items.length)} tasks`, children: [_jsxs("header", { className: "task-column-head", children: [_jsxs("div", { children: [_jsx("h3", { children: column.title }), _jsx("span", { children: column.detail })] }), _jsx("b", { children: text(column.items.length) })] }), _jsx("div", { className: "task-column-body", "data-scroll-id": `task-column-${column.id}`, children: column.items.length
+                            ? column.items.map((job) => _jsx(TaskBoardCard, { job: job }))
+                            : _jsx("p", { className: "empty tight", children: column.empty }) })] })) }) });
+}
+function AgentWork({ dashboard, jobs }) {
+    const items = taskBoardItems(dashboard, jobs).filter(isActiveAgentJob);
+    const workers = agentWorkers(items);
+    void dashboard;
+    return _jsx("div", { className: "agent-work-layout", "data-scroll-id": "swarm", children: _jsxs("section", { className: "agent-roster-panel", "aria-label": "Active agent roster", children: [_jsxs("div", { className: "agent-roster-head", children: [_jsx("span", { children: "Agent" }), _jsx("span", { children: "Current work" }), _jsx("span", { children: "Model" }), _jsx("span", { children: "Run time" }), _jsx("span", { children: "Input" }), _jsx("span", { children: "Files" })] }), _jsx("div", { className: "agent-roster-list", "data-scroll-id": "swarm-roster", children: workers.length
+                        ? workers.map((worker, index) => _jsx(AgentWorkerCard, { worker: worker, index: index, now: timeValue(dashboard.generatedAt) ?? Date.now() }))
+                        : _jsx("p", { className: "agent-roster-empty", children: "No active agents are running right now." }) })] }) });
+}
+function AgentWorkerCard({ worker, index, now }) {
+    const model = agentModelSummary(worker);
+    const files = agentTouchedFiles(worker);
+    const evidenceCount = agentEvidenceCount(worker);
+    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: "No files" }) : null] }), evidenceCount ? _jsxs("small", { children: [text(evidenceCount), " ", evidenceCount === 1 ? 'artifact' : 'artifacts'] }) : null] })] });
+}
+function TaskBoardCard({ job }) {
+    const id = taskCardId(job);
+    const ticket = ticketId(job);
+    const risk = jobRisk(job);
+    return _jsxs("article", { className: `task-card ${risk}`, "data-task-card": id, role: "button", tabIndex: 0, draggable: "false", "aria-label": `Open task ${taskTitle(job)}`, children: [_jsxs("div", { className: "task-card-top", children: [_jsx("code", { className: "task-ticket", children: ticket }), _jsx("button", { type: "button", className: "task-id-copy", "data-copy-code": ticket, title: `Copy ${ticket}`, children: "Copy" })] }), _jsx("span", { className: "task-card-kicker", children: taskCardStatus(job) }), _jsx("b", { children: taskTitle(job) }), _jsxs("small", { children: [laneOf(job), " \u00B7 ", taskStatusDetail(job)] }), _jsxs("div", { className: "task-card-foot", children: [_jsxs("span", { children: [formatNumber(numberValue(job.changedPathCount)), " paths"] }), _jsxs("span", { children: [formatNumber(numberValue(job.evidencePathCount)), " evidence"] })] })] });
+}
+function TaskDetailDialog({ job, dashboard }) {
+    const title = taskTitle(job);
+    const reasons = taskReasonItems(job);
+    const ticket = ticketId(job);
+    const id = taskCardId(job);
+    const details = taskDetailsCache.get(id);
+    const tokenSummary = taskTokenSummary(job);
+    void dashboard;
+    return _jsx("div", { className: "task-modal-backdrop", "data-modal-backdrop": "true", children: _jsxs("section", { className: `task-dialog ${jobRisk(job)}`, role: "dialog", "aria-modal": "true", "aria-labelledby": "task-dialog-title", children: [_jsxs("header", { className: "task-dialog-head", children: [_jsxs("div", { children: [_jsx("span", { children: taskCardStatus(job) }), _jsx("h3", { id: "task-dialog-title", children: title }), _jsx("p", { children: taskDetailSummary(job) })] }), _jsxs("div", { className: "task-dialog-actions", children: [_jsx("button", { type: "button", "data-copy-code": ticket, children: "Copy ID" }), _jsx("button", { type: "button", "data-modal-close": "true", "aria-label": "Close task details", children: "Close" })] })] }), _jsxs("div", { className: "task-dialog-body", "data-scroll-id": taskDialogScrollId(id), children: [_jsxs("section", { className: "task-dialog-grid", "aria-label": "Task facts", children: [taskFact('Ticket', ticket), taskFact('Task', text(job.taskId ?? job.id)), taskFact('Lane', laneOf(job)), taskFact('Status', text(job.status)), taskFact('Column', taskBoardColumnTitle(taskBoardColumnId(job))), taskFact('Merge', text(job.mergeReadiness ?? job.disposition ?? job.bucket)), taskFact('Cost', tokenSummary)] }), _jsxs("section", { className: "task-dialog-section", children: [_jsx("h4", { children: "Details" }), _jsx("p", { children: taskMarkdownSummary(job) })] }), _jsxs("section", { className: "task-dialog-section split", children: [_jsxs("div", { children: [_jsx("h4", { children: "Reasons" }), reasons.length ? _jsx("ul", { children: reasons.map((reason) => _jsx("li", { children: reason })) }) : _jsx("p", { className: "empty tight", children: "No reasons reported." })] }), _jsxs("div", { children: [_jsx("h4", { children: "Output" }), _jsxs("ul", { children: [_jsxs("li", { children: [formatNumber(numberValue(job.changedPathCount)), " changed paths reported."] }), _jsxs("li", { children: [formatNumber(numberValue(job.evidencePathCount)), " evidence artifacts reported."] }), _jsxs("li", { children: [pathSummaryText(job), "."] })] })] })] }), _jsx(TaskFileDiffs, { job: job, details: details }), _jsx(TaskResultDetails, { job: job, details: details })] })] }) });
+}
+function TaskFileDiffs({ job, details }) {
+    const changedPaths = stringArray(job.changedPaths).slice(0, 12);
+    if (!details && job.boardKind !== 'backlog')
+        return _jsxs("section", { className: "task-dialog-section", children: [_jsx("h4", { children: "Files changed" }), _jsx("p", { className: "empty tight", children: "Loading file diffs..." })] });
+    if (details?.files?.length)
+        return _jsxs("section", { className: "task-dialog-section", children: [_jsx("h4", { children: "Files changed" }), _jsx("div", { className: "task-file-list", children: details.files.map((file) => _jsxs("details", { className: "task-file-diff", 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.' })] });
+}
+function TaskResultDetails({ job, details }) {
+    const evidenceArtifacts = artifactListFromDetails(job, details).slice(0, 10);
+    const passed = details?.commandsPassed ?? [];
+    const failed = details?.commandsFailed ?? [];
+    if (passed.length || failed.length)
+        return _jsxs("section", { className: "task-dialog-section", children: [_jsx("h4", { children: "Results" }), _jsxs("div", { className: "task-result-list", children: [failed.map((entry) => taskResultRow(entry, 'failed')), passed.map((entry) => taskResultRow(entry, 'passed'))] }), evidenceArtifacts.length ? _jsxs("div", { className: "task-section-subblock", children: [_jsx("h5", { children: "Evidence" }), _jsx(ArtifactList, { artifacts: evidenceArtifacts })] }) : null] });
+    if (!evidenceArtifacts.length)
+        return _jsxs("section", { className: "task-dialog-section", children: [_jsx("h4", { children: "Results" }), _jsx("p", { className: "empty tight", children: "No test or evidence output is attached to this task yet." })] });
+    return _jsxs("section", { className: "task-dialog-section", children: [_jsx("h4", { children: "Evidence" }), _jsx(ArtifactList, { artifacts: evidenceArtifacts })] });
+}
+function DiffRenderer({ file }) {
+    const hunks = file.hunks?.length ? file.hunks : fallbackDiffHunks(file.diff);
+    return _jsx("div", { className: `diff-renderer language-${file.language ?? 'text'}`, "data-diff-renderer": "true", children: hunks.map((hunk) => _jsx("section", { className: "diff-hunk", "aria-label": hunk.header, children: hunk.lines.map((line) => diffLineNode(line, file.language ?? 'text')) })) });
+}
+function diffLineNode(line, language) {
+    const prefix = line.kind === 'add' ? '+' : line.kind === 'delete' ? '-' : line.kind === 'context' ? ' ' : '';
+    return _jsxs("div", { className: `diff-line diff-line-${line.kind}`, children: [_jsx("span", { className: "diff-line-old", children: line.oldLine === undefined ? '' : text(line.oldLine) }), _jsx("span", { className: "diff-line-new", children: line.newLine === undefined ? '' : text(line.newLine) }), _jsx("span", { className: "diff-line-prefix", children: prefix }), _jsx("code", { className: "diff-line-code", children: line.kind === 'add' || line.kind === 'delete' || line.kind === 'context'
+                    ? highlightCode(line.content, language)
+                    : line.content })] });
+}
+function fallbackDiffHunks(diff) {
+    return [{
+            header: 'Raw patch',
+            lines: diff.split('\n').map((line) => {
+                if (line.startsWith('+') && !line.startsWith('+++'))
+                    return { kind: 'add', content: line.slice(1) };
+                if (line.startsWith('-') && !line.startsWith('---'))
+                    return { kind: 'delete', content: line.slice(1) };
+                if (line.startsWith('@@'))
+                    return { kind: 'hunk', content: line };
+                if (line.startsWith(' '))
+                    return { kind: 'context', content: line.slice(1) };
+                return { kind: 'meta', content: line };
+            })
+        }];
+}
+function ArtifactPathList({ paths }) {
+    return _jsx("div", { className: "task-path-list", children: paths.map((entry) => _jsx(ArtifactLink, { path: entry, label: entry })) });
+}
+function ArtifactList({ artifacts }) {
+    return _jsx("div", { className: "task-path-list", children: artifacts.map((artifact) => _jsx(ArtifactLink, { path: artifact.path, label: artifact.label || artifact.path })) });
+}
+function ArtifactLink({ path, label, className }) {
+    return _jsx("button", { type: "button", className: className ? `artifact-link ${className}` : 'artifact-link', "data-reveal-artifact-path": path, title: `Reveal ${path} in Finder`, children: label });
+}
+function artifactListFromDetails(job, details) {
+    const detailArtifacts = details?.evidenceArtifacts ?? [];
+    const legacy = stringArray(job.evidencePaths).map((entry) => ({ path: entry, label: artifactLabel(entry) }));
+    const byPath = new Map();
+    for (const artifact of [...detailArtifacts, ...legacy])
+        byPath.set(artifact.path, artifact);
+    return Array.from(byPath.values());
+}
+function highlightCode(value, language) {
+    if (!shouldHighlightLanguage(language) || !value)
+        return [value];
+    const pattern = /(\/\/.*$|\/\*.*?\*\/|"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|`(?:\\.|[^`\\])*`|\b(?:async|await|break|case|catch|class|const|continue|default|else|export|extends|false|for|from|function|if|import|interface|let|new|null|of|return|switch|true|try|type|undefined|var|while)\b|\b\d+(?:\.\d+)?\b)/g;
+    const out = [];
+    let lastIndex = 0;
+    for (const match of value.matchAll(pattern)) {
+        const token = match[0];
+        const index = match.index ?? 0;
+        if (index > lastIndex)
+            out.push(value.slice(lastIndex, index));
+        out.push(_jsx("span", { className: `diff-token ${tokenClass(token)}`, children: token }));
+        lastIndex = index + token.length;
+    }
+    if (lastIndex < value.length)
+        out.push(value.slice(lastIndex));
+    return out.length ? out : [value];
+}
+function shouldHighlightLanguage(language) {
+    return ['typescript', 'javascript', 'json', 'css', 'html', 'markdown'].includes(language);
+}
+function tokenClass(token) {
+    if (token.startsWith('//') || token.startsWith('/*'))
+        return 'comment';
+    if (token.startsWith('"') || token.startsWith("'") || token.startsWith('`'))
+        return 'string';
+    if (/^\d/.test(token))
+        return 'number';
+    return 'keyword';
+}
+function artifactLabel(path) {
+    const clean = path.replace(/\/+$/g, '');
+    return clean.split(/[\\/]/g).filter(Boolean).pop() ?? clean;
+}
+function taskResultRow(entry, state) {
+    const command = textValue(entry.command ?? entry.cmd ?? entry.name ?? entry.label, state === 'passed' ? 'passed command' : 'failed command');
+    const detail = textValue(entry.summary ?? entry.output ?? entry.error ?? entry.exitCode, '');
+    return _jsxs("article", { className: `task-result-row ${state}`, children: [_jsx("span", { children: state }), _jsx("b", { children: command }), detail ? _jsx("small", { children: detail }) : null] });
+}
+function taskBoardItems(dashboard, jobs) {
+    return [
+        ...jobs.filter(isTaskBoardVisibleJob).map((job) => ({ ...job, boardKind: 'job' })),
+        ...backlogBoardItems(dashboard)
+    ];
+}
+function isTaskBoardVisibleJob(job) {
+    return !isResolvedCoordinatorReviewJob(job);
+}
+function isResolvedCoordinatorReviewJob(job) {
+    const bucket = normalized(job.bucket);
+    const status = coordinatorDecisionStatus(job);
+    if (bucket === 'review-resolved' || bucket === 'resolved-review' || job.reviewResolved === true)
+        return true;
+    return Boolean(status) && isResolvedCoordinatorDecisionStatus(status);
+}
+function isResolvedCoordinatorDecisionStatus(status) {
+    const value = normalized(status);
+    return Boolean(value) && !['open', 'pending', 'deferred', 'needs-review'].includes(value);
+}
+function activeAgentTaskCount(dashboard, jobs) {
+    return taskBoardItems(dashboard, jobs).filter(isActiveAgentJob).length;
+}
+function backlogBoardItems(dashboard) {
+    const direct = recordValue(dashboard.backlog);
+    const raw = recordValue(dashboard.raw);
+    const continuation = recordValue(raw.continuation);
+    const nextBacklog = recordValue(continuation.nextBacklog);
+    const entries = [
+        ...arrayRecords(direct.entries),
+        ...arrayRecords(nextBacklog.entries)
+    ];
+    return entries.map((entry, index) => {
+        const id = textValue(entry.id ?? entry.taskId ?? entry.title, `backlog-${index + 1}`);
+        const status = normalized(entry.status ?? entry.state);
+        const column = ['todo', 'ready', 'queued', 'pending'].includes(status) || Boolean(entry.ready)
+            ? 'todo'
+            : 'backlog';
+        return {
+            ...entry,
+            boardKind: 'backlog',
+            boardColumn: column,
+            id: `backlog:${id}`,
+            taskId: id,
+            title: textValue(entry.title ?? entry.objective ?? entry.summary ?? id, id),
+            status: textValue(entry.status ?? entry.state, column === 'todo' ? 'todo' : 'backlog'),
+            lane: textValue(entry.lane ?? entry.group ?? entry.owner, 'backlog'),
+            changedPathCount: numberValue(entry.changedPathCount),
+            evidencePathCount: numberValue(entry.evidencePathCount)
+        };
+    });
+}
+function taskBoardColumns(items) {
+    const columns = [
+        { id: 'backlog', title: 'Backlog', detail: 'not scheduled yet', empty: 'No backlog items.', items: [] },
+        { id: 'todo', title: 'To do', detail: 'ready to start', empty: 'No queued tasks.', items: [] },
+        { id: 'active', title: 'Active', detail: 'running work', empty: 'No active tasks.', items: [] },
+        { id: 'review', title: 'Coordinator review', detail: 'needs decision', empty: 'No tasks need coordinator review.', items: [] },
+        { id: 'ready', title: 'Ready', detail: 'ready to apply', empty: 'No ready patches.', items: [] },
+        { id: 'done', title: 'Done', detail: 'completed output', empty: 'No completed tasks.', items: [] },
+        { id: 'blocked', title: 'Blocked', detail: 'waiting or impossible', empty: 'No genuinely blocked tasks.', items: [] }
+    ];
+    const byId = new Map(columns.map((column) => [column.id, column]));
+    for (const job of items)
+        byId.get(taskBoardColumnId(job))?.items.push(job);
+    for (const column of columns)
+        column.items.sort(taskBoardJobSort);
+    return columns;
+}
+const AGENT_DESCRIPTION_WORDS = [
+    'curious',
+    'steady',
+    'sharp',
+    'patient',
+    'bright',
+    'quiet',
+    'focused',
+    'careful',
+    'swift',
+    'calm',
+    'clear',
+    'brave',
+    'nimble',
+    'keen',
+    'warm',
+    'exact'
+];
+const AGENT_ANIMAL_NAMES = [
+    'fox',
+    'otter',
+    'hawk',
+    'lynx',
+    'raven',
+    'badger',
+    'heron',
+    'marten',
+    'falcon',
+    'orca',
+    'hare',
+    'wolf',
+    'owl',
+    'seal',
+    'ibis',
+    'koala'
+];
+const AGENT_COLORS = [
+    '#9fb7cf',
+    '#b7ad83',
+    '#9fbea8',
+    '#c3a0a0',
+    '#b2a6c8',
+    '#96b8b3',
+    '#c2b08f',
+    '#a9b1bb',
+    '#8fb29d',
+    '#baa0b4',
+    '#a5b8d0',
+    '#c0aa96'
+];
+function agentWorkers(jobs) {
+    const byAgent = new Map();
+    for (const job of jobs) {
+        const key = agentIdentityKey(job);
+        let worker = byAgent.get(key);
+        if (!worker) {
+            worker = {
+                key,
+                name: generatedAgentName(key),
+                color: agentColor(key),
+                status: 'idle',
+                jobs: [],
+                currentJobs: []
+            };
+            byAgent.set(key, worker);
+        }
+        worker.jobs.push(job);
+        if (isActiveAgentJob(job))
+            worker.currentJobs.push(job);
+    }
+    const workers = Array.from(byAgent.values());
+    for (const worker of workers) {
+        worker.jobs.sort(agentWorkerSort);
+        worker.currentJobs.sort(agentWorkerSort);
+        worker.status = coordinatorStatus(agentStatusCounts(worker.jobs));
+        if (!worker.currentJobs.length)
+            worker.currentJobs = worker.jobs.slice(0, 3);
+    }
+    return workers.sort((left, right) => agentStatusRank(left.status) - agentStatusRank(right.status) || left.name.localeCompare(right.name));
+}
+function agentIdentityKey(job) {
+    return textValue(job.agentId ?? job.workerId ?? job.worker ?? job.assignee ?? job.assignedAgent ?? job.computeId ?? job.taskId ?? job.id, taskCardId(job));
+}
+function generatedAgentName(key) {
+    const hash = stableNumber(key);
+    const description = AGENT_DESCRIPTION_WORDS[hash % AGENT_DESCRIPTION_WORDS.length] ?? 'curious';
+    const animal = AGENT_ANIMAL_NAMES[Math.floor(hash / AGENT_DESCRIPTION_WORDS.length) % AGENT_ANIMAL_NAMES.length] ?? 'fox';
+    return `${description} ${animal}`;
+}
+function agentDisplayName(worker, index) {
+    if (worker.name)
+        return worker.name;
+    return `Agent ${String(index + 1).padStart(2, '0')}`;
+}
+function agentColor(key) {
+    return AGENT_COLORS[stableNumber(key) % AGENT_COLORS.length] ?? AGENT_COLORS[0];
+}
+function stableNumber(value) {
+    let hash = 2_166_136_261;
+    for (let index = 0; index < value.length; index += 1) {
+        hash ^= value.charCodeAt(index);
+        hash = Math.imul(hash, 16_777_619);
+    }
+    return hash >>> 0;
+}
+function agentStatusCounts(items) {
+    const counts = emptyAgentStatusCounts();
+    for (const item of items)
+        counts[agentStatus(item)] += 1;
+    return counts;
+}
+function emptyAgentStatusCounts() {
+    return { active: 0, waiting: 0, review: 0, done: 0, blocked: 0, idle: 0 };
+}
+function agentStatus(job) {
+    const status = normalized(job.status ?? job.state);
+    const bucket = normalized(job.bucket);
+    const disposition = normalized(job.disposition ?? job.mergeReadiness);
+    if (['running', 'active', 'working', 'in-progress', 'in progress'].includes(status))
+        return 'active';
+    if (status === 'idle' || bucket === 'idle')
+        return 'idle';
+    if (isBlockedJob(job))
+        return 'blocked';
+    if (isCoordinatorReviewJob(job) || isReadyJob(job) || disposition.includes('review'))
+        return 'review';
+    if (isCompletedJob(job) || ['done', 'landed', 'applied'].includes(bucket) || ['done', 'landed', 'applied'].includes(disposition))
+        return 'done';
+    if (['queued', 'pending', 'todo', 'waiting', 'scheduled'].includes(status) || ['queued', 'pending'].includes(bucket))
+        return 'waiting';
+    return 'waiting';
+}
+function isActiveAgentJob(job) {
+    return agentStatus(job) === 'active';
+}
+function coordinatorStatus(counts) {
+    if (counts.active)
+        return 'active';
+    if (counts.review)
+        return 'review';
+    if (counts.blocked)
+        return 'blocked';
+    if (counts.waiting)
+        return 'waiting';
+    if (counts.done)
+        return 'done';
+    return 'idle';
+}
+function agentStatusLabel(status) {
+    if (status === 'active')
+        return 'Active';
+    if (status === 'waiting')
+        return 'Waiting';
+    if (status === 'review')
+        return 'Review';
+    if (status === 'done')
+        return 'Done';
+    if (status === 'blocked')
+        return 'Blocked';
+    return 'Idle';
+}
+function agentModelLabel(job) {
+    const value = textValue(job.model ?? job.modelTier ?? job.profile ?? job.computeProfile ?? job.routingMode, '');
+    return value || 'model unknown';
+}
+function agentModelSummary(worker) {
+    const models = uniqueStrings(worker.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 agentStatusDetail(job) {
+    const status = agentStatus(job);
+    if (status === 'active')
+        return 'Working on the assigned task now.';
+    if (status === 'waiting')
+        return 'Waiting to start, resume, or receive a lease.';
+    if (status === 'review')
+        return 'Output is waiting for coordinator review or application.';
+    if (status === 'blocked')
+        return taskReasonItems(job).slice(0, 2).join(', ') || 'Explicitly blocked by a dependency, missing decision, or impossible task.';
+    if (status === 'done')
+        return 'Worker output is complete.';
+    return 'Worker is idle.';
+}
+function agentTokenValue(worker) {
+    const actual = worker.jobs.reduce((sum, job) => sum + numberValue(job.actualInputTokens), 0);
+    const estimated = worker.jobs.reduce((sum, job) => sum + numberValue(job.estimatedInputTokens), 0);
+    const prompt = worker.jobs.reduce((sum, job) => sum + numberValue(job.promptBytes), 0);
+    if (actual)
+        return formatNumber(actual);
+    if (estimated)
+        return `${formatNumber(estimated)} est`;
+    if (prompt)
+        return formatBytes(prompt);
+    return '-';
+}
+function agentUncachedTokenValue(worker) {
+    const uncached = worker.jobs.reduce((sum, job) => sum + uncachedInputTokensForJob(job), 0);
+    return uncached ? formatNumber(uncached) : '-';
+}
+function agentRuntimeValue(worker, now) {
+    const durations = worker.currentJobs.map((job) => jobRuntimeMs(job, now)).filter((value) => value > 0);
+    if (!durations.length)
+        return '-';
+    return formatDuration(Math.max(...durations));
+}
+function jobRuntimeLabel(job, now) {
+    const duration = jobRuntimeMs(job, now);
+    return duration ? formatDuration(duration) : 'no timing';
+}
+function jobRuntimeMs(job, now) {
+    const explicit = numberValue(job.durationMs ?? job.elapsedMs ?? job.runtimeMs ?? job.wallTimeMs);
+    if (explicit > 0)
+        return explicit;
+    const started = timeValue(job.startedAt ?? job.startTime ?? job.createdAt ?? job.leaseStartedAt);
+    const ended = timeValue(job.finishedAt ?? job.completedAt ?? job.endedAt ?? job.updatedAt);
+    if (started && ended && ended >= started)
+        return ended - started;
+    if (started && isActiveAgentJob(job))
+        return Math.max(0, now - started);
+    return 0;
+}
+function agentTouchedFiles(worker) {
+    const paths = worker.jobs.flatMap((job) => stringArray(job.changedPaths));
+    if (paths.length)
+        return uniqueStrings(paths);
+    return worker.jobs
+        .map((job) => textValue(job.changedPath, ''))
+        .filter(Boolean);
+}
+function agentEvidencePaths(worker) {
+    return uniqueStrings(worker.jobs.flatMap((job) => stringArray(job.evidencePaths)));
+}
+function agentEvidenceCount(worker) {
+    const paths = agentEvidencePaths(worker);
+    if (paths.length)
+        return paths.length;
+    return worker.jobs.reduce((sum, job) => sum + numberValue(job.evidencePathCount), 0);
+}
+function agentWorkerSort(left, right) {
+    return agentStatusRank(agentStatus(left)) - agentStatusRank(agentStatus(right))
+        || taskBoardJobSort(left, right);
+}
+function agentStatusRank(status) {
+    if (status === 'active')
+        return 0;
+    if (status === 'review')
+        return 1;
+    if (status === 'blocked')
+        return 2;
+    if (status === 'waiting')
+        return 3;
+    if (status === 'idle')
+        return 4;
+    return 5;
+}
+function taskBoardColumnId(job) {
+    if (job.boardColumn)
+        return job.boardColumn;
+    if (job.boardKind === 'backlog')
+        return 'backlog';
+    if (isBlockedJob(job))
+        return 'blocked';
+    if (isCoordinatorReviewJob(job))
+        return 'review';
+    if (isReadyJob(job))
+        return 'ready';
+    if (['queued', 'pending', 'todo'].includes(normalized(job.status)))
+        return 'todo';
+    if (!isTerminalJob(job) || normalized(job.status) === 'running')
+        return 'active';
+    return 'done';
+}
+function taskBoardColumnTitle(id) {
+    if (id === 'backlog')
+        return 'Backlog';
+    if (id === 'todo')
+        return 'To do';
+    if (id === 'active')
+        return 'Active';
+    if (id === 'review')
+        return 'Coordinator review';
+    if (id === 'ready')
+        return 'Ready';
+    if (id === 'done')
+        return 'Done';
+    return 'Blocked';
+}
+function taskBoardJobSort(left, right) {
+    return taskSortRank(left) - taskSortRank(right)
+        || taskTitle(left).localeCompare(taskTitle(right));
+}
+function taskSortRank(job) {
+    if (job.boardKind === 'backlog')
+        return 0;
+    if (isBlockedJob(job))
+        return 0;
+    if (isNeedsCoordinatorPortJob(job))
+        return 1;
+    if (isFailedJob(job) || isStaleJob(job))
+        return 2;
+    if (normalized(job.status) === 'running')
+        return 3;
+    if (isReadyJob(job))
+        return 4;
+    return 5;
+}
+function taskCardId(job) {
+    return textValue(job.id ?? job.taskId ?? job.title, 'task');
+}
+function ticketId(job) {
+    return `T-${stableHash(taskCardId(job)).slice(0, 5).toUpperCase()}`;
+}
+function stableHash(value) {
+    let hash = 2_166_136_261;
+    for (let index = 0; index < value.length; index += 1) {
+        hash ^= value.charCodeAt(index);
+        hash = Math.imul(hash, 16_777_619);
+    }
+    return (hash >>> 0).toString(36).padStart(6, '0');
+}
+function taskTitle(job) {
+    return sentenceCaseIdentifier(textValue(job.title ?? job.taskId ?? job.id, 'Untitled task'));
+}
+function taskCardStatus(job) {
+    const decision = coordinatorDecisionStatus(job);
+    if (decision)
+        return coordinatorDecisionLabel(decision);
+    const column = taskBoardColumnId(job);
+    if (column === 'backlog')
+        return 'Backlog';
+    if (column === 'todo')
+        return 'To do';
+    if (column === 'review')
+        return 'Coordinator review';
+    if (column === 'ready')
+        return 'Ready';
+    if (column === 'blocked')
+        return 'Blocked';
+    if (column === 'done')
+        return 'Done';
+    return textValue(job.status, 'Active');
+}
+function taskStatusDetail(job) {
+    const decision = recordValue(job.coordinatorDecision);
+    const reason = textValue(decision.reason, '');
+    if (reason)
+        return reason;
+    return coordinatorFacingSignalLabel(job.bucket ?? job.disposition ?? job.mergeReadiness ?? job.status);
+}
+function taskDetailSummary(job) {
+    const decision = recordValue(job.coordinatorDecision);
+    const reason = textValue(decision.reason, '');
+    if (reason)
+        return `Coordinator decision: ${coordinatorDecisionLabel(textValue(job.coordinatorDecisionStatus ?? decision.status, 'resolved'))}. ${reason}`;
+    const column = taskBoardColumnId(job);
+    if (column === 'backlog')
+        return 'This is planned work that is not scheduled into the active swarm yet.';
+    if (column === 'todo')
+        return 'This work is queued for the AI-managed task backlog.';
+    if (column === 'review')
+        return 'The worker produced output that the coordinator should review before it is treated as landed work.';
+    if (column === 'ready')
+        return 'This task appears ready to apply or already has a clean readiness signal.';
+    if (column === 'blocked')
+        return 'This task is explicitly blocked by a dependency, missing decision, or an impossible requirement.';
+    if (column === 'done')
+        return 'This task has completed and is being kept visible as successful swarm output.';
+    return 'This task is still active or queued in the swarm run.';
+}
+function taskMarkdownSummary(job) {
+    const changed = formatNumber(numberValue(job.changedPathCount));
+    const evidence = formatNumber(numberValue(job.evidencePathCount));
+    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}`;
+}
+function coordinatorDecisionStatus(job) {
+    return textValue(job.coordinatorDecisionStatus ?? recordValue(job.coordinatorDecision).status, '');
+}
+function coordinatorDecisionLabel(status) {
+    const value = normalized(status);
+    if (value.includes('superseded'))
+        return 'Superseded';
+    if (value.includes('not-applicable'))
+        return 'Not applicable';
+    if (value.includes('accepted') || value.includes('applied'))
+        return 'Accepted';
+    if (value.includes('rejected'))
+        return 'Rejected';
+    return sentenceCaseIdentifier(status || 'resolved');
+}
+function coordinatorFacingSignalLabel(value) {
+    const raw = textValue(value, 'tracked task');
+    const normalizedValue = normalized(raw);
+    if (normalizedValue === 'needs-human-port' || normalizedValue === 'needs-coordinator-port')
+        return 'needs coordinator review';
+    if (normalizedValue === 'needs-human-review' || normalizedValue === 'needs-coordinator-review')
+        return 'needs coordinator review';
+    if (normalizedValue === 'needs-human-decision' || normalizedValue === 'needs-coordinator-decision')
+        return 'needs coordinator decision';
+    if (normalizedValue === 'failed-evidence')
+        return 'failed evidence';
+    if (normalizedValue === 'ready-to-apply')
+        return 'ready to apply';
+    if (normalizedValue === 'patch-candidate')
+        return 'patch candidate';
+    return sentenceCaseIdentifier(raw);
+}
+function taskTokenSummary(job) {
+    const actual = numberValue(job.actualInputTokens);
+    const uncached = numberValue(job.uncachedInputTokens);
+    const estimated = numberValue(job.estimatedInputTokens);
+    if (actual)
+        return `${formatNumber(actual)} input`;
+    if (uncached)
+        return `${formatNumber(uncached)} uncached`;
+    if (estimated)
+        return `${formatNumber(estimated)} est`;
+    return '-';
+}
+function taskReasonItems(job) {
+    return uniqueStrings([
+        ...stringArray(job.collectReasonClasses),
+        ...stringArray(job.reasons),
+        ...stringArray(job.contextBudgetWarnings),
+        ...stringArray(job.semanticReadinessReasons)
+    ]).slice(0, 8);
+}
+function taskFact(label, value) {
+    return _jsxs("div", { className: "task-fact", children: [_jsx("span", { children: label }), _jsx("b", { children: value || '-' })] });
+}
+function workKpi(label, value, detail) {
+    return _jsxs("article", { className: "work-kpi", children: [_jsx("span", { children: label }), _jsx("b", { children: text(value) }), _jsx("small", { children: detail })] });
+}
+function HumanActionQueue({ dashboard, jobs, audit }) {
+    const rows = humanActionRows(jobs, audit, dashboard);
+    return _jsx("div", { className: "action-layout", "data-scroll-id": "actions", children: _jsx(ActionList, { rows: rows, expanded: true }) });
+}
+function ActionList({ rows, expanded = false }) {
+    if (!rows.length)
+        return _jsx("p", { className: "empty tight", children: "No open questions from agents right now." });
+    return _jsx("div", { className: expanded ? 'action-list expanded' : 'action-list', children: rows.map((row) => _jsxs("article", { className: `action-row ${row.priority}`, "data-human-question-code": row.code, children: [_jsxs("div", { className: "action-code", children: [_jsx("b", { children: row.code }), _jsx("button", { type: "button", "data-copy-code": row.code, title: `Copy ${row.code}`, children: "Copy" })] }), _jsxs("div", { className: "action-copy", children: [_jsxs("span", { children: [row.askedBy || 'Agent question', row.scope ? ` · ${row.scope}` : ''] }), _jsx("h4", { children: row.title }), _jsx("p", { children: row.question }), expanded && row.why ? _jsxs("small", { children: ["Why: ", row.why] }) : null, expanded && row.detail !== row.question ? _jsxs("small", { children: ["Context: ", row.detail] }) : null, expanded ? _jsxs("small", { children: ["Requested answer: ", row.requestedAnswer || row.defaultAction] }) : null, expanded ? _jsx(HumanActionAnswerForm, { row: row }) : null] })] })) });
+}
+function HumanActionAnswerForm({ row }) {
+    const state = humanAnswerStates.get(row.code);
+    const answer = humanAnswerDrafts.get(row.code) ?? '';
+    return _jsxs("form", { className: "action-answer-form", "data-human-answer-form": "true", "data-human-answer-code": row.code, children: [_jsx("textarea", { name: "answer", "data-human-answer-code": row.code, rows: 3, placeholder: `Answer ${row.code}...`, "aria-label": `Answer ${row.code}`, children: answer }), _jsxs("div", { children: [_jsx("button", { type: "submit", disabled: state?.status === 'submitting', children: state?.status === 'submitting' ? 'Submitting...' : 'Submit answer' }), state ? _jsx("small", { className: `action-answer-status ${state.status}`, children: state.message }) : null] })] });
+}
+function PerformanceView({ dashboard, jobs, attention, audit }) {
+    const telemetry = tokenTimeSummary(dashboard, jobs);
+    const context = contextPressureSummary(jobs);
+    const cost = modelCostSummary(jobs);
+    const timeCharts = performanceTimeChartSeries(dashboard, jobs);
+    const optimization = optimizationSignalSummary(dashboard, jobs);
+    const behavior = optimizationBehaviorSummary(dashboard, jobs);
+    const topContext = contextOffenderRows(jobs);
+    const topCosts = modelCostRows(jobs);
+    return _jsxs("div", { className: "performance-layout", "data-scroll-id": "performance", "data-smoke-marker": "performance-tab", children: [_jsxs("section", { className: "performance-summary", children: [workKpi('Estimated cost', cost.value, cost.detail), workKpi('Input tokens', telemetry.tokenValue, telemetry.tokenDetail), workKpi('Runtime', telemetry.durationValue, telemetry.durationDetail), workKpi('Cache hit', context.cacheHitRatio ? formatPercent(context.cacheHitRatio) : '-', context.actualInputTokens ? `${formatNumber(context.cachedInputTokens)} cached` : 'no cache data'), workKpi('Waste signals', context.warningCount + context.failedCount + attention.failedCount + attention.blockedCount + generatedNoiseCount(audit), 'budget, failure, blocked, and generated-noise signals')] }), _jsxs("section", { className: "work-section performance-chart-section", children: [_jsxs("div", { className: "metric-section-head", children: [_jsx("h3", { children: "Performance over time" }), _jsx("span", { children: performanceTimeDetail(dashboard) })] }), _jsx(MiniCharts, { series: timeCharts })] }), _jsxs("section", { className: "work-section performance-chart-section", children: [_jsxs("div", { className: "metric-section-head", children: [_jsx("h3", { children: "Optimization signals" }), _jsx("span", { children: optimization.status })] }), _jsx("div", { className: "optimization-signal-grid", children: optimization.rows.map((row) => _jsxs("article", { className: `optimization-signal ${row.tone}`, children: [_jsx("span", { children: row.label }), _jsx("b", { children: row.value }), _jsx("small", { children: row.detail })] })) })] }), _jsxs("section", { className: "work-section optimization-behavior-section", children: [_jsxs("div", { className: "metric-section-head", children: [_jsx("h3", { children: "Workflow behavior trend" }), _jsx("span", { children: behavior.status })] }), _jsx("div", { className: "optimization-behavior-grid", children: behavior.cards.map((card) => _jsxs("article", { className: `optimization-behavior-card ${card.tone}`, children: [_jsx("span", { children: card.label }), _jsx("b", { children: card.value }), _jsx("small", { children: card.detail })] })) }), _jsx("div", { className: "optimization-behavior-list", children: behavior.rows.map((row) => _jsxs("article", { className: `optimization-behavior-row ${row.tone}`, children: [_jsxs("div", { children: [_jsx("b", { children: row.label }), _jsx("small", { children: row.detail })] }), _jsx("span", { children: row.value })] })) })] }), _jsxs("section", { className: "work-section performance-split", children: [_jsxs("div", { children: [_jsxs("div", { className: "metric-section-head", children: [_jsx("h3", { children: "Top cost drivers" }), _jsxs("span", { children: [text(Math.max(topCosts.length, topContext.length)), " tasks"] })] }), _jsx(SimpleRows, { rows: topCosts.length ? topCosts : topContext.map((job) => ({
+                                    label: job.label,
+                                    value: formatNumber(job.uncachedInputTokens || job.actualInputTokens || job.estimatedInputTokens),
+                                    detail: contextDriverDetail(job)
+                                })) })] }), _jsxs("div", { children: [_jsxs("div", { className: "metric-section-head", children: [_jsx("h3", { children: "Waste breakdown" }), _jsx("span", { children: riskStatusLabel(dashboard, attention, jobs.length > 0) })] }), _jsx(BarRows, { rows: performanceWasteRows(jobs, attention, audit, context) })] })] })] });
+}
+function HistoryView({ dashboard, jobs, events, success, attention }) {
+    const graph = historyGitGraph(dashboard, jobs);
+    return _jsxs("div", { className: "history-layout", "data-scroll-id": "history", "data-smoke-marker": "history-tab", children: [_jsxs("section", { className: "work-section history-graph-section git-history-section", children: [_jsxs("div", { className: "metric-section-head", children: [_jsx("h3", { children: "Version history" }), _jsxs("span", { children: [text(graph.rows.length), " nodes \u00B7 ", text(graph.lanes.length), " lanes"] })] }), _jsx(HistoryGitGraph, { graph: graph })] }), _jsxs("section", { className: "work-section history-split", children: [_jsxs("div", { children: [_jsxs("div", { className: "metric-section-head", children: [_jsx("h3", { children: "Merge state" }), _jsxs("span", { children: [formatNumber(success.appliedCount), " applied \u00B7 ", formatNumber(success.landedCount), " landed"] })] }), _jsx(SimpleRows, { rows: [
+                                    { label: 'Ready', value: formatNumber(success.readyCount), detail: 'outputs that appear ready to apply' },
+                                    { label: 'Coordinator review', value: formatNumber(attention.needsCoordinatorReviewCount), detail: 'outputs waiting on coordinator judgement' },
+                                    { label: 'Review / blocked', value: formatNumber(attention.failedCount + attention.needsCoordinatorReviewCount + attention.staleCount + attention.blockedCount), detail: 'outputs needing coordinator decision or explicit unblock' },
+                                    { label: 'Snapshot', value: formatTime(dashboard.generatedAt), detail: dashboardSourceLabel(dashboard) }
+                                ] })] }), _jsxs("div", { children: [_jsxs("div", { className: "metric-section-head", children: [_jsx("h3", { children: "Recent events" }), _jsxs("span", { children: [text(events.length), " visible"] })] }), _jsx(HistoryEventRows, { events: events })] })] })] });
+}
+function HistoryGitGraph({ graph }) {
+    if (!graph.rows.length)
+        return _jsx("p", { className: "empty tight", children: "No task history has been reported yet." });
+    return _jsx("div", { className: "git-history-viewport", children: _jsxs("div", { className: "git-history-grid", style: `--history-row-height:${graph.rowHeight}px; --history-graph-width:${graph.width}px; --history-graph-height:${graph.height}px`, children: [_jsx("div", { className: "git-graph-canvas", "aria-hidden": "true", children: _jsxs("svg", { className: "git-graph-svg", viewBox: `0 0 ${graph.width} ${graph.height}`, width: graph.width, height: graph.height, children: [graph.lanes.map((lane) => _jsx("path", { className: "git-graph-rail", d: `M ${lane.x} 14 V ${Math.max(14, graph.height - 14)}`, stroke: lane.color })), graph.rows.filter((row) => row.laneIndex > 0).map((row) => _jsx("path", { className: row.merged ? 'git-graph-merge' : 'git-graph-branch', d: historyCurvePath(graph.trunkX, row.x, row.y), stroke: historyLaneColor(graph, row.laneId) })), graph.rows.filter((row) => row.merged && row.laneIndex > 0).map((row) => _jsx("circle", { className: `git-graph-node trunk ${row.tone}`, cx: graph.trunkX, cy: row.y, r: "4", stroke: historyLaneColor(graph, 'main'), "data-chart-tooltip": `${row.title}\nMerged to main\n${row.meta}` })), graph.rows.map((row) => _jsx("circle", { className: `git-graph-node ${row.tone}`, cx: row.x, cy: row.y, r: "5", stroke: historyLaneColor(graph, row.laneId), "data-chart-tooltip": row.tooltip }))] }) }), _jsx("div", { className: "git-history-rows", children: graph.rows.map((row) => _jsxs("button", { type: "button", className: `git-history-row ${row.tone}`, "data-task-card": row.id, "data-chart-tooltip": row.tooltip, "aria-label": row.tooltip.replace(/\n/g, '. '), style: `height:${graph.rowHeight}px`, children: [_jsxs("div", { children: [_jsx("b", { children: row.title }), _jsx("small", { children: row.subtitle })] }), _jsx("span", { children: row.meta })] })) })] }) });
+}
+function LegacyHistoryBranchList({ jobs }) {
+    const branches = historyBranchRows(jobs);
+    return _jsxs("section", { className: "work-section", children: [_jsxs("div", { className: "metric-section-head", children: [_jsx("h3", { children: "Version lanes" }), _jsxs("span", { children: [text(branches.length), " recent task outputs"] })] }), _jsx("div", { className: "history-branches", children: branches.length ? branches.map((job) => _jsxs("article", { className: `history-branch ${jobRisk(job)}`, children: [_jsx("span", { className: "history-branch-rail", "aria-hidden": "true" }), _jsxs("div", { children: [_jsxs("b", { children: [ticketId(job), " \u00B7 ", taskTitle(job)] }), _jsxs("small", { children: [laneOf(job), " \u00B7 ", taskCardStatus(job), " \u00B7 ", pathSummaryText(job)] })] }), _jsx("span", { children: jobRuntimeLabel(job, Date.now()) })] })) : _jsx("p", { className: "empty tight", children: "No task outputs are available for this history view yet." }) })] });
+}
+function TestingView({ jobs, events }) {
+    const summary = testingSummary(jobs, events);
+    return _jsxs("div", { className: "testing-layout", "data-scroll-id": "testing", "data-smoke-marker": "testing-tab", children: [_jsxs("section", { className: "testing-summary", children: [workKpi('Checks passing', summary.totalChecks ? `${formatNumber(summary.passedChecks)}/${formatNumber(summary.totalChecks)}` : '-', summary.totalChecks ? `${formatNumber(summary.failedChecks)} failing` : 'no command metadata'), workKpi('Active work', summary.activeJobs ? formatNumber(summary.activeJobs) : '0', summary.activeJobs ? 'verification still pending' : 'no running tasks'), workKpi('Browser evidence', summary.browserEvidence ? formatNumber(summary.browserEvidence) : '-', 'Playwright, screenshot, DOM, or browser artifacts'), workKpi('Fuzzing', summary.fuzzEvidence ? formatNumber(summary.fuzzEvidence) : '-', 'fuzz or property-test evidence paths'), workKpi('Oracles', summary.oracleEvidence ? formatNumber(summary.oracleEvidence) : '-', 'oracle, golden, fixture, or snapshot evidence')] }), summary.notice ? _jsx("p", { className: `testing-notice ${summary.noticeTone}`, children: summary.notice }) : null, _jsxs("section", { className: "work-section testing-split", children: [_jsxs("div", { children: [_jsxs("div", { className: "metric-section-head", children: [_jsx("h3", { children: "Quality status" }), _jsx("span", { children: summary.status })] }), _jsx(BarRows, { rows: [
+                                    { label: 'Passed checks', value: summary.passedChecks, detail: formatNumber(summary.passedChecks), tone: summary.passedChecks ? 'good' : 'neutral' },
+                                    { label: 'Failed checks', value: summary.failedChecks, detail: formatNumber(summary.failedChecks), tone: summary.failedChecks ? 'bad' : 'neutral' },
+                                    { label: 'Active work', value: summary.activeJobs, detail: `${formatNumber(summary.activeJobs)} tasks`, tone: summary.activeJobs ? 'warn' : 'neutral' },
+                                    { label: 'Missing metadata', value: summary.noMetadataTasks, detail: `${formatNumber(summary.noMetadataTasks)} tasks`, tone: summary.noMetadataTasks ? 'warn' : 'neutral' },
+                                    { label: 'Evidence-backed tasks', value: summary.evidenceTasks, detail: `${formatNumber(summary.evidenceTasks)} tasks`, tone: 'neutral' },
+                                    { label: 'Open failures', value: summary.openFailures, detail: `${formatNumber(summary.openFailures)} tasks`, tone: summary.openFailures ? 'bad' : 'neutral' }
+                                ] })] }), _jsxs("div", { children: [_jsxs("div", { className: "metric-section-head", children: [_jsx("h3", { children: "Evidence mix" }), _jsxs("span", { children: [formatNumber(summary.evidencePaths), " paths"] })] }), _jsxs("div", { className: "testing-evidence-grid", children: [testingEvidenceCard('Browser', summary.browserEvidence, 'UI, screenshot, DOM, or Playwright'), testingEvidenceCard('Fuzzing', summary.fuzzEvidence, 'fuzz/property runs'), testingEvidenceCard('Oracle', summary.oracleEvidence, 'golden/reference checks'), testingEvidenceCard('Unit / smoke', summary.unitEvidence, 'test, smoke, or spec output')] })] })] }), _jsxs("section", { className: "work-section", children: [_jsxs("div", { className: "metric-section-head", children: [_jsx("h3", { children: "Recent check output" }), _jsxs("span", { children: [formatNumber(summary.rows.length), " tasks"] })] }), _jsx("div", { className: "testing-rows", children: summary.rows.length ? summary.rows.map((row) => _jsxs("article", { className: `testing-row ${row.tone}`, children: [_jsxs("div", { className: "testing-row-copy", children: [_jsx("b", { children: row.label }), _jsx("div", { className: "testing-row-meta", children: row.detailParts.map((part) => _jsx("small", { children: part })) })] }), _jsx("span", { children: row.value })] })) : _jsx("p", { className: "empty tight", children: "No check metadata has been reported yet. This is not the same as passing tests." }) })] })] });
+}
+function Metrics({ dashboard, lanes, jobs, events, attention, audit }) {
+    const telemetry = tokenTimeSummary(dashboard, jobs);
+    const context = contextPressureSummary(jobs);
+    const topContext = contextOffenderRows(jobs);
+    const usefulOutput = jobs.length ? successLikeJobCount(jobs) / jobs.length : 0;
+    void lanes;
+    return _jsxs("div", { className: "efficiency-layout", "data-scroll-id": "efficiency", children: [_jsxs("section", { className: "efficiency-summary", children: [workKpi('Useful output rate', formatPercent(usefulOutput), `${text(successLikeJobCount(jobs))} useful of ${text(jobs.length)}`), workKpi('Uncached tokens', formatNumber(context.uncachedInputTokens), `${telemetry.tokenValue} total input`), workKpi('Budget warnings', context.warningCount + context.failedCount, `${text(context.failedCount)} failed budget`), workKpi('Runtime', telemetry.durationValue, telemetry.durationDetail), workKpi('Events', events.length, 'visible event rows')] }), _jsxs("section", { className: "work-section", children: [_jsxs("div", { className: "metric-section-head", children: [_jsx("h3", { children: "Top cost drivers" }), _jsxs("span", { children: [text(topContext.length), " tasks"] })] }), _jsx(SimpleRows, { rows: topContext.map((job) => ({
+                            label: job.label,
+                            value: formatNumber(job.uncachedInputTokens || job.actualInputTokens || job.estimatedInputTokens),
+                            detail: contextDriverDetail(job)
+                        })) })] }), _jsxs("section", { className: "work-section", children: [_jsxs("div", { className: "metric-section-head", children: [_jsx("h3", { children: "Performance concerns" }), _jsx("span", { children: riskStatusLabel(dashboard, attention, jobs.length > 0) })] }), _jsx(SimpleRows, { rows: [
+                            { label: 'Coordinator review', value: text(attention.failedCount + attention.needsCoordinatorReviewCount + attention.staleCount), detail: 'failed, stale, or coordinator-review outputs' },
+                            { label: 'Blocked', value: text(attention.blockedCount), detail: 'explicit dependency or impossible-task blocks' },
+                            { label: 'Source ownership risk', value: text(audit.sourceOwnershipViolationCount), detail: 'outside declared source ownership' },
+                            { label: 'Generated noise', value: text(generatedNoiseCount(audit)), detail: 'ignored generated/cache output' },
+                            { label: 'Context warning jobs', value: text(context.warningCount), detail: 'higher token/cost risk' }
+                        ] })] })] });
+}
+function MergeView({ dashboard, jobs, success, attention }) {
+    const semantic = semanticMetrics(dashboard.semantic);
+    const stages = [
+        { id: 'workers', label: 'Worker outputs', value: jobs.length, tone: 'neutral' },
+        { id: 'review', label: 'Coordinator review', value: attention.needsCoordinatorReviewCount, tone: attention.needsCoordinatorReviewCount ? 'warn' : 'neutral' },
+        { id: 'ready', label: 'Ready', value: success.readyCount, tone: success.readyCount ? 'good' : 'neutral' },
+        { id: 'applied', label: 'Applied', value: success.appliedCount, tone: success.appliedCount ? 'good' : 'neutral' },
+        { id: 'blocked', label: 'Blocked', value: attention.failedCount + attention.staleCount, tone: attention.failedCount + attention.staleCount ? 'bad' : 'neutral' }
+    ];
+    return _jsxs("div", { className: "merge-layout", "data-scroll-id": "merge", children: [_jsx("section", { className: "merge-flow", "aria-label": "Semantic merge and patch flow", children: stages.map((stage) => _jsxs("article", { className: `merge-node ${stage.tone}`, children: [_jsx("span", { children: stage.label }), _jsx("b", { children: text(stage.value) })] })) }), _jsxs("section", { className: "work-section", children: [_jsxs("div", { className: "metric-section-head", children: [_jsx("h3", { children: "Semantic merge status" }), _jsxs("span", { children: [formatNumber(semantic.total), " signals"] })] }), _jsx(SimpleRows, { rows: [
+                            { label: 'Auto-merge candidates', value: formatNumber(semantic.autoMerge), detail: 'semantic scripts that may be portable' },
+                            { label: 'Replay accepted clean', value: formatNumber(semantic.acceptedClean), detail: 'clean semantic replay outcomes' },
+                            { label: 'Replay conflicts', value: formatNumber(semantic.conflicts), detail: 'must be reviewed before merge' },
+                            { label: 'Expected imports satisfied', value: `${formatNumber(semantic.satisfied)}/${formatNumber(semantic.expected)}`, detail: 'semantic import coverage' }
+                        ] })] }), _jsxs("section", { className: "work-section", children: [_jsxs("div", { className: "metric-section-head", children: [_jsx("h3", { children: "Patch/version tree" }), _jsxs("span", { children: [text(jobs.length), " worker leaves"] })] }), _jsx("div", { className: "version-tree", children: jobs.slice(0, 18).map((job) => _jsxs("article", { className: `version-leaf ${jobRisk(job)}`, children: [_jsx("b", { children: text(job.id) }), _jsxs("small", { children: [text(job.disposition ?? job.mergeReadiness ?? job.status), " \u00B7 ", pathSummaryText(job)] })] })) })] })] });
+}
+function EvidenceView({ jobs, events, sourceEntries, dashboard }) {
+    return _jsxs("div", { className: "evidence-layout", "data-scroll-id": "evidence", children: [_jsxs("section", { className: "work-section", children: [_jsxs("div", { className: "metric-section-head", children: [_jsx("h3", { children: "Jobs" }), _jsxs("span", { children: [text(jobs.length), " visible"] })] }), _jsx(Jobs, { jobs: jobs })] }), _jsxs("section", { className: "work-section", children: [_jsxs("div", { className: "metric-section-head", children: [_jsx("h3", { children: "Events" }), _jsxs("span", { children: [text(events.length), " visible"] })] }), _jsx(Events, { events: events })] }), _jsxs("section", { className: "work-section", children: [_jsxs("div", { className: "metric-section-head", children: [_jsx("h3", { children: "Sources" }), _jsxs("span", { children: [text(sourceEntries.length), " paths"] })] }), _jsx(Sources, { entries: sourceEntries })] }), _jsxs("section", { className: "work-section", children: [_jsxs("div", { className: "metric-section-head", children: [_jsx("h3", { children: "Run context" }), _jsx("span", { children: "readonly" })] }), _jsx(RunContext, { routing: dashboard.routing, backlog: dashboard.backlog })] })] });
+}
+function Overview({ dashboard, lanes, jobs, events, attention, audit, success }) {
+    const health = dashboardHealthSummary(dashboard, jobs, attention);
+    const telemetry = tokenTimeSummary(dashboard, jobs);
+    const pressure = warningPressureSummary(attention, audit, health, telemetry);
+    const progressCharts = progressChartSeries(dashboard, jobs, events).slice(0, 3);
+    return _jsxs("section", { className: "overview-grid", children: [_jsxs("section", { className: "overview-snapshot", "data-smoke-marker": "landed-health-summary", "aria-label": "Landed success, health, warning pressure, token, and time snapshot", children: [snapshotTile('Run health', health.status, `${formatPercent(health.completionRatio)} complete · ${text(health.failedJobCount + health.blockedJobCount)} failed/blocked`, health.tone), snapshotTile('Applied / landed', `${formatNumber(success.appliedCount)}/${formatNumber(success.applyTotalCount || success.appliedCount || success.landedCount)}`, `${formatNumber(success.landedCount)} landed · ${formatNumber(success.applyFailedCount)} ledger failed`, success.applyFailedCount ? 'bad' : success.appliedCount || success.landedCount ? 'good' : 'neutral'), snapshotTile('Warning pressure', pressure.headline, pressure.detail, pressure.tone), snapshotTile('Token load', telemetry.tokenValue, telemetry.tokenDetail, telemetry.tokenTone), snapshotTile('Run time', telemetry.durationValue, telemetry.durationDetail, telemetry.timeTone)] }), _jsx(Panel, { title: "Run health", meta: `${text(jobs.length)} visible jobs`, children: _jsxs("div", { className: "overview-card-scroll", children: [_jsx(RunHealthSummary, { health: health }), _jsxs("div", { className: "overview-metrics", children: [compactMetric('Healthy', health.healthyJobCount), compactMetric('Warning', health.warningJobCount), compactMetric('Failed', health.failedJobCount), compactMetric('Terminal', health.terminalJobCount), compactMetric('Ready', health.readyToApplyJobCount), compactMetric('Semantic clean', health.semanticCleanJobCount)] }), _jsx(MiniCharts, { series: progressCharts, compact: true })] }) }), _jsx(Panel, { title: "Warning pressure", meta: `${formatNumber(pressure.total)} signals`, children: _jsxs("div", { className: "overview-card-scroll pressure-panel", "data-smoke-marker": "warning-pressure", children: [_jsxs("div", { className: "pressure-grid", children: [pressureCell('Merge blockers', pressure.severe, pressure.severe ? 'failed, blocked, or source' : 'none'), pressureCell('Budget warnings', pressure.budget, pressure.budget ? 'context load' : 'within budget'), pressureCell('Timing gaps', telemetry.missingTimestampCount, telemetry.missingTimestampCount ? 'estimated spans' : 'current timestamps')] }), _jsx(BarRows, { rows: pressure.rows })] }) }), _jsx(Panel, { title: "Workspace audit", meta: `${text(audit.changedPathCount)} changed paths`, children: _jsxs("div", { className: "overview-card-scroll", children: [_jsxs("div", { className: "audit-list", children: [auditRow('Patch candidates', audit.changedPathCount), auditRow('Source violations', audit.sourceOwnershipViolationCount), auditRow('Generated noise', generatedNoiseCount(audit)), auditRow('Quarantined paths', audit.quarantinedChangedPathCount)] }), _jsx(ReasonClasses, { audit: audit })] }) }), _jsx(Panel, { title: "Recent activity", meta: `${text(events.length)} visible events`, children: _jsx("div", { className: "overview-card-scroll", children: _jsx(Events, { events: events.slice(-10) }) }) })] });
+}
+function snapshotTile(label, value, detail, tone) {
+    return _jsxs("article", { className: `snapshot-tile ${tone}`, children: [_jsx("span", { children: label }), _jsx("b", { children: value }), _jsx("small", { children: detail })] });
+}
+function Success({ dashboard, jobs, success }) {
+    const completedJobs = jobs.filter(isCompletedJob);
+    const readyJobs = jobs.filter(isReadyJob);
+    const cleanJobs = jobs.filter((job) => sourceOwnershipViolations(job).length === 0 && numberValue(job.quarantinedChangedPathCount) === 0);
+    const semanticRows = semanticSuccessRows(dashboard.semantic);
+    return _jsxs("div", { className: "success-layout", "data-scroll-id": "success", children: [_jsxs("section", { className: "success-summary", "data-smoke-marker": "success-summary", children: [successKpi('Completed jobs', success.completedCount, `${text(completedJobs.length)} visible`), successKpi('Ready patches', success.readyCount, 'direct apply candidates'), successKpi('Applied patches', success.appliedCount, `${text(success.applyTotalCount)} ledger total`), successKpi('Landed patches', success.landedCount, 'apply ledger entries'), successKpi('Source-clean jobs', success.cleanSourceCount, 'no source ownership flags'), successKpi('Evidence complete', success.evidenceCompleteCount, 'jobs with artifacts'), successKpi('Replay clean', success.semanticAcceptedClean, 'semantic replay accepted'), successKpi('Already applied', success.semanticAlreadyApplied, 'semantic edits recognized')] }), _jsxs("section", { className: "success-section", children: [_jsxs("div", { className: "metric-section-head", children: [_jsx("h3", { children: "Successful worker output" }), _jsxs("span", { children: [text(completedJobs.length), " visible completed jobs"] })] }), _jsx(SuccessRows, { jobs: completedJobs.slice(0, 24) })] }), _jsxs("section", { className: "success-section", children: [_jsxs("div", { className: "metric-section-head", children: [_jsx("h3", { children: "Ready or clean signals" }), _jsxs("span", { children: [text(readyJobs.length), " ready \u00B7 ", text(cleanJobs.length), " source-clean"] })] }), _jsx(BarRows, { rows: [
+                            { label: 'Completed', value: success.completedCount, tone: 'good' },
+                            { label: 'Ready patches', value: success.readyCount, tone: success.readyCount ? 'good' : 'neutral' },
+                            { label: 'Applied patches', value: success.appliedCount, tone: success.applyFailedCount ? 'bad' : success.appliedCount ? 'good' : 'neutral' },
+                            { label: 'Landed patches', value: success.landedCount, tone: success.landedCount ? 'good' : 'neutral' },
+                            { label: 'Source-clean', value: success.cleanSourceCount, tone: 'good' },
+                            { label: 'Evidence complete', value: success.evidenceCompleteCount, tone: 'good' }
+                        ] })] }), semanticRows.length ? _jsxs("section", { className: "success-section wide", children: [_jsxs("div", { className: "metric-section-head", children: [_jsx("h3", { children: "Semantic success" }), _jsxs("span", { children: [text(success.semanticAcceptedClean + success.semanticAlreadyApplied), " accepted/applied"] })] }), _jsx(BarRows, { rows: semanticRows })] }) : null] });
+}
+function successKpi(label, value, detail) {
+    return _jsxs("div", { className: "success-kpi", children: [_jsx("span", { children: label }), _jsx("b", { children: text(value) }), _jsx("small", { children: detail })] });
+}
+function SuccessRows({ jobs }) {
+    if (!jobs.length)
+        return _jsx("p", { className: "empty tight", children: "No completed jobs in this run." });
+    return _jsx("div", { className: "success-list", children: jobs.map((job) => _jsxs("article", { className: "success-row", children: [_jsx("span", { className: "mono", children: text(job.id) }), _jsx("b", { children: text(job.disposition ?? job.mergeReadiness ?? job.status) }), _jsxs("small", { children: [text(laneOf(job)), " \u00B7 ", text(job.evidencePathCount), " evidence \u00B7 ", pathSummaryText(job)] })] })) });
+}
+function Jobs({ jobs }) {
+    if (!jobs.length)
+        return _jsx("div", { className: "table-scroll jobs-scroll", "data-scroll-id": "jobs", children: _jsx("p", { className: "empty", children: "No jobs are available for this run." }) });
+    return _jsx("div", { className: "table-scroll jobs-scroll", "data-scroll-id": "jobs", children: _jsxs("table", { className: "jobs-table", children: [_jsx("thead", { children: _jsxs("tr", { children: [_jsx("th", { className: "nowrap", children: "Risk" }), _jsx("th", { children: "Job / task" }), _jsx("th", { className: "nowrap", children: "Lane" }), _jsx("th", { className: "nowrap", children: "Status" }), _jsx("th", { children: "Bucket / disposition" }), _jsx("th", { children: "Paths" }), _jsx("th", { className: "nowrap", children: "Evidence" }), _jsx("th", { children: "Reasons" })] }) }), _jsx("tbody", { children: jobs.slice(0, 160).map((job) => _jsxs("tr", { className: `risk-${jobRisk(job)}`, children: [_jsx("td", { children: _jsx("span", { className: `risk-pill ${jobRisk(job)}`, children: jobRiskLabel(job) }) }), _jsxs("td", { children: [_jsx("span", { className: "mono strong", children: text(job.id) }), _jsx("small", { children: text(job.taskId ?? job.title) })] }), _jsx("td", { className: "lane-cell", title: text(job.lane), children: text(job.lane) }), _jsx("td", { className: "nowrap", children: text(job.status) }), _jsxs("td", { children: [_jsx("span", { children: text(job.bucket) }), _jsx("small", { children: text(job.disposition ?? job.mergeReadiness) })] }), _jsx("td", { children: pathSummary(job) }), _jsx("td", { className: "numeric", children: text(job.evidencePathCount) }), _jsx("td", { children: jobReasonText(job) })] })) })] }) });
+}
+function statCell(label, value) {
+    return _jsxs("div", { className: "stat-cell", children: [_jsx("span", { children: label }), _jsx("b", { children: value })] });
+}
+function ContextPressure({ jobs }) {
+    const summary = contextPressureSummary(jobs);
+    const offenders = contextOffenderRows(jobs);
+    return _jsxs("div", { className: "context-pressure", "data-smoke-marker": "context-pressure", children: [_jsxs("div", { className: "stat-grid", children: [statCell('Budget warnings', formatNumber(summary.warningCount)), statCell('Uncached input', summary.uncachedInputTokens ? formatNumber(summary.uncachedInputTokens) : '-'), statCell('Uncached / estimated', summary.uncachedRatio ? formatRatio(summary.uncachedRatio) : '-')] }), _jsx(BarRows, { rows: [
+                    { label: 'Uncached input', value: summary.uncachedInputTokens, detail: formatNumber(summary.uncachedInputTokens), tone: summary.warningCount || summary.failedCount ? 'warn' : 'neutral' },
+                    { label: 'Cached input', value: summary.cachedInputTokens, detail: formatNumber(summary.cachedInputTokens) },
+                    { label: 'Actual total', value: summary.actualInputTokens, detail: formatNumber(summary.actualInputTokens) },
+                    { label: 'Estimated tokens', value: summary.estimatedInputTokens, detail: formatNumber(summary.estimatedInputTokens) },
+                    { label: 'P95 uncached', value: summary.p95UncachedInputTokens, detail: formatNumber(summary.p95UncachedInputTokens), tone: summary.p95UncachedInputTokens > summary.estimatedInputTokens / Math.max(1, jobs.length) ? 'warn' : 'neutral' }
+                ] }), _jsx("div", { className: "context-offender-list", "aria-label": "Top context offenders", children: offenders.length ? offenders.map((job) => _jsxs("article", { className: "context-offender-row", children: [_jsx("span", { className: "mono", children: text(job.id) }), _jsx("b", { children: formatNumber(job.uncachedInputTokens || job.actualInputTokens || job.estimatedInputTokens) }), _jsxs("small", { children: [text(job.lane), " \u00B7 ", job.statusLabel] })] })) : _jsx("p", { className: "empty tight", children: "No context pressure reported for visible jobs." }) })] });
+}
+function MiniCharts({ series, compact = false }) {
+    if (!series.length)
+        return _jsx("p", { className: "empty tight", children: "No chart data." });
+    return _jsx("div", { className: compact ? 'chart-grid compact' : 'chart-grid', children: series.map((entry) => _jsxs("article", { className: `chart-card ${entry.tone ?? 'neutral'}`, "data-chart-id": entry.id, children: [_jsxs("div", { className: "chart-card-head", children: [_jsx("span", { children: entry.title }), _jsx("b", { children: entry.value })] }), _jsx(Sparkline, { points: entry.points, tone: entry.tone ?? 'neutral', label: `${entry.title}: ${entry.value}` }), compact ? null : _jsx("small", { children: chartDetailLabel(entry) })] })) });
+}
+function chartDetailLabel(entry) {
+    const axis = entry.xLabel || entry.yLabel
+        ? `Y: ${entry.yLabel ?? 'value'} · X: ${entry.xLabel ?? 'series'}`
+        : '';
+    return axis ? `${axis} · ${entry.detail}` : entry.detail;
+}
+function RunHealthSummary({ health }) {
+    return _jsxs("div", { className: "health-summary", "data-smoke-marker": "health-summary", children: [_jsxs("article", { className: `health-card ${health.tone}`, children: [_jsx("span", { children: "Run status" }), _jsx("b", { children: health.status }), _jsxs("small", { children: [formatPercent(health.completionRatio), " complete \u00B7 ", formatPercent(health.failureRatio), " failed/blocked"] })] }), _jsxs("article", { className: health.warningJobCount ? 'health-card warn' : 'health-card good', children: [_jsx("span", { children: "Warnings" }), _jsx("b", { children: text(health.warningJobCount) }), _jsxs("small", { children: [text(health.contextWarningJobCount), " context \u00B7 ", text(health.semanticCandidateJobCount), " semantic candidates"] })] }), _jsxs("article", { className: health.failedJobCount || health.blockedJobCount ? 'health-card bad' : 'health-card good', children: [_jsx("span", { children: "Success" }), _jsx("b", { children: text(health.healthyJobCount) }), _jsxs("small", { children: [text(health.readyToApplyJobCount), " ready \u00B7 ", text(health.semanticCleanJobCount), " semantic clean"] })] })] });
+}
+function Sparkline({ points, tone, label }) {
+    const visible = points.length ? points : [{ label: 'No data', value: 0 }];
+    const max = Math.max(1, ...visible.map((point) => point.value));
+    return _jsx("div", { className: `sparkline aligned-chart ${tone}`, role: "img", "aria-label": label, "data-chart-points": text(visible.length), children: _jsx("div", { className: "spark-bars", children: visible.map((point) => _jsx("span", { className: `spark-bar ${point.tone ?? tone}`, "data-chart-tooltip": `${point.label}\n${point.detail ?? formatNumber(point.value)}`, title: `${point.label}: ${point.detail ?? formatNumber(point.value)}`, style: `height:${point.value ? Math.max(8, Math.round((point.value / max) * 100)) : 3}%` })) }) });
+}
+function BarRows({ rows }) {
+    const max = Math.max(1, ...rows.map((row) => row.value));
+    return _jsx("div", { className: "metric-bars", children: rows.map((row) => _jsxs("div", { className: "metric-bar-row", children: [_jsx("span", { className: "metric-bar-label", children: row.label }), _jsx("span", { className: "metric-bar-track", children: _jsx("span", { className: `metric-bar-fill ${row.tone ?? 'neutral'}`, style: `width:${row.value ? Math.max(3, Math.round((row.value / max) * 100)) : 0}%` }) }), _jsx("span", { className: "metric-bar-value", children: row.detail ?? formatNumber(row.value) })] })) });
+}
+function Quality({ jobs, attention, audit }) {
+    const sourceOwnershipCount = audit.sourceOwnershipViolationCount;
+    const ignoredCount = generatedNoiseCount(audit);
+    const quarantinedCount = audit.quarantinedChangedPathCount;
+    const blockerCount = attention.failedCount + attention.needsCoordinatorReviewCount + attention.staleCount + sourceOwnershipCount;
+    const noiseCount = ignoredCount + quarantinedCount;
+    return _jsxs("div", { className: "quality-layout", "data-smoke-marker": "quality-signal-panel", "data-scroll-id": "quality", children: [_jsxs("section", { className: "quality-summary", "data-smoke-marker": "quality-summary", children: [qualityKpi('Admission blockers', blockerCount, blockerCount ? 'Review before merge' : 'Clear'), qualityKpi('Generated workspace noise', noiseCount, noiseCount ? 'Separated from source' : 'None'), qualityKpi('Visible jobs', jobs.length, 'Current lane filter')] }), _jsxs("section", { className: "quality-group blocker", "data-smoke-marker": "quality-real-blockers", children: [_jsxs("div", { className: "quality-group-head", children: [_jsx("h3", { children: "Real blockers" }), _jsxs("span", { children: [text(blockerCount), " signals"] })] }), _jsxs("div", { className: "quality-signal-list", children: [qualitySignal('Failed jobs', attention.failedCount, 'Blocks admission', 'Worker failed, evidence failed, or merge readiness failed.', 'failed-jobs'), qualitySignal('Coordinator review', attention.needsCoordinatorReviewCount, 'Coordinator decision', 'Patch needs review or cannot be applied directly.', 'needs-coordinator'), qualitySignal('Stale', attention.staleCount, 'Rerun or rebase', 'Output was collected against an older source state.', 'stale'), qualitySignal('Source violations', sourceOwnershipCount, 'Out of scope source', 'Changed source paths are outside the job ownership boundary.', 'source-ownership')] })] }), _jsxs("section", { className: "quality-group noise", "data-smoke-marker": "quality-generated-noise", children: [_jsxs("div", { className: "quality-group-head", children: [_jsx("h3", { children: "Generated workspace noise" }), _jsxs("span", { children: [text(noiseCount), " separated paths"] })] }), _jsxs("div", { className: "quality-signal-list compact", children: [qualitySignal('Ignored', ignoredCount, 'Not a source blocker', 'Build, cache, dist, and dependency paths stay out of patch candidates.', 'ignored'), qualitySignal('Quarantined', quarantinedCount, 'Held back', 'Disallowed generated changes were separated from source patch review.', 'quarantined')] })] })] });
+}
+function qualityKpi(label, value, detail) {
+    return _jsxs("div", { className: "quality-kpi", children: [_jsx("span", { children: label }), _jsx("b", { children: text(value) }), _jsx("small", { children: detail })] });
+}
+function qualitySignal(label, value, status, description, marker) {
+    return _jsxs("article", { className: value ? 'quality-signal active' : 'quality-signal', "data-smoke-marker": `quality-signal-${marker}`, children: [_jsxs("div", { children: [_jsx("b", { children: label }), _jsx("p", { children: description })] }), _jsx("span", { className: "quality-signal-count", children: text(value) }), _jsx("span", { className: "quality-signal-status", children: value ? status : 'Clear' })] });
+}
+function Timeline({ dashboard, jobs, events, audit }) {
+    const summary = timelineSummary(dashboard, jobs, events);
+    const contribution = contributionGrid(dashboard, jobs, events);
+    const bottlenecks = timelineBottlenecks(jobs, audit);
+    const aria = `${text(summary.progressPercent)} percent terminal progress, ${text(summary.runningJobs)} running jobs, ${text(summary.attentionJobs)} attention jobs`;
+    return _jsxs("div", { className: "timeline-layout", "data-scroll-id": "timeline", children: [_jsxs("section", { className: "timeline-section wide contribution-section", children: [_jsxs("div", { className: "metric-section-head", children: [_jsx("h3", { children: "Progress by day" }), _jsxs("span", { children: [text(contribution.activeDays), " active days \u00B7 ", text(contribution.totalDone), " done signals"] })] }), _jsx(ContributionGraph, { grid: contribution })] }), _jsxs("section", { className: "timeline-section", children: [_jsxs("div", { className: "metric-section-head", children: [_jsx("h3", { children: "Run progress" }), _jsxs("span", { children: [text(summary.terminalJobs), " / ", text(summary.totalJobs), " terminal"] })] }), _jsxs("div", { className: "timeline-progress-row", children: [_jsxs("div", { className: "timeline-progress-copy", children: [_jsxs("b", { children: [text(summary.progressPercent), "%"] }), _jsxs("span", { children: [text(summary.runningJobs), " running \u00B7 ", text(summary.attentionJobs), " attention"] })] }), _jsx("div", { className: "timeline-progress-track", role: "img", "aria-label": aria, children: _jsx("span", { className: "timeline-progress-fill", style: `width:${summary.progressPercent}%` }) })] }), _jsx(TimelineNote, { summary: summary }), _jsx(TimeSeriesSummary, { dashboard: dashboard })] }), _jsxs("section", { className: "timeline-section", children: [_jsxs("div", { className: "metric-section-head", children: [_jsx("h3", { children: "Event series" }), _jsx("span", { children: summary.points.length ? `${formatTime(summary.firstAt)} to ${formatTime(summary.lastAt)}` : 'no timestamps' })] }), _jsx(TimelineSeries, { summary: summary })] }), _jsxs("section", { className: "timeline-section", children: [_jsxs("div", { className: "metric-section-head", children: [_jsx("h3", { children: "Bottlenecks" }), _jsxs("span", { children: [text(bottlenecks.reduce((sum, row) => sum + row.value, 0)), " signals"] })] }), _jsx(BottleneckStrip, { rows: bottlenecks })] }), _jsxs("section", { className: "timeline-section wide", children: [_jsxs("div", { className: "metric-section-head", children: [_jsx("h3", { children: "Recent timeline" }), _jsxs("span", { children: [text(summary.points.length), " timestamped events"] })] }), _jsx(TimelineEventList, { points: summary.points })] })] });
+}
+function ContributionGraph({ grid, prominent = false }) {
+    const weekTemplate = `repeat(${grid.weeks.length}, var(--contribution-cell))`;
+    return _jsxs("div", { className: prominent ? 'contribution-card prominent' : 'contribution-card', "data-smoke-marker": "progress-by-day", children: [_jsxs("div", { className: "contribution-summary", children: [statCell('Calendar year', String(grid.year)), statCell('Done signals', formatNumber(grid.totalDone)), statCell('Active days', formatNumber(grid.activeDays)), statCell('Peak day', formatNumber(grid.maxCount))] }), _jsxs("div", { className: "contribution-scroll", "data-contribution-grid": "true", role: "img", "aria-label": `Daily progress activity across calendar year ${text(grid.year)}, January through December`, children: [_jsx("div", { className: "contribution-months", style: `grid-template-columns:${weekTemplate}`, children: grid.weeks.map((week, index) => _jsx("span", { children: contributionMonthLabel(week, index, grid.weeks) })) }), _jsxs("div", { className: "contribution-body", children: [_jsxs("div", { className: "contribution-weekdays", "aria-hidden": "true", children: [_jsx("span", {}), _jsx("span", { children: "Mon" }), _jsx("span", {}), _jsx("span", { children: "Wed" }), _jsx("span", {}), _jsx("span", { children: "Fri" }), _jsx("span", {})] }), _jsx("div", { className: "contribution-weeks", style: `grid-template-columns:${weekTemplate}`, children: grid.weeks.map((week) => _jsx("div", { className: "contribution-week", children: week.map((day) => day.inYear
+                                        ? _jsx("span", { className: `contribution-day level-${day.level}`, "data-contribution-tooltip": contributionTooltip(day), "aria-label": `${day.label}: ${formatNumber(day.count)} total activity` })
+                                        : _jsx("span", { className: "contribution-day empty", "aria-hidden": "true" })) })) })] }), _jsxs("div", { className: "contribution-legend", "aria-hidden": "true", children: [_jsx("span", { children: "Less" }), _jsx("i", { className: "contribution-day level-0" }), _jsx("i", { className: "contribution-day level-1" }), _jsx("i", { className: "contribution-day level-2" }), _jsx("i", { className: "contribution-day level-3" }), _jsx("i", { className: "contribution-day level-4" }), _jsx("span", { children: "More" })] })] })] });
+}
+function contributionTooltip(day) {
+    return `${day.label}\n${formatNumber(day.count)} total activity\n${formatNumber(day.completed)} done signals · ${formatNumber(day.events)} events`;
+}
+function TimelineNote({ summary }) {
+    if (summary.exactTimingAvailable && !summary.eventWindowLimited)
+        return _jsx("p", { className: "timeline-note", children: "Exact job spans are available for this dashboard snapshot." });
+    const note = summary.points.length
+        ? 'Exact job spans are unavailable. Showing the recent event window plus current job states.'
+        : 'No timestamped events are available for this run. Showing current job progress only.';
+    return _jsx("p", { className: "timeline-note", children: note });
+}
+function TimeSeriesSummary({ dashboard }) {
+    const summary = recordValue(dashboard.timeSeries?.summary);
+    const pointCount = numberValue(summary.pointCount);
+    if (!pointCount)
+        return _jsx("p", { className: "empty tight", children: "No bucketed time-series metrics in this snapshot." });
+    return _jsxs("div", { className: "time-series-summary", "data-smoke-marker": "time-series-summary", children: [statCell('Buckets', formatNumber(pointCount)), statCell('Terminal jobs', formatNumber(numberValue(summary.terminalJobCount))), statCell('Warnings', formatNumber(numberValue(summary.warningJobCount))), statCell('Missing time', formatNumber(numberValue(summary.missingTimestampJobCount)))] });
+}
+function TimelineSeries({ summary }) {
+    if (!summary.points.length)
+        return _jsx("p", { className: "empty tight", children: "No timestamped events for this run." });
+    return _jsxs("div", { className: "timeline-series", role: "img", "aria-label": `Event timeline from ${formatTime(summary.firstAt)} to ${formatTime(summary.lastAt)}`, children: [_jsx("div", { className: "timeline-series-track", children: summary.points.slice(-48).map((point) => _jsx("span", { className: `timeline-point ${timelinePointTone(point)}`, style: `left:${timelinePointLeft(point, summary)}%`, title: `${formatTime(point.at)} ${point.type} ${point.jobId}` })) }), _jsxs("div", { className: "timeline-axis", "aria-hidden": "true", children: [_jsx("span", { children: formatTime(summary.firstAt) }), _jsx("span", { children: formatTime(summary.lastAt) })] })] });
+}
+function BottleneckStrip({ rows }) {
+    const active = rows.filter((row) => row.value > 0);
+    if (!active.length)
+        return _jsx("p", { className: "empty tight", children: "No current bottlenecks in this run." });
+    return _jsx("div", { className: "bottleneck-list", children: active.map((row) => _jsxs("div", { className: `bottleneck-row ${row.tone}`, children: [_jsx("span", { children: row.label }), _jsx("b", { children: text(row.value) }), _jsx("small", { children: row.detail })] })) });
+}
+function TimelineEventList({ points }) {
+    if (!points.length)
+        return _jsx("p", { className: "empty tight", children: "No recent event rows to show." });
+    return _jsx("div", { className: "timeline-events", role: "list", children: points.slice(-24).reverse().map((point) => _jsxs("article", { className: `timeline-event ${timelinePointTone(point)}`, role: "listitem", children: [_jsx("time", { dateTime: new Date(point.at).toISOString(), children: formatTime(point.at) }), _jsxs("div", { children: [_jsx("b", { children: point.type }), _jsx("span", { children: point.message })] }), _jsxs("small", { children: [point.lane, " \u00B7 ", point.jobId, " \u00B7 ", text(point.progressPercent), "%"] })] })) });
+}
+function Events({ events }) {
+    if (!events.length)
+        return _jsx("p", { className: "empty", children: "No recent events for this run." });
+    return _jsx("div", { className: "table-scroll compact", "data-scroll-id": "events", children: _jsxs("table", { className: "events-table", children: [_jsx("thead", { children: _jsxs("tr", { children: [_jsx("th", { children: "Time" }), _jsx("th", { children: "Event" }), _jsx("th", { children: "Lane" }), _jsx("th", { children: "Job" }), _jsx("th", { children: "Message" })] }) }), _jsx("tbody", { children: events.slice(-36).reverse().map((event) => _jsxs("tr", { children: [_jsx("td", { children: formatTime(event.at) }), _jsx("td", { children: text(event.type) }), _jsx("td", { children: text(event.lane) }), _jsx("td", { className: "mono", children: text(event.jobId) }), _jsx("td", { children: text(event.message) })] })) })] }) });
+}
+function Sources({ entries }) {
+    if (!entries.length)
+        return _jsx("p", { className: "empty", children: "No source paths were reported by the dashboard snapshot." });
+    return _jsx("div", { className: "table-scroll compact", "data-scroll-id": "sources", children: _jsx("table", { className: "sources-table", children: _jsx("tbody", { children: entries.map((entry) => _jsxs("tr", { children: [_jsx("th", { children: entry.label }), _jsx("td", { className: "mono", children: entry.value })] })) }) }) });
+}
+function RunContext({ routing, backlog }) {
+    return _jsxs("div", { className: "context-grid", children: [_jsxs("dl", { className: "kv", children: [_jsx("dt", { children: "Policy" }), _jsx("dd", { children: text(routing?.policyId) }), _jsx("dt", { children: "Mode" }), _jsx("dd", { children: text(routing?.defaultMode) }), _jsx("dt", { children: "Prefer / avoid" }), _jsxs("dd", { children: [text(routing?.preferCount), " / ", text(routing?.avoidCount)] }), _jsx("dt", { children: "Feedback" }), _jsx("dd", { children: text(routing?.preferenceCount) })] }), _jsxs("dl", { className: "kv", children: [_jsx("dt", { children: "Backlog" }), _jsx("dd", { children: text(backlog?.id) }), _jsx("dt", { children: "Entries" }), _jsx("dd", { children: text(backlog?.entryCount) }), _jsx("dt", { children: "Ready" }), _jsx("dd", { children: text(backlog?.readyCount) }), _jsx("dt", { children: "Children" }), _jsx("dd", { children: text(Array.isArray(backlog?.childBacklogPaths) ? backlog?.childBacklogPaths.length : undefined) })] })] });
+}
+function auditSummary(dashboard, jobs) {
+    const summary = dashboard.summary ?? {};
+    const changedPathCount = numberValue(summary.changedPathCount)
+        || jobs.reduce((sum, job) => sum + numberValue(job.changedPathCount), 0);
+    const ownershipViolationCount = numberValue(summary.ownershipViolationCount)
+        || jobs.reduce((sum, job) => sum + numberValue(job.ownershipViolationCount), 0);
+    const sourceOwnershipViolationCount = numberValue(summary.sourceOwnershipViolationCount)
+        || jobs.reduce((sum, job) => sum + sourceOwnershipViolations(job).length, 0);
+    const ignoredOwnershipViolationCount = numberValue(summary.ignoredOwnershipViolationCount)
+        || jobs.reduce((sum, job) => sum + ignoredOwnershipViolations(job).length, 0);
+    const ignoredChangedPathCount = numberValue(summary.ignoredChangedPathCount)
+        || jobs.reduce((sum, job) => sum + numberValue(job.ignoredChangedPathCount), 0);
+    const quarantinedChangedPathCount = numberValue(summary.quarantinedChangedPathCount)
+        || jobs.reduce((sum, job) => sum + numberValue(job.quarantinedChangedPathCount), 0);
+    const reasonMap = new Map();
+    for (const job of jobs) {
+        for (const reason of stringArray(job.collectReasonClasses)) {
+            reasonMap.set(reason, (reasonMap.get(reason) ?? 0) + 1);
+        }
+    }
+    return {
+        changedPathCount,
+        ownershipViolationCount,
+        sourceOwnershipViolationCount,
+        ignoredOwnershipViolationCount,
+        ignoredChangedPathCount,
+        quarantinedChangedPathCount,
+        reasonCounts: Array.from(reasonMap.entries())
+            .map(([reason, count]) => ({ reason, count }))
+            .sort((left, right) => right.count - left.count || left.reason.localeCompare(right.reason))
+            .slice(0, 8)
+    };
+}
+function metric(label, value, tone, detail) {
+    return _jsxs("article", { className: `metric ${tone}`, children: [_jsx("span", { children: label }), _jsx("b", { children: text(value) }), detail ? _jsx("small", { children: detail }) : null] });
+}
+function compactMetric(label, value) {
+    return _jsxs("div", { className: "compact-metric", children: [_jsx("span", { children: label }), _jsx("b", { children: text(value) })] });
+}
+function auditRow(label, value) {
+    return _jsxs("div", { className: "audit-row", children: [_jsx("span", { children: label }), _jsx("b", { children: text(value) })] });
+}
+function pressureCell(label, value, detail) {
+    return _jsxs("div", { className: "pressure-card", children: [_jsx("span", { children: label }), _jsx("b", { children: text(value) }), _jsx("small", { children: detail })] });
+}
+function generatedNoiseCount(audit) {
+    return audit.ignoredOwnershipViolationCount + audit.ignoredChangedPathCount;
+}
+function ReasonClasses({ audit }) {
+    if (!audit.reasonCounts.length)
+        return _jsx("p", { className: "empty tight", children: "No collect reason classes." });
+    return _jsx("div", { className: "reason-list", children: audit.reasonCounts.map((entry) => _jsxs("div", { className: "reason-row", children: [_jsx("span", { children: entry.reason }), _jsx("b", { children: text(entry.count) })] })) });
+}
+function SimpleRows({ rows }) {
+    if (!rows.length)
+        return _jsx("p", { className: "empty tight", children: "No rows for this run." });
+    return _jsx("div", { className: "simple-rows", children: rows.map((row) => _jsxs("article", { className: "simple-row", children: [_jsxs("div", { children: [_jsx("b", { children: row.label }), _jsx("small", { children: row.detail })] }), _jsx("span", { children: row.value })] })) });
+}
+function humanActionRows(jobs, audit, dashboard) {
+    void audit;
+    return snapshotHumanActionRows(dashboard, jobs);
+}
+function snapshotHumanActionRows(dashboard, jobs) {
+    if (!dashboard || !Array.isArray(dashboard.humanActions))
+        return [];
+    const visibleJobIds = new Set(jobs.map((job) => textValue(job.id ?? job.taskId, '')).filter(Boolean));
+    const answeredCodes = answeredHumanActionCodes(dashboard);
+    const rows = dashboard.humanActions
+        .map(snapshotHumanActionRow)
+        .filter((row) => Boolean(row))
+        .filter(isExplicitAgentQuestion)
+        .filter(isOpenHumanActionRow)
+        .filter((row) => !answeredCodes.has(row.code))
+        .filter((row) => !row.jobId || visibleJobIds.has(row.jobId));
+    return dedupeHumanActionRows(rows)
+        .sort((left, right) => priorityRank(left.priority) - priorityRank(right.priority) || left.code.localeCompare(right.code));
+}
+function answeredHumanActionCodes(dashboard) {
+    return new Set(Array.isArray(dashboard.humanActionAnswers)
+        ? dashboard.humanActionAnswers.map((answer) => textValue(answer.code, '')).filter(Boolean)
+        : []);
+}
+function pruneResolvedHumanActionDrafts(dashboard) {
+    const openCodes = new Set(snapshotHumanActionRows(dashboard, dashboard.jobs).map((row) => row.code));
+    for (const code of humanAnswerDrafts.keys())
+        if (!openCodes.has(code))
+            humanAnswerDrafts.delete(code);
+    for (const code of humanAnswerStates.keys())
+        if (!openCodes.has(code))
+            humanAnswerStates.delete(code);
+}
+function snapshotHumanActionRow(value) {
+    const code = textValue(value.code, '');
+    if (!code)
+        return undefined;
+    const type = normalizeHumanActionType(textValue(value.type, 'concern'));
+    const priority = normalizeHumanActionPriority(textValue(value.priority, 'info'));
+    const title = textValue(value.title, code);
+    const question = textValue(value.question ?? value.prompt ?? value.detail ?? value.text, title);
+    const detail = textValue(value.detail ?? value.context ?? value.text, question);
+    return {
+        id: textValue(value.id, code),
+        code,
+        status: textValue(value.status, 'open'),
+        priority,
+        type,
+        title,
+        question,
+        scope: textValue(value.scope ?? value.lane, 'workspace'),
+        detail,
+        why: textValue(value.why ?? value.reason, ''),
+        requestedAnswer: textValue(value.requestedAnswer ?? value.answerFormat ?? value.expectedAnswer, ''),
+        defaultAction: textValue(value.defaultAction, 'Answer in Codex so the coordinator can resolve the item.'),
+        askedBy: textValue(value.askedBy ?? value.agentId ?? value.jobId, ''),
+        source: textValue(value.source, 'dashboard'),
+        jobId: textValue(value.jobId, ''),
+        lane: textValue(value.lane, ''),
+        options: humanActionOptions(value.options)
+    };
+}
+function humanActionOptions(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value.flatMap((entry) => {
+        if (typeof entry === 'string')
+            return [{ label: entry }];
+        if (!entry || typeof entry !== 'object' || Array.isArray(entry))
+            return [];
+        const option = entry;
+        const label = textValue(option.label ?? option.title ?? option.value, '');
+        if (!label)
+            return [];
+        const detail = textValue(option.detail ?? option.description ?? option.impact, '');
+        return [{ label, ...(detail ? { detail } : {}) }];
+    }).slice(0, 6);
+}
+function normalizeHumanActionType(value) {
+    if (value === 'question' || value === 'concern' || value === 'review' || value === 'approval')
+        return value;
+    return 'concern';
+}
+function isExplicitAgentQuestion(row) {
+    return row.type === 'question' && Boolean(row.question.trim());
+}
+function normalizeHumanActionPriority(value) {
+    if (value === 'blocking' || value === 'important' || value === 'info')
+        return value;
+    return 'info';
+}
+function isOpenHumanActionRow(row) {
+    const status = (row.status ?? 'open').toLowerCase();
+    return !['answered', 'resolved', 'dismissed', 'cancelled', 'canceled', 'closed'].includes(status);
+}
+function dedupeHumanActionRows(rows) {
+    const out = new Map();
+    for (const row of rows)
+        if (!out.has(row.code))
+            out.set(row.code, row);
+    return Array.from(out.values()).slice(0, 60);
+}
+function priorityRank(priority) {
+    if (priority === 'blocking')
+        return 0;
+    if (priority === 'important')
+        return 1;
+    return 2;
+}
+function successLikeJobCount(jobs) {
+    return jobs.filter((job) => isCompletedJob(job) && !isFailedJob(job) && !isStaleJob(job)).length;
+}
+function laneLoadTone(lane) {
+    if (lane.failedCount || lane.blockedCount)
+        return 'bad';
+    if (lane.staleCount || lane.needsCoordinatorReviewCount)
+        return 'warn';
+    if (lane.completedCount && lane.completedCount === lane.jobCount)
+        return 'good';
+    return 'neutral';
+}
+function captureScrollPositions() {
+    root?.querySelectorAll('[data-scroll-id]').forEach((element) => {
+        const id = element.dataset.scrollId;
+        if (!id)
+            return;
+        scrollPositions.set(id, { left: element.scrollLeft, top: element.scrollTop });
+    });
+}
+function restoreScrollPositions() {
+    window.requestAnimationFrame(() => {
+        root?.querySelectorAll('[data-scroll-id]').forEach((element) => {
+            const id = element.dataset.scrollId;
+            const position = id ? scrollPositions.get(id) : undefined;
+            if (!position)
+                return;
+            element.scrollLeft = position.left;
+            element.scrollTop = position.top;
+        });
+        if (pendingFocusTab) {
+            const focusTab = pendingFocusTab;
+            pendingFocusTab = undefined;
+            contentTabButtons().find((tab) => tab.dataset.contentTab === focusTab)?.focus();
+        }
+    });
+}
+function selectContentTab(tab) {
+    selectedTab = tab;
+    writeRouteState();
+    if (currentDashboard)
+        renderDashboard(currentDashboard);
+}
+function openTaskCard(id) {
+    if (!id)
+        return;
+    if (selectedTaskCardId !== id)
+        scrollPositions.delete(taskDialogScrollId(id));
+    selectedTaskCardId = id;
+    selectedTicketId = undefined;
+    if (!currentDashboard)
+        return;
+    const item = taskBoardItems(currentDashboard, currentDashboard.jobs).find((job) => taskCardId(job) === id);
+    if (item)
+        selectedTicketId = ticketId(item);
+    writeRouteState();
+    if (item)
+        void fetchTaskDetails(item);
+    renderDashboard(currentDashboard);
+}
+function taskDialogScrollId(id) {
+    return `task-dialog-${id}`;
+}
+async function fetchTaskDetails(job) {
+    const id = taskCardId(job);
+    if (!id || taskDetailsCache.has(id) || taskDetailsPending.has(id))
+        return;
+    if (job.boardKind === 'backlog') {
+        taskDetailsCache.set(id, { ok: true, jobId: id, files: [], commandsPassed: [], commandsFailed: [], evidenceArtifacts: [] });
+        return;
+    }
+    taskDetailsPending.add(id);
+    try {
+        const response = await fetch(`/api/task-details?id=${encodeURIComponent(id)}`);
+        const details = await response.json();
+        taskDetailsCache.set(id, details);
+    }
+    catch (error) {
+        taskDetailsCache.set(id, {
+            ok: false,
+            jobId: id,
+            files: [],
+            commandsPassed: [],
+            commandsFailed: [],
+            evidenceArtifacts: [],
+            error: error instanceof Error ? error.message : String(error)
+        });
+    }
+    finally {
+        taskDetailsPending.delete(id);
+        if (selectedTaskCardId === id && currentDashboard)
+            renderDashboard(currentDashboard);
+    }
+}
+async function revealArtifactInFinder(pathValue) {
+    try {
+        const response = await fetch('/api/artifact/reveal', {
+            method: 'POST',
+            headers: { 'content-type': 'application/json' },
+            body: JSON.stringify({ path: pathValue })
+        });
+        const result = await response.json();
+        if (!response.ok || !result.ok)
+            console.warn('Unable to reveal artifact in Finder:', result.error ?? response.statusText);
+    }
+    catch (error) {
+        console.warn('Unable to reveal artifact in Finder:', error);
+    }
+}
+async function submitHumanActionAnswer(form) {
+    const code = form.dataset.humanAnswerCode ?? '';
+    const field = form.querySelector('textarea[name="answer"]');
+    const answer = field?.value.trim() ?? '';
+    if (!code)
+        return;
+    if (!answer) {
+        humanAnswerStates.set(code, { status: 'error', message: 'Enter an answer first.' });
+        if (currentDashboard)
+            renderDashboard(currentDashboard);
+        return;
+    }
+    humanAnswerDrafts.set(code, answer);
+    humanAnswerStates.set(code, { status: 'submitting', message: 'Submitting...' });
+    if (currentDashboard)
+        renderDashboard(currentDashboard);
+    try {
+        const response = await fetch('/api/human-actions/answer', {
+            method: 'POST',
+            headers: { 'content-type': 'application/json' },
+            body: JSON.stringify({ code, answer })
+        });
+        const result = await response.json();
+        if (!response.ok || !result.ok)
+            throw new Error(result.error ?? response.statusText);
+        humanAnswerDrafts.delete(code);
+        humanAnswerStates.set(code, { status: 'submitted', message: 'Answer submitted.' });
+        void refresh();
+    }
+    catch (error) {
+        humanAnswerStates.set(code, { status: 'error', message: error instanceof Error ? error.message : String(error) });
+    }
+    finally {
+        if (currentDashboard)
+            renderDashboard(currentDashboard);
+    }
+}
+async function copyTextToClipboard(value, target) {
+    let copied = false;
+    try {
+        if (navigator.clipboard?.writeText) {
+            await navigator.clipboard.writeText(value);
+            copied = true;
+        }
+    }
+    catch {
+        copied = fallbackCopyText(value);
+    }
+    if (!copied)
+        copied = fallbackCopyText(value);
+    if (!target)
+        return;
+    const previousText = target.textContent ?? '';
+    target.dataset.copyState = copied ? 'copied' : 'failed';
+    target.textContent = copied ? 'Copied' : 'Copy failed';
+    window.setTimeout(() => {
+        target.textContent = previousText;
+        delete target.dataset.copyState;
+    }, 900);
+}
+function fallbackCopyText(value) {
+    const field = document.createElement('textarea');
+    field.value = value;
+    field.setAttribute('readonly', 'true');
+    field.style.position = 'fixed';
+    field.style.left = '-9999px';
+    field.style.top = '0';
+    document.body.append(field);
+    field.focus();
+    field.select();
+    let copied = false;
+    try {
+        copied = document.execCommand('copy');
+    }
+    catch {
+        copied = false;
+    }
+    finally {
+        field.remove();
+    }
+    return copied;
+}
+function closeTaskDialog() {
+    selectedTaskCardId = undefined;
+    selectedTicketId = undefined;
+    writeRouteState();
+    if (currentDashboard)
+        renderDashboard(currentDashboard);
+}
+function selectedTaskItem(dashboard, jobs) {
+    if (!selectedTaskCardId && !selectedTicketId)
+        return undefined;
+    const items = taskBoardItems(dashboard, jobs);
+    const byTask = selectedTaskCardId ? items.find((job) => taskCardId(job) === selectedTaskCardId) : undefined;
+    const item = byTask ?? (selectedTicketId ? items.find((job) => ticketId(job) === selectedTicketId) : undefined);
+    if (!item) {
+        selectedTaskCardId = undefined;
+        selectedTicketId = undefined;
+        window.setTimeout(writeRouteState, 0);
+        return undefined;
+    }
+    selectedTaskCardId = taskCardId(item);
+    selectedTicketId = ticketId(item);
+    return item;
+}
+function routeStateFromLocation() {
+    const raw = window.location.hash.replace(/^#/, '');
+    const params = new URLSearchParams(raw.includes('=') ? raw : raw ? `tab=${raw}` : '');
+    return {
+        tab: asContentTab(params.get('tab')),
+        taskId: textValue(params.get('task'), '') || undefined,
+        ticket: textValue(params.get('ticket'), '') || undefined
+    };
+}
+function writeRouteState() {
+    const params = new URLSearchParams();
+    params.set('tab', selectedTab);
+    if (selectedTaskCardId)
+        params.set('task', selectedTaskCardId);
+    if (selectedTicketId)
+        params.set('ticket', selectedTicketId);
+    const next = `${window.location.pathname}${window.location.search}#${params.toString()}`;
+    if (`${window.location.pathname}${window.location.search}${window.location.hash}` !== next) {
+        window.history.replaceState(null, '', next);
+    }
+}
+function contentTabButtons() {
+    return Array.from(root?.querySelectorAll('[data-content-tab]') ?? []);
+}
+function isTabNavigationKey(key) {
+    return key === 'ArrowRight' || key === 'ArrowLeft' || key === 'Home' || key === 'End';
+}
+function nextTabIndex(key, currentIndex, count) {
+    if (key === 'Home')
+        return 0;
+    if (key === 'End')
+        return Math.max(0, count - 1);
+    if (key === 'ArrowLeft')
+        return (currentIndex - 1 + count) % count;
+    return (currentIndex + 1) % count;
+}
+function asContentTab(value) {
+    if (value === 'agents')
+        return 'swarm';
+    return contentTabs.some((tab) => tab.id === value) ? value : 'work';
+}
+function contributionTooltipTarget(value) {
+    return value instanceof Element
+        ? value.closest('[data-contribution-tooltip]') ?? undefined
+        : undefined;
+}
+function chartTooltipTarget(value) {
+    return value instanceof Element
+        ? value.closest('[data-chart-tooltip]') ?? undefined
+        : undefined;
+}
+function contributionGridTarget(value) {
+    return value instanceof Element
+        ? value.closest('[data-contribution-grid]') ?? undefined
+        : undefined;
+}
+function nearestContributionTarget(event) {
+    const exact = contributionTooltipTarget(event.target);
+    if (exact)
+        return exact;
+    const grid = contributionGridTarget(event.target);
+    if (!grid)
+        return undefined;
+    const weeks = grid.querySelector('.contribution-weeks');
+    if (!weeks)
+        return undefined;
+    const weeksRect = weeks.getBoundingClientRect();
+    if (event.clientX < weeksRect.left ||
+        event.clientX > weeksRect.right ||
+        event.clientY < weeksRect.top ||
+        event.clientY > weeksRect.bottom) {
+        return undefined;
+    }
+    let best;
+    let bestDistance = Number.POSITIVE_INFINITY;
+    for (const target of Array.from(weeks.querySelectorAll('[data-contribution-tooltip]'))) {
+        const rect = target.getBoundingClientRect();
+        const dx = event.clientX < rect.left ? rect.left - event.clientX : event.clientX > rect.right ? event.clientX - rect.right : 0;
+        const dy = event.clientY < rect.top ? rect.top - event.clientY : event.clientY > rect.bottom ? event.clientY - rect.bottom : 0;
+        const distance = dx * dx + dy * dy;
+        if (distance >= bestDistance)
+            continue;
+        best = target;
+        bestDistance = distance;
+    }
+    return best;
+}
+function nearestChartPopoverTarget(event) {
+    return chartTooltipTarget(event.target) ?? nearestContributionTarget(event);
+}
+function isStillInsideContributionGrid(event) {
+    const grid = contributionGridTarget(event.target);
+    return Boolean(grid && event.relatedTarget instanceof Node && grid.contains(event.relatedTarget));
+}
+function showChartPopover(target, pointerX, pointerY) {
+    const popover = ensureChartPopover();
+    popover.textContent = target.dataset.chartTooltip ?? target.dataset.contributionTooltip ?? '';
+    popover.classList.add('visible');
+    positionChartPopover(target, pointerX, pointerY);
+}
+function hideChartPopover() {
+    activeContributionTarget = undefined;
+    chartPopover?.classList.remove('visible', 'below');
+}
+function ensureChartPopover() {
+    if (chartPopover && document.body.contains(chartPopover))
+        return chartPopover;
+    chartPopover = document.createElement('div');
+    chartPopover.className = 'chart-popover';
+    chartPopover.setAttribute('role', 'tooltip');
+    document.body.appendChild(chartPopover);
+    return chartPopover;
+}
+function positionChartPopover(target, pointerX, pointerY) {
+    if (!chartPopover)
+        return;
+    const rect = target.getBoundingClientRect();
+    const width = Math.min(240, Math.max(180, chartPopover.offsetWidth || 200));
+    const leftSource = pointerX ?? rect.left + rect.width / 2;
+    const left = Math.max(12 + width / 2, Math.min(window.innerWidth - 12 - width / 2, leftSource));
+    const aboveTop = (pointerY ?? rect.top) - 12;
+    const below = aboveTop < 42;
+    const top = below ? rect.bottom + 10 : aboveTop;
+    chartPopover.style.left = `${left}px`;
+    chartPopover.style.top = `${top}px`;
+    chartPopover.style.maxWidth = `${width}px`;
+    chartPopover.classList.toggle('below', below);
+}
+function laneRollups(dashboard) {
+    const rows = new Map();
+    for (const lane of dashboard.lanes) {
+        const id = textValue(lane.id, 'unassigned');
+        rows.set(id, {
+            id,
+            jobCount: numberValue(lane.jobCount),
+            completedCount: numberValue(lane.completedCount),
+            failedCount: numberValue(lane.failedCount),
+            runningCount: numberValue(lane.runningCount),
+            blockedCount: 0,
+            needsCoordinatorReviewCount: 0,
+            staleCount: 0,
+            evidenceCount: 0,
+            eventCount: 0
+        });
+    }
+    if (dashboard.jobs.length > 0) {
+        for (const row of rows.values()) {
+            row.jobCount = 0;
+            row.completedCount = 0;
+            row.failedCount = 0;
+            row.runningCount = 0;
+        }
+    }
+    for (const job of dashboard.jobs) {
+        const lane = ensureLane(rows, laneOf(job));
+        lane.jobCount += 1;
+        if (normalized(job.status) === 'completed')
+            lane.completedCount += 1;
+        if (normalized(job.status) === 'running')
+            lane.runningCount += 1;
+        if (isFailedJob(job))
+            lane.failedCount += 1;
+        if (isBlockedJob(job))
+            lane.blockedCount += 1;
+        if (isNeedsCoordinatorReviewJob(job))
+            lane.needsCoordinatorReviewCount += 1;
+        if (isStaleJob(job))
+            lane.staleCount += 1;
+        lane.evidenceCount += numberValue(job.evidencePathCount);
+    }
+    for (const event of dashboard.events) {
+        const laneId = textValue(event.lane, '');
+        if (!laneId)
+            continue;
+        ensureLane(rows, laneId).eventCount += 1;
+    }
+    return Array.from(rows.values()).sort((left, right) => {
+        const risk = (right.failedCount + right.staleCount + right.needsCoordinatorReviewCount) - (left.failedCount + left.staleCount + left.needsCoordinatorReviewCount);
+        return risk || left.id.localeCompare(right.id);
+    });
+}
+function ensureLane(rows, id) {
+    const existing = rows.get(id);
+    if (existing)
+        return existing;
+    const row = {
+        id,
+        jobCount: 0,
+        completedCount: 0,
+        failedCount: 0,
+        runningCount: 0,
+        blockedCount: 0,
+        needsCoordinatorReviewCount: 0,
+        staleCount: 0,
+        evidenceCount: 0,
+        eventCount: 0
+    };
+    rows.set(id, row);
+    return row;
+}
+function emptyLane(id) {
+    return {
+        id,
+        jobCount: 0,
+        completedCount: 0,
+        failedCount: 0,
+        runningCount: 0,
+        blockedCount: 0,
+        needsCoordinatorReviewCount: 0,
+        staleCount: 0,
+        evidenceCount: 0,
+        eventCount: 0
+    };
+}
+function attentionSummary(jobs) {
+    return jobs.reduce((summary, job) => ({
+        failedCount: summary.failedCount + (isFailedJob(job) ? 1 : 0),
+        staleCount: summary.staleCount + (isStaleJob(job) ? 1 : 0),
+        needsCoordinatorReviewCount: summary.needsCoordinatorReviewCount + (isNeedsCoordinatorReviewJob(job) ? 1 : 0),
+        blockedCount: summary.blockedCount + (isBlockedJob(job) ? 1 : 0),
+        evidenceCount: summary.evidenceCount + numberValue(job.evidencePathCount)
+    }), { failedCount: 0, staleCount: 0, needsCoordinatorReviewCount: 0, blockedCount: 0, evidenceCount: 0 });
+}
+function successSummary(dashboard, jobs) {
+    const semantic = semanticMetrics(dashboard.semantic);
+    const replay = recordValue(recordValue(dashboard.semantic).replay);
+    const ledger = dashboardApplyLedgerSummary(dashboard);
+    return {
+        completedCount: jobs.filter(isCompletedJob).length,
+        readyCount: jobs.filter(isReadyJob).length,
+        cleanSourceCount: jobs.filter((job) => sourceOwnershipViolations(job).length === 0 && numberValue(job.quarantinedChangedPathCount) === 0).length,
+        evidenceCompleteCount: jobs.filter((job) => numberValue(job.evidencePathCount) > 0).length,
+        appliedCount: ledger.applied,
+        applyTotalCount: ledger.total,
+        applyFailedCount: ledger.failed,
+        landedCount: ledger.landed,
+        semanticAcceptedClean: semantic.acceptedClean,
+        semanticAlreadyApplied: numberValue(replay.alreadyAppliedCount)
+    };
+}
+function dashboardApplyLedgerSummary(dashboard) {
+    const summary = recordValue(dashboard.summary);
+    const summaryLedger = recordValue(summary.applyLedger);
+    const raw = recordValue(dashboard.raw);
+    const collection = recordValue(raw.collection);
+    const collectionSummary = recordValue(collection.summary);
+    const collectionLedger = recordValue(collectionSummary.applyLedger);
+    const compact = recordValue(raw.compactDashboard);
+    const compactLedger = recordValue(compact.applyLedger);
+    const rawLedger = recordValue(raw.applyLedger);
+    const rawLedgerSummary = recordValue(rawLedger.summary);
+    const ledgers = [summaryLedger, collectionLedger, compactLedger, rawLedger, rawLedgerSummary];
+    const landedIds = stringArray(summary.landedJobIds).length
+        || stringArray(collectionSummary.landedJobIds).length
+        || stringArray(compact.landedJobIds).length;
+    const applied = firstLedgerCount(ledgers, 'applied');
+    const committed = firstLedgerCount(ledgers, 'committed');
+    const failed = firstLedgerCount(ledgers, 'failed');
+    const skipped = firstLedgerCount(ledgers, 'skipped');
+    const landed = numberValue(summary.landed)
+        || numberValue(summary.landedCount)
+        || numberValue(summary.applyLedgerLandedCount)
+        || numberValue(summaryLedger.landed)
+        || numberValue(collectionSummary.landed)
+        || numberValue(collectionSummary.landedCount)
+        || numberValue(collectionLedger.landed)
+        || numberValue(compact.landedCount)
+        || numberValue(compactLedger.landed)
+        || landedIds;
+    const appliedCount = applied || landed;
+    return {
+        total: firstLedgerCount(ledgers, 'total') || appliedCount + committed + failed + skipped || landed,
+        applied: appliedCount,
+        committed,
+        skipped,
+        failed,
+        landed
+    };
+}
+function firstLedgerCount(ledgers, key) {
+    for (const ledger of ledgers) {
+        const value = numberValue(ledger[key]);
+        if (value > 0)
+            return value;
+    }
+    return 0;
+}
+function tokenTimeSummary(dashboard, jobs) {
+    const timeSummary = recordValue(dashboard.timeSeries?.summary);
+    const context = contextPressureSummary(jobs);
+    const actualInputTokens = numberValue(timeSummary.actualInputTokens) || context.actualInputTokens;
+    const estimatedInputTokens = numberValue(timeSummary.estimatedInputTokens) || context.estimatedInputTokens;
+    const uncachedInputTokens = numberValue(timeSummary.uncachedInputTokens) || context.uncachedInputTokens;
+    const durationMs = numberValue(timeSummary.durationMs) || sumJobNumber(jobs, 'durationMs');
+    const pointCount = numberValue(timeSummary.pointCount);
+    const missingTimestampCount = numberValue(timeSummary.missingTimestampJobCount);
+    const warningCount = context.warningCount + context.failedCount;
+    const tokenValue = actualInputTokens ? formatNumber(actualInputTokens) : estimatedInputTokens ? formatNumber(estimatedInputTokens) : '-';
+    const tokenDetail = actualInputTokens
+        ? `${formatNumber(uncachedInputTokens)} uncached · ${formatNumber(estimatedInputTokens)} est`
+        : estimatedInputTokens
+            ? 'estimated input tokens'
+            : 'no token data';
+    const durationDetail = pointCount
+        ? `${formatNumber(pointCount)} buckets · ${formatNumber(missingTimestampCount)} missing time`
+        : durationMs
+            ? 'summed worker duration'
+            : 'no timing data';
+    return {
+        tokenValue,
+        tokenDetail,
+        durationValue: durationMs ? formatDuration(durationMs) : '-',
+        durationDetail,
+        tokenTone: warningCount ? 'warn' : 'neutral',
+        timeTone: missingTimestampCount ? 'warn' : 'neutral',
+        warningCount,
+        missingTimestampCount
+    };
+}
+function warningPressureSummary(attention, audit, health, telemetry) {
+    const failedBlocked = health.failedJobCount + health.blockedJobCount;
+    const coordinatorStale = attention.needsCoordinatorReviewCount + attention.staleCount;
+    const sourceViolations = audit.sourceOwnershipViolationCount;
+    const generatedNoise = generatedNoiseCount(audit) + audit.quarantinedChangedPathCount;
+    const budget = Math.max(health.contextWarningJobCount, telemetry.warningCount);
+    const missingTime = telemetry.missingTimestampCount;
+    const severe = failedBlocked + sourceViolations;
+    const rows = [
+        { label: 'Failed / blocked', value: failedBlocked, detail: `${text(health.failedJobCount)} failed · ${text(health.blockedJobCount)} blocked`, tone: failedBlocked ? 'bad' : 'neutral' },
+        { label: 'Coordinator / stale', value: coordinatorStale, detail: `${text(attention.needsCoordinatorReviewCount)} coordinator · ${text(attention.staleCount)} stale`, tone: coordinatorStale ? 'warn' : 'neutral' },
+        { label: 'Context budget', value: budget, detail: `${text(health.contextWarningJobCount)} context · ${text(telemetry.warningCount)} token`, tone: budget ? 'warn' : 'neutral' },
+        { label: 'Source violations', value: sourceViolations, detail: 'outside owned source globs', tone: sourceViolations ? 'bad' : 'neutral' },
+        { label: 'Generated / quarantined', value: generatedNoise, detail: `${text(generatedNoiseCount(audit))} ignored · ${text(audit.quarantinedChangedPathCount)} quarantined`, tone: generatedNoise ? 'warn' : 'neutral' },
+        { label: 'Missing timing', value: missingTime, detail: 'jobs without timestamps', tone: missingTime ? 'warn' : 'neutral' }
+    ];
+    const total = rows.reduce((sum, row) => sum + row.value, 0);
+    return {
+        total,
+        severe,
+        budget,
+        tone: severe ? 'bad' : total ? 'warn' : 'neutral',
+        headline: total ? formatNumber(total) : 'clear',
+        detail: total ? `${formatNumber(severe)} blockers · ${formatNumber(budget)} budget` : 'no warning pressure',
+        rows
+    };
+}
+function sourceRows(dashboard) {
+    const entries = [];
+    if (dashboard.cwd)
+        entries.push({ label: 'cwd', value: dashboard.cwd });
+    if (dashboard.generatedAt)
+        entries.push({ label: 'snapshot', value: formatTime(dashboard.generatedAt) });
+    for (const [key, value] of Object.entries(dashboard.sources ?? {})) {
+        const text = textValue(value, '');
+        if (text)
+            entries.push({ label: sourceLabel(key), value: text });
+    }
+    return entries;
+}
+function dashboardSourceLabel(dashboard) {
+    const kind = dashboardSourceKind(dashboard);
+    const generated = dashboard.generatedAt ? ` · snapshot ${formatTime(dashboard.generatedAt)}` : '';
+    const activeCount = activeAgentTaskCount(dashboard, dashboard.jobs);
+    const sources = recordValue(dashboard.sources);
+    if (kind === 'demo')
+        return `Demo fixture data · example agents, not a live run${generated}`;
+    if (kind === 'lifetime')
+        return `Workspace lifetime · ${text(numberValue(sources.loadedSourceCount) || numberValue(sources.sourceCount))} sources · ${text(activeCount)} active ${activeCount === 1 ? 'agent' : 'agents'}${generated}`;
+    if (kind === 'live')
+        return `Live run snapshot · ${text(activeCount)} active ${activeCount === 1 ? 'agent' : 'agents'}${generated}`;
+    if (kind === 'stopped')
+        return `Run snapshot · no active agents${generated}`;
+    return `Snapshot${generated}`;
+}
+function dashboardSourceKind(dashboard) {
+    const sources = recordValue(dashboard.sources);
+    const sourceText = Object.values(sources).map((value) => textValue(value, '')).join(' ');
+    const cwd = textValue(dashboard.cwd, '');
+    const source = `${cwd} ${sourceText}`;
+    if (/loom-ui-demo-populated|demo-populated|fixture/i.test(source))
+        return 'demo';
+    if (textValue(dashboard.kind, '') === 'frontier.loom-ui.lifetime-dashboard' || textValue(sources.lifetimeRoot, ''))
+        return 'lifetime';
+    if (/agent-runs|activeRun|pids\.json/i.test(source))
+        return activeAgentTaskCount(dashboard, dashboard.jobs) > 0 ? 'live' : 'stopped';
+    return 'snapshot';
+}
+function dashboardSourceSmokeMarker(kind) {
+    if (kind === 'demo')
+        return 'demo-source-strip';
+    if (kind === 'lifetime')
+        return 'lifetime-source-strip';
+    if (kind === 'live')
+        return 'live-source-strip';
+    if (kind === 'stopped')
+        return 'stopped-source-strip';
+    return 'snapshot-source-strip';
+}
+function riskStatusLabel(dashboard, attention, loaded) {
+    if (attention.failedCount || attention.staleCount || attention.needsCoordinatorReviewCount || attention.blockedCount)
+        return 'Attention needed';
+    if (!loaded)
+        return 'No run loaded';
+    return dashboard.ok ? 'Admission clean' : 'Run degraded';
+}
+function jobRisk(job) {
+    if (isBlockedJob(job))
+        return 'failed';
+    if (isNeedsCoordinatorPortJob(job))
+        return 'review';
+    if (isFailedJob(job))
+        return 'failed';
+    if (isStaleJob(job))
+        return 'stale';
+    if (normalized(job.status) === 'running')
+        return 'running';
+    if (normalized(job.bucket) === 'ready-to-apply')
+        return 'ready';
+    if (normalized(job.status) === 'completed')
+        return 'done';
+    return 'unknown';
+}
+function isCompletedJob(job) {
+    return normalized(job.status) === 'completed';
+}
+function isReadyJob(job) {
+    return normalized(job.bucket) === 'ready-to-apply'
+        || normalized(job.disposition) === 'ready-to-apply'
+        || normalized(job.mergeReadiness).includes('ready');
+}
+function jobRiskLabel(job) {
+    const risk = jobRisk(job);
+    if (isBlockedJob(job))
+        return 'blocked';
+    if (risk === 'failed')
+        return 'review';
+    if (risk === 'stale')
+        return 'stale';
+    if (risk === 'review')
+        return 'review';
+    if (risk === 'ready')
+        return 'ready';
+    if (risk === 'done')
+        return 'done';
+    return text(job.status);
+}
+function isFailedJob(job) {
+    const status = normalized(job.status);
+    const bucket = normalized(job.bucket);
+    const disposition = normalized(job.disposition);
+    const readiness = normalized(job.mergeReadiness);
+    return status === 'failed'
+        || bucket === 'failed-evidence'
+        || disposition === 'rejected'
+        || disposition === 'failed'
+        || readiness.includes('failed');
+}
+function isBlockedJob(job) {
+    const status = normalized(job.status);
+    const bucket = normalized(job.bucket);
+    const disposition = normalized(job.disposition);
+    const readiness = normalized(job.mergeReadiness);
+    return status === 'blocked'
+        || bucket === 'blocked'
+        || bucket === 'waiting-on-human'
+        || bucket === 'waiting-on-dependency'
+        || disposition === 'blocked'
+        || readiness === 'blocked';
+}
+function isNeedsCoordinatorReviewJob(job) {
+    return isNeedsCoordinatorPortJob(job);
+}
+function isNeedsCoordinatorPortJob(job) {
+    const bucket = normalized(job.bucket);
+    const disposition = normalized(job.disposition);
+    const readiness = normalized(job.mergeReadiness);
+    return bucket === 'needs-human-port'
+        || bucket === 'needs-human-review'
+        || bucket === 'needs-human-decision'
+        || bucket === 'needs-coordinator-port'
+        || bucket === 'needs-coordinator-review'
+        || bucket === 'needs-coordinator-decision'
+        || disposition.includes('needs')
+        || readiness.includes('needs')
+        || normalized(job.status) === 'needs-review';
+}
+function isCoordinatorReviewJob(job) {
+    if (isResolvedCoordinatorReviewJob(job))
+        return false;
+    return isNeedsCoordinatorPortJob(job)
+        || isFailedJob(job)
+        || isStaleJob(job)
+        || normalized(job.disposition).includes('review')
+        || normalized(job.mergeReadiness).includes('review');
+}
+function isStaleJob(job) {
+    return normalized(job.bucket).includes('stale')
+        || normalized(job.disposition).includes('stale')
+        || normalized(job.mergeReadiness).includes('stale');
+}
+function isTerminalJob(job) {
+    const status = normalized(job.status);
+    return status === 'completed'
+        || status === 'failed'
+        || status === 'blocked'
+        || Boolean(textValue(job.bucket, ''));
+}
+function laneOf(job) {
+    return textValue(job.lane, 'unassigned');
+}
+function reasonText(value) {
+    if (Array.isArray(value) && value.length)
+        return value.slice(0, 3).map(String).join(', ');
+    return '-';
+}
+function jobReasonText(job) {
+    const values = [...stringArray(job.collectReasonClasses), ...stringArray(job.reasons)];
+    return reasonText(values);
+}
+function pathSummary(job) {
+    const ownershipViolationCount = numberValue(job.ownershipViolationCount);
+    const sourceOwnership = sourceOwnershipViolations(job);
+    const ignoredOwnership = ignoredOwnershipViolations(job);
+    const ignoredChangedPathCount = numberValue(job.ignoredChangedPathCount);
+    const quarantinedChangedPathCount = numberValue(job.quarantinedChangedPathCount);
+    const quarantinedChangedPaths = stringArray(job.quarantinedChangedPaths);
+    const ignoredCount = ignoredOwnership.length + ignoredChangedPathCount;
+    const issueText = sourceOwnership.length
+        ? `${text(sourceOwnership.length)} source: ${pathList(sourceOwnership)}`
+        : ignoredOwnership.length
+            ? `${text(ignoredCount)} generated noise: ${pathList(ignoredOwnership)}`
+            : quarantinedChangedPaths.length
+                ? `${text(quarantinedChangedPathCount)} quarantined: ${pathList(quarantinedChangedPaths)}`
+                : ownershipViolationCount || ignoredCount || quarantinedChangedPathCount
+                    ? `${text(sourceOwnership.length)} source · ${text(ignoredCount)} generated · ${text(quarantinedChangedPathCount)} quarantined`
+                    : 'clean';
+    return _jsxs("span", { className: "path-summary", children: [_jsx("b", { children: text(job.changedPathCount) }), _jsx("small", { children: issueText })] });
+}
+function pathSummaryText(job) {
+    const sourceOwnership = sourceOwnershipViolations(job);
+    const ignoredOwnership = ignoredOwnershipViolations(job);
+    const ignoredChangedPathCount = numberValue(job.ignoredChangedPathCount);
+    const quarantinedChangedPathCount = numberValue(job.quarantinedChangedPathCount);
+    const ignoredCount = ignoredOwnership.length + ignoredChangedPathCount;
+    if (sourceOwnership.length)
+        return `${text(sourceOwnership.length)} source issue`;
+    if (quarantinedChangedPathCount)
+        return `${text(quarantinedChangedPathCount)} quarantined`;
+    if (ignoredCount)
+        return `${text(ignoredCount)} generated noise`;
+    return `${text(job.changedPathCount)} changed paths`;
+}
+function sourceOwnershipViolations(job) {
+    const explicit = stringArray(job.sourceOwnershipViolations);
+    if (explicit.length)
+        return explicit.filter((path) => !isGeneratedPath(path));
+    return stringArray(job.ownershipViolations).filter((path) => !isGeneratedPath(path));
+}
+function ignoredOwnershipViolations(job) {
+    const explicit = stringArray(job.ignoredOwnershipViolations);
+    return uniqueStrings([...explicit, ...stringArray(job.sourceOwnershipViolations).filter(isGeneratedPath), ...stringArray(job.ownershipViolations).filter(isGeneratedPath)]);
+}
+function uniqueStrings(values) {
+    return Array.from(new Set(values.filter(Boolean)));
+}
+function isGeneratedPath(value) {
+    const path = value.replace(/\\/g, '/');
+    return path.includes('/.cache/')
+        || path.startsWith('.cache/')
+        || path.endsWith('.tsbuildinfo')
+        || path.includes('/dist/')
+        || path.startsWith('dist/')
+        || path.includes('/node_modules/')
+        || path.startsWith('node_modules/');
+}
+function pathList(paths) {
+    const visible = paths.slice(0, 2);
+    const more = paths.length > visible.length ? ` +${paths.length - visible.length}` : '';
+    return `${visible.join(', ')}${more}`;
+}
+function contributionGrid(dashboard, jobs, events) {
+    const anchor = Math.max(Date.now(), timeValue(dashboard.generatedAt) ?? 0, ...events.map((event) => timeValue(event.at) ?? 0), ...jobs.map(jobCompletionTime));
+    const year = new Date(anchor).getFullYear();
+    const yearStart = new Date(year, 0, 1).getTime();
+    const yearEnd = new Date(year, 11, 31).getTime();
+    const gridStart = addLocalDays(yearStart, -new Date(yearStart).getDay());
+    const gridEnd = addLocalDays(yearEnd, 6 - new Date(yearEnd).getDay());
+    const dayStarts = localDayRange(gridStart, gridEnd);
+    const weekCount = Math.ceil(dayStarts.length / 7);
+    const rows = new Map();
+    for (const at of dayStarts) {
+        const date = dateKey(at);
+        const inYear = at >= yearStart && at <= yearEnd;
+        rows.set(date, {
+            date,
+            label: formatDay(at),
+            count: 0,
+            completed: 0,
+            events: 0,
+            level: 0,
+            inYear
+        });
+    }
+    for (const event of events) {
+        const at = timeValue(event.at);
+        if (at === undefined)
+            continue;
+        const row = rows.get(dateKey(at));
+        if (!row)
+            continue;
+        row.events += 1;
+        if (isProgressEvent(event))
+            row.completed += 1;
+    }
+    for (const job of jobs) {
+        if (!isPositiveProgressJob(job))
+            continue;
+        const at = jobCompletionTime(job) || timeValue(dashboard.generatedAt);
+        if (at === undefined)
+            continue;
+        const row = rows.get(dateKey(at));
+        if (!row)
+            continue;
+        row.completed += 1;
+    }
+    const days = Array.from(rows.values()).map((row) => ({
+        ...row,
+        count: row.completed + row.events
+    }));
+    const yearDays = days.filter((day) => day.inYear);
+    const maxCount = Math.max(0, ...yearDays.map((day) => day.count));
+    const levelled = days.map((day) => ({
+        ...day,
+        level: contributionLevel(day.count, maxCount)
+    }));
+    const weeks = Array.from({ length: weekCount }, (_, index) => levelled.slice(index * 7, index * 7 + 7));
+    return {
+        year,
+        days: levelled.filter((day) => day.inYear),
+        weeks,
+        maxCount,
+        totalDone: yearDays.reduce((sum, day) => sum + day.completed, 0),
+        totalEvents: yearDays.reduce((sum, day) => sum + day.events, 0),
+        activeDays: yearDays.filter((day) => day.count > 0).length
+    };
+}
+const DAY_MS = 24 * 60 * 60 * 1000;
+function startOfLocalDay(value) {
+    const date = new Date(value);
+    return new Date(date.getFullYear(), date.getMonth(), date.getDate()).getTime();
+}
+function addLocalDays(value, days) {
+    const date = new Date(value);
+    return new Date(date.getFullYear(), date.getMonth(), date.getDate() + days).getTime();
+}
+function localDayRange(start, end) {
+    const out = [];
+    for (let at = startOfLocalDay(start); at <= end; at = addLocalDays(at, 1)) {
+        out.push(at);
+    }
+    return out;
+}
+function dateKey(value) {
+    const date = new Date(startOfLocalDay(value));
+    const year = date.getFullYear();
+    const month = String(date.getMonth() + 1).padStart(2, '0');
+    const day = String(date.getDate()).padStart(2, '0');
+    return `${year}-${month}-${day}`;
+}
+function formatDay(value) {
+    return new Intl.DateTimeFormat('en-US', {
+        month: 'short',
+        day: 'numeric',
+        year: 'numeric'
+    }).format(new Date(value));
+}
+function contributionLevel(count, maxCount) {
+    if (!count)
+        return 0;
+    if (maxCount <= 1)
+        return 1;
+    return Math.min(4, Math.max(1, Math.ceil((count / maxCount) * 4)));
+}
+function contributionMonthLabel(week, index, weeks) {
+    const firstInYear = week.find((day) => day.inYear);
+    if (!firstInYear)
+        return '';
+    const startsMonth = week.find((day) => day.inYear && day.date.endsWith('-01'));
+    if (index > 0 && !startsMonth)
+        return '';
+    const day = startsMonth ?? firstInYear;
+    const previousMonth = weeks[index - 1]?.find((entry) => entry.inYear)?.date.slice(5, 7);
+    const month = day.date.slice(5, 7);
+    if (!startsMonth && previousMonth === month)
+        return '';
+    return new Intl.DateTimeFormat('en-US', { month: 'short' }).format(new Date(`${day.date}T00:00:00`));
+}
+function jobCompletionTime(job) {
+    return timeValue(job.finishedAt)
+        ?? timeValue(job.completedAt)
+        ?? timeValue(job.endedAt)
+        ?? timeValue(job.updatedAt)
+        ?? 0;
+}
+function isPositiveProgressJob(job) {
+    return isCompletedJob(job)
+        || isReadyJob(job)
+        || normalized(job.bucket) === 'applied'
+        || normalized(job.bucket) === 'landed'
+        || normalized(job.disposition) === 'applied'
+        || normalized(job.disposition) === 'landed';
+}
+function timelineSummary(dashboard, jobs, events) {
+    const totalJobs = jobs.length || numberValue(dashboard.summary.jobCount);
+    const terminalJobs = jobs.filter(isTerminalJob).length;
+    const runningJobs = jobs.filter((job) => normalized(job.status) === 'running').length;
+    const attentionJobs = jobs.filter((job) => isFailedJob(job) || isNeedsCoordinatorReviewJob(job) || isStaleJob(job) || isBlockedJob(job)).length;
+    const progressPercent = totalJobs ? percentNumber(terminalJobs / totalJobs) : 0;
+    const timestamped = events
+        .map((event) => ({ event, at: timeValue(event.at) }))
+        .filter((entry) => entry.at !== undefined)
+        .sort((left, right) => left.at - right.at);
+    const finished = new Set();
+    const points = timestamped.map(({ event, at }) => {
+        const type = text(event.type);
+        const jobId = textValue(event.jobId, '');
+        if (jobId && normalized(type) === 'agent.finished')
+            finished.add(jobId);
+        const pointProgress = normalized(type) === 'swarm.finished'
+            ? progressPercent
+            : totalJobs
+                ? Math.min(progressPercent, percentNumber(finished.size / totalJobs))
+                : 0;
+        return {
+            at,
+            type,
+            lane: text(event.lane),
+            jobId: jobId || '-',
+            message: text(event.message),
+            progressPercent: pointProgress
+        };
+    });
+    return {
+        totalJobs,
+        terminalJobs,
+        runningJobs,
+        attentionJobs,
+        progressPercent,
+        points,
+        firstAt: points[0]?.at,
+        lastAt: points[points.length - 1]?.at,
+        exactTimingAvailable: jobs.some((job) => timeValue(job.startedAt) !== undefined && (timeValue(job.finishedAt) !== undefined || numberValue(job.durationMs) > 0)),
+        eventWindowLimited: events.length >= 80
+    };
+}
+function timelineBottlenecks(jobs, audit) {
+    return [
+        { label: 'Failed', value: jobs.filter(isFailedJob).length, detail: 'failed or rejected jobs', tone: 'bad' },
+        { label: 'Coordinator review', value: jobs.filter(isNeedsCoordinatorReviewJob).length, detail: 'outputs waiting on coordinator review', tone: 'warn' },
+        { label: 'Stale', value: jobs.filter(isStaleJob).length, detail: 'stale against current head', tone: 'warn' },
+        { label: 'Blocked', value: jobs.filter(isBlockedJob).length, detail: 'scheduler or dependency blocked', tone: 'bad' },
+        { label: 'Source violations', value: audit.sourceOwnershipViolationCount, detail: 'changed paths outside owned source globs', tone: 'bad' },
+        {
+            label: 'Truncated logs',
+            value: jobs.filter((job) => numberValue(job.eventBytesTruncated) + numberValue(job.stderrBytesTruncated) > 0).length,
+            detail: 'lost event or stderr detail',
+            tone: 'warn'
+        }
+    ];
+}
+function dashboardHealthSummary(dashboard, jobs, attention) {
+    const summary = recordValue(dashboard.health?.summary);
+    const jobCount = numberValue(summary.jobCount) || jobs.length;
+    const failedJobCount = numberValue(summary.failedJobCount) || attention.failedCount;
+    const blockedJobCount = numberValue(summary.blockedJobCount) || attention.blockedCount;
+    const warningJobCount = numberValue(summary.warningJobCount) || attention.needsCoordinatorReviewCount + attention.staleCount;
+    const terminalJobCount = numberValue(summary.terminalJobCount) || jobs.filter(isTerminalJob).length;
+    const status = textValue(dashboard.health?.status, failedJobCount || blockedJobCount ? 'failed' : warningJobCount ? 'warning' : jobCount ? 'healthy' : 'unknown');
+    return {
+        status,
+        tone: healthTone(status),
+        jobCount,
+        healthyJobCount: numberValue(summary.healthyJobCount) || Math.max(0, jobCount - failedJobCount - blockedJobCount - warningJobCount),
+        warningJobCount,
+        failedJobCount,
+        blockedJobCount,
+        runningJobCount: numberValue(summary.runningJobCount) || jobs.filter((job) => normalized(job.status) === 'running').length,
+        terminalJobCount,
+        readyToApplyJobCount: numberValue(summary.readyToApplyJobCount) || jobs.filter(isReadyJob).length,
+        contextWarningJobCount: numberValue(summary.contextWarningJobCount) || jobs.filter(isContextBudgetWarningJob).length,
+        semanticCleanJobCount: numberValue(summary.semanticCleanJobCount) || jobs.filter((job) => normalized(job.semanticReadiness) === 'clean').length,
+        semanticCandidateJobCount: numberValue(summary.semanticCandidateJobCount) || jobs.filter((job) => normalized(job.semanticReadiness) === 'candidate').length,
+        completionRatio: numberValue(summary.completionRatio) || (jobCount ? terminalJobCount / jobCount : 0),
+        failureRatio: numberValue(summary.failureRatio) || (jobCount ? (failedJobCount + blockedJobCount) / jobCount : 0)
+    };
+}
+function dashboardHealthRows(dashboard, jobs, attention) {
+    const health = dashboardHealthSummary(dashboard, jobs, attention);
+    return [
+        { label: 'Healthy', value: health.healthyJobCount, tone: 'good' },
+        { label: 'Warnings', value: health.warningJobCount, tone: health.warningJobCount ? 'warn' : 'neutral' },
+        { label: 'Failed', value: health.failedJobCount, tone: health.failedJobCount ? 'bad' : 'neutral' },
+        { label: 'Blocked', value: health.blockedJobCount, tone: health.blockedJobCount ? 'bad' : 'neutral' },
+        { label: 'Running', value: health.runningJobCount, tone: 'neutral' },
+        { label: 'Semantic clean', value: health.semanticCleanJobCount, tone: health.semanticCleanJobCount ? 'good' : 'neutral' }
+    ];
+}
+function healthTone(value) {
+    const status = normalized(value);
+    if (status === 'healthy')
+        return 'good';
+    if (status === 'warning' || status === 'running')
+        return 'warn';
+    if (status === 'failed' || status === 'blocked')
+        return 'bad';
+    return 'neutral';
+}
+function timelinePointLeft(point, summary) {
+    const first = summary.firstAt ?? point.at;
+    const last = summary.lastAt ?? point.at;
+    if (last <= first)
+        return 0;
+    return Math.max(0, Math.min(100, Math.round(((point.at - first) / (last - first)) * 100)));
+}
+function timelinePointTone(point) {
+    const type = normalized(point.type);
+    const message = normalized(point.message);
+    if (type.includes('failed') || message.includes('failed') || message.includes('blocked'))
+        return 'bad';
+    if (type.includes('adaptive') || message.includes('stale') || message.includes('human'))
+        return 'warn';
+    if (type.includes('finished'))
+        return 'good';
+    return 'neutral';
+}
+function tabMeta(tab, input) {
+    void input.events;
+    void input.sources;
+    if (tab === 'work')
+        return `${text(input.jobs)} tasks`;
+    if (tab === 'board')
+        return 'AI tasks';
+    if (tab === 'swarm')
+        return 'active agents';
+    if (tab === 'performance')
+        return 'cost trends';
+    if (tab === 'history')
+        return 'change graph';
+    if (tab === 'testing')
+        return 'quality checks';
+    return `${text(input.questions)} open`;
+}
+function sourceLabel(value) {
+    return value.replace(/([A-Z])/g, ' $1').replace(/^./, (first) => first.toUpperCase());
+}
+function offlineDashboard(error) {
+    return {
+        ok: false,
+        generatedAt: Date.now(),
+        summary: {
+            jobCount: 0,
+            completedCount: 0,
+            failedCount: 0,
+            runningCount: 0,
+            blockedCount: 0,
+            bucketCounts: { total: 0, 'ready-to-apply': 0 }
+        },
+        lanes: [],
+        jobs: [],
+        events: [],
+        sources: { error: error instanceof Error ? error.message : String(error) }
+    };
+}
+function text(value) {
+    return textValue(value, '-');
+}
+function textValue(value, fallback) {
+    if (value === undefined || value === null || value === '')
+        return fallback;
+    return String(value);
+}
+function numberValue(value) {
+    const number = Number(value ?? 0);
+    return Number.isFinite(number) ? number : 0;
+}
+function timeValue(value) {
+    if (value === undefined || value === null || value === '')
+        return undefined;
+    const number = Number(value);
+    if (Number.isFinite(number) && number > 0)
+        return number;
+    if (typeof value === 'string') {
+        const parsed = Date.parse(value);
+        if (Number.isFinite(parsed) && parsed > 0)
+            return parsed;
+    }
+    return undefined;
+}
+function sumJobNumber(jobs, key) {
+    return jobs.reduce((sum, job) => sum + numberValue(job[key]), 0);
+}
+function progressChartSeries(dashboard, jobs, events) {
+    const timeSeries = timeSeriesChartSeries(dashboard);
+    if (timeSeries.length)
+        return timeSeries;
+    const completed = jobs.filter((job) => normalized(job.status) === 'completed').length;
+    const attention = jobs.filter((job) => isFailedJob(job) || isStaleJob(job) || isNeedsCoordinatorReviewJob(job)).length;
+    const progressEvents = events.filter(isProgressEvent).length;
+    const attentionEvents = events.filter(isAttentionEvent).length;
+    return [
+        {
+            id: 'event-activity',
+            title: 'Activity',
+            value: formatNumber(events.length),
+            detail: 'event cadence',
+            points: eventBucketPoints(events, () => true)
+        },
+        {
+            id: 'progress-events',
+            title: 'Progress',
+            value: progressEvents ? formatNumber(progressEvents) : `${formatNumber(completed)}/${formatNumber(jobs.length)}`,
+            detail: progressEvents ? 'ready/completed events' : 'completed jobs',
+            tone: 'good',
+            points: eventBucketPoints(events, isProgressEvent, 'good')
+        },
+        {
+            id: 'attention-events',
+            title: 'Attention',
+            value: attentionEvents ? formatNumber(attentionEvents) : formatNumber(attention),
+            detail: attentionEvents ? 'risk events' : 'jobs with risk',
+            tone: attention || attentionEvents ? 'bad' : 'neutral',
+            points: eventBucketPoints(events, isAttentionEvent, attention || attentionEvents ? 'bad' : 'neutral')
+        }
+    ];
+}
+function timeSeriesChartSeries(dashboard) {
+    const points = timeSeriesPoints(dashboard);
+    if (!points.length)
+        return [];
+    const summary = recordValue(dashboard.timeSeries?.summary);
+    const terminal = numberValue(summary.terminalJobCount);
+    const warnings = numberValue(summary.warningJobCount);
+    const failures = numberValue(summary.failureJobCount) + numberValue(summary.blockedJobCount);
+    const durationMs = numberValue(summary.durationMs);
+    return [
+        {
+            id: 'time-series-terminal',
+            title: 'Terminal jobs',
+            value: formatNumber(terminal),
+            detail: `${formatBucketSize(dashboard.timeSeries?.bucketMs)} buckets`,
+            tone: 'good',
+            points: points.map((point) => timeSeriesPoint(point, 'terminalJobCount', 'terminal jobs', 'good'))
+        },
+        {
+            id: 'time-series-warnings',
+            title: 'Warnings',
+            value: formatNumber(warnings),
+            detail: 'warning jobs by bucket',
+            tone: warnings ? 'warn' : 'neutral',
+            points: points.map((point) => timeSeriesPoint(point, 'warningJobCount', 'warnings', warnings ? 'warn' : 'neutral'))
+        },
+        {
+            id: 'time-series-failures',
+            title: 'Failures',
+            value: formatNumber(failures),
+            detail: 'failed and blocked jobs',
+            tone: failures ? 'bad' : 'neutral',
+            points: points.map((point) => ({
+                ...timeSeriesPoint(point, 'failureJobCount', 'failures', failures ? 'bad' : 'neutral'),
+                value: numberValue(point.failureJobCount) + numberValue(point.blockedJobCount)
+            }))
+        },
+        {
+            id: 'time-series-duration',
+            title: 'Duration',
+            value: formatDuration(durationMs),
+            detail: 'bucketed worker duration',
+            points: points.map((point) => timeSeriesPoint(point, 'durationMs', 'duration', 'neutral', formatDuration))
+        }
+    ];
+}
+function contextLoadChartSeries(dashboard, jobs) {
+    const points = timeSeriesPoints(dashboard);
+    if (points.length) {
+        const summary = recordValue(dashboard.timeSeries?.summary);
+        const actualInputTokens = numberValue(summary.actualInputTokens);
+        return [
+            {
+                id: 'time-series-estimated-tokens',
+                title: 'Estimated tokens',
+                value: formatNumber(numberValue(summary.estimatedInputTokens)),
+                detail: 'bucketed input estimate',
+                points: points.map((point) => timeSeriesPoint(point, 'estimatedInputTokens', 'estimated tokens'))
+            },
+            {
+                id: 'time-series-actual-tokens',
+                title: 'Actual tokens',
+                value: actualInputTokens ? formatNumber(actualInputTokens) : '-',
+                detail: 'reported usage',
+                points: points.map((point) => timeSeriesPoint(point, 'actualInputTokens', 'actual tokens'))
+            },
+            {
+                id: 'time-series-uncached-tokens',
+                title: 'Uncached input',
+                value: formatNumber(numberValue(summary.uncachedInputTokens)),
+                detail: 'uncached input tokens',
+                points: points.map((point) => timeSeriesPoint(point, 'uncachedInputTokens', 'uncached input'))
+            }
+        ];
+    }
+    const promptBytes = sumJobNumber(jobs, 'promptBytes');
+    const estimatedInputTokens = sumJobNumber(jobs, 'estimatedInputTokens');
+    const actualInputTokens = sumJobNumber(jobs, 'actualInputTokens');
+    const rows = [
+        {
+            id: 'prompt-bytes',
+            title: 'Prompt bytes',
+            value: formatBytes(promptBytes),
+            detail: 'per visible job',
+            points: jobValuePoints(jobs, 'promptBytes', formatBytes)
+        },
+        {
+            id: 'estimated-tokens',
+            title: 'Estimated tokens',
+            value: formatNumber(estimatedInputTokens),
+            detail: 'per visible job',
+            points: jobValuePoints(jobs, 'estimatedInputTokens', formatNumber)
+        }
+    ];
+    if (actualInputTokens) {
+        rows.push({
+            id: 'actual-tokens',
+            title: 'Actual tokens',
+            value: formatNumber(actualInputTokens),
+            detail: 'reported usage',
+            points: jobValuePoints(jobs, 'actualInputTokens', formatNumber)
+        });
+    }
+    return rows;
+}
+function performanceTabMeta(dashboard, jobs) {
+    const telemetry = tokenTimeSummary(dashboard, jobs);
+    return telemetry.tokenValue === '-' ? 'cost trends' : `${telemetry.tokenValue} input`;
+}
+function historyTabMeta(dashboard, jobs, success) {
+    void dashboard;
+    if (success.landedCount)
+        return `${formatNumber(success.landedCount)} landed`;
+    if (success.appliedCount)
+        return `${formatNumber(success.appliedCount)} applied`;
+    return `${formatNumber(jobs.length)} branches`;
+}
+function testingTabMeta(jobs) {
+    const summary = testingSummary(jobs, []);
+    if (summary.failedChecks)
+        return `${formatNumber(summary.failedChecks)} failing`;
+    if (summary.activeJobs)
+        return `${formatNumber(summary.activeJobs)} pending`;
+    if (summary.totalChecks)
+        return `${formatNumber(summary.passedChecks)}/${formatNumber(summary.totalChecks)} passing`;
+    if (summary.noMetadataTasks || !jobs.length)
+        return 'no check metadata';
+    return 'quality checks';
+}
+function performanceTimeDetail(dashboard) {
+    const points = timeSeriesPoints(dashboard);
+    if (!points.length)
+        return 'per-task fallback';
+    return `${formatNumber(points.length)} ${formatBucketSize(dashboard.timeSeries?.bucketMs)} buckets`;
+}
+function historyBranchRows(jobs) {
+    return [...jobs]
+        .sort((left, right) => taskSortRank(left) - taskSortRank(right) || ticketId(left).localeCompare(ticketId(right)))
+        .slice(0, 12);
+}
+const HISTORY_GRAPH_COLORS = ['#8b949e', '#58a6ff', '#bc8cff', '#3fb950', '#d29922', '#f778ba', '#39c5cf'];
+function historyGitGraph(dashboard, jobs) {
+    void dashboard;
+    const ordered = historyGraphJobs(jobs).slice(0, 28);
+    const laneKeys = historyGraphLaneKeys(ordered);
+    const laneGap = 22;
+    const rowHeight = 54;
+    const lanes = [
+        { id: 'main', label: 'main', x: 16, color: HISTORY_GRAPH_COLORS[0] ?? '#8b949e' },
+        ...laneKeys.map((id, index) => ({
+            id,
+            label: id,
+            x: 16 + laneGap * (index + 1),
+            color: HISTORY_GRAPH_COLORS[(index + 1) % HISTORY_GRAPH_COLORS.length] ?? '#58a6ff'
+        }))
+    ];
+    const laneById = new Map(lanes.map((lane, index) => [lane.id, { lane, index }]));
+    const rows = ordered.map((job, index) => {
+        const laneId = historyGraphLaneId(job, laneKeys);
+        const laneEntry = laneById.get(laneId) ?? laneById.get('main');
+        const lane = laneEntry?.lane ?? lanes[0];
+        const laneIndex = laneEntry?.index ?? 0;
+        const y = index * rowHeight + Math.round(rowHeight / 2);
+        const tone = historyGraphTone(job);
+        const runtime = jobRuntimeLabel(job, Date.now());
+        const time = historyJobTime(job);
+        const title = `${ticketId(job)} · ${taskTitle(job)}`;
+        const subtitle = `${laneOf(job)} · ${taskCardStatus(job)} · ${pathSummaryText(job)}`;
+        const meta = `${time ? formatTime(time) : 'no timing'} · ${runtime}`;
+        return {
+            id: taskCardId(job),
+            laneId,
+            laneIndex,
+            x: lane.x,
+            y,
+            title,
+            subtitle,
+            meta,
+            tooltip: `${title}\n${subtitle}\n${meta}\n${text(job.disposition ?? job.mergeReadiness ?? job.bucket ?? job.status)}`,
+            tone,
+            merged: historyJobMerged(job)
+        };
+    });
+    return {
+        lanes,
+        rows,
+        width: Math.max(72, 32 + laneGap * Math.max(1, lanes.length)),
+        height: Math.max(rowHeight, rows.length * rowHeight),
+        rowHeight,
+        trunkX: lanes[0]?.x ?? 16
+    };
+}
+function historyGraphJobs(jobs) {
+    return [...jobs]
+        .sort((left, right) => historyJobSortTime(right) - historyJobSortTime(left)
+        || taskSortRank(left) - taskSortRank(right)
+        || ticketId(left).localeCompare(ticketId(right)));
+}
+function historyGraphLaneKeys(jobs) {
+    const raw = uniqueStrings(jobs.map(historyRawLaneKey).filter((value) => value !== 'main'));
+    return raw.slice(0, 6);
+}
+function historyGraphLaneId(job, laneKeys) {
+    const raw = historyRawLaneKey(job);
+    if (laneKeys.includes(raw))
+        return raw;
+    if (!laneKeys.length)
+        return 'main';
+    const index = Number.parseInt(stableHash(raw || taskCardId(job)), 36) % laneKeys.length;
+    return laneKeys[index] ?? 'main';
+}
+function historyRawLaneKey(job) {
+    const worker = textValue(job.workerId ?? job.agentId ?? job.assignedAgent ?? job.workerName, '');
+    const lane = textValue(job.lane, '');
+    return sanitizeHistoryLane(worker || lane || 'main');
+}
+function sanitizeHistoryLane(value) {
+    const clean = value.replace(/[^a-zA-Z0-9._-]+/g, '-').replace(/^-+|-+$/g, '').slice(0, 32);
+    return clean || 'main';
+}
+function historyGraphTone(job) {
+    if (isFailedJob(job) || isBlockedJob(job) || isStaleJob(job))
+        return 'bad';
+    if (isNeedsCoordinatorReviewJob(job) || taskBoardColumnId(job) === 'review')
+        return 'warn';
+    if (isPositiveProgressJob(job) || isReadyJob(job))
+        return 'good';
+    return 'neutral';
+}
+function historyJobMerged(job) {
+    if (isFailedJob(job) || isBlockedJob(job) || isStaleJob(job))
+        return false;
+    return isPositiveProgressJob(job)
+        || isReadyJob(job)
+        || normalized(job.bucket) === 'ready-to-apply'
+        || normalized(job.disposition).includes('applied')
+        || normalized(job.disposition).includes('landed')
+        || normalized(job.mergeReadiness).includes('ready');
+}
+function historyJobSortTime(job) {
+    return historyJobTime(job) || 0;
+}
+function historyJobTime(job) {
+    return timeValue(job.finishedAt)
+        ?? timeValue(job.completedAt)
+        ?? timeValue(job.endedAt)
+        ?? timeValue(job.updatedAt)
+        ?? timeValue(job.startedAt)
+        ?? timeValue(job.createdAt);
+}
+function historyCurvePath(trunkX, laneX, y) {
+    const mid = Math.round((trunkX + laneX) / 2);
+    return `M ${trunkX} ${y} C ${mid} ${y}, ${mid} ${y}, ${laneX} ${y}`;
+}
+function historyLaneColor(graph, laneId) {
+    return graph.lanes.find((lane) => lane.id === laneId)?.color ?? HISTORY_GRAPH_COLORS[0] ?? '#8b949e';
+}
+function HistoryEventRows({ events }) {
+    const rows = events.slice(-6).reverse();
+    if (!rows.length)
+        return _jsx("p", { className: "empty tight", children: "No recent events are available." });
+    return _jsx("div", { className: "history-events", children: rows.map((event) => _jsxs("article", { className: `history-event ${timelinePointTone(eventToTimelinePoint(event))}`, children: [_jsx("time", { children: formatTime(event.at) }), _jsxs("div", { children: [_jsx("b", { children: text(event.type ?? event.message ?? 'event') }), _jsx("small", { children: text(event.message ?? event.jobId ?? event.lane) })] })] })) });
+}
+function eventToTimelinePoint(event) {
+    return {
+        at: numberValue(event.at),
+        type: textValue(event.type, ''),
+        lane: textValue(event.lane, ''),
+        jobId: textValue(event.jobId, ''),
+        message: textValue(event.message, ''),
+        progressPercent: 0
+    };
+}
+function testingSummary(jobs, events) {
+    const signals = jobs.map(testingJobSignals);
+    const passedChecks = signals.reduce((sum, signal) => sum + signal.passedChecks, 0);
+    const failedChecks = signals.reduce((sum, signal) => sum + signal.failedChecks, 0);
+    const evidencePaths = signals.reduce((sum, signal) => sum + signal.evidencePaths.length, 0);
+    const browserEvidence = signals.filter((signal) => signal.browserEvidence).length;
+    const fuzzEvidence = signals.filter((signal) => signal.fuzzEvidence).length;
+    const oracleEvidence = signals.filter((signal) => signal.oracleEvidence).length;
+    const unitEvidence = signals.filter((signal) => signal.unitEvidence).length;
+    const activeJobs = signals.filter((signal) => signal.active).length;
+    const noMetadataTasks = signals.filter((signal) => !signal.hasMetadata).length;
+    const openFailures = jobs.filter((job) => isFailedJob(job) || isBlockedJob(job) || isStaleJob(job)).length;
+    const totalChecks = passedChecks + failedChecks;
+    const rows = signals
+        .filter((signal) => signal.passedChecks || signal.failedChecks || signal.evidencePaths.length || signal.openFailure || signal.active || !signal.hasMetadata)
+        .sort((left, right) => Number(right.openFailure) - Number(left.openFailure)
+        || Number(right.active) - Number(left.active)
+        || Number(!right.hasMetadata) - Number(!left.hasMetadata)
+        || right.failedChecks - left.failedChecks
+        || right.passedChecks - left.passedChecks
+        || left.label.localeCompare(right.label))
+        .slice(0, 10)
+        .map((signal) => ({
+        label: signal.label,
+        value: signal.failedChecks
+            ? `${formatNumber(signal.failedChecks)} failed`
+            : signal.passedChecks
+                ? `${formatNumber(signal.passedChecks)} passed`
+                : signal.active
+                    ? 'pending'
+                    : signal.hasMetadata
+                        ? `${formatNumber(signal.evidencePaths.length)} evidence`
+                        : 'no metadata',
+        detailParts: signal.detailParts,
+        tone: signal.failedChecks || signal.openFailure
+            ? 'bad'
+            : signal.active || !signal.hasMetadata
+                ? 'warn'
+                : signal.passedChecks
+                    ? 'good'
+                    : 'neutral'
+    }));
+    const testEvents = events.filter((event) => /\b(test|fuzz|oracle|playwright|smoke|spec)\b/i.test(`${text(event.type)} ${text(event.message)}`)).length;
+    const status = failedChecks || openFailures
+        ? 'attention needed'
+        : activeJobs
+            ? 'active work pending verification'
+            : totalChecks
+                ? 'checks reported'
+                : evidencePaths
+                    ? 'evidence reported; check results missing'
+                    : 'no check metadata yet';
+    const notice = failedChecks || openFailures
+        ? undefined
+        : activeJobs
+            ? `${formatNumber(activeJobs)} active ${activeJobs === 1 ? 'task is' : 'tasks are'} still running; do not treat this snapshot as fully verified.`
+            : totalChecks
+                ? undefined
+                : evidencePaths
+                    ? 'Evidence paths are present, but no pass/fail command metadata was reported.'
+                    : 'No testing metadata was reported. This empty state means unknown, not passing.';
+    return {
+        totalChecks,
+        passedChecks,
+        failedChecks,
+        evidenceTasks: signals.filter((signal) => signal.evidencePaths.length > 0).length,
+        evidencePaths,
+        browserEvidence,
+        fuzzEvidence,
+        oracleEvidence,
+        unitEvidence: unitEvidence || testEvents,
+        activeJobs,
+        noMetadataTasks,
+        openFailures,
+        status,
+        notice,
+        noticeTone: activeJobs || noMetadataTasks ? 'warn' : 'neutral',
+        rows
+    };
+}
+function testingJobSignals(job) {
+    const passed = arrayRecords(job.commandsPassed);
+    const failed = arrayRecords(job.commandsFailed);
+    const evidencePaths = uniqueStrings([
+        ...stringArray(job.evidencePaths),
+        ...stringArray(job.proofPaths),
+        ...stringArray(job.artifactPaths)
+    ]);
+    const evidenceText = evidencePaths.join(' ').toLowerCase();
+    const commandText = [...passed, ...failed].map((entry) => text(entry.command ?? entry.name ?? entry.summary)).join(' ').toLowerCase();
+    const combined = `${evidenceText} ${commandText}`;
+    const passedChecks = passed.length + numberValue(job.commandsPassedCount ?? job.passedCommandCount ?? job.testPassedCount);
+    const failedChecks = failed.length + numberValue(job.commandsFailedCount ?? job.failedCommandCount ?? job.testFailedCount);
+    const hasCommandMetadata = hasOwn(job, 'commandsPassed')
+        || hasOwn(job, 'commandsFailed')
+        || hasOwn(job, 'commandsPassedCount')
+        || hasOwn(job, 'passedCommandCount')
+        || hasOwn(job, 'testPassedCount')
+        || hasOwn(job, 'commandsFailedCount')
+        || hasOwn(job, 'failedCommandCount')
+        || hasOwn(job, 'testFailedCount');
+    const hasMetadata = hasCommandMetadata || evidencePaths.length > 0;
+    return {
+        label: `${ticketId(job)} · ${taskTitle(job)}`,
+        detailParts: [
+            laneOf(job),
+            taskCardStatus(job),
+            hasMetadata ? evidencePaths.length ? `${formatNumber(evidencePaths.length)} evidence paths` : 'command metadata only' : 'no check metadata'
+        ],
+        passedChecks,
+        failedChecks,
+        evidencePaths,
+        browserEvidence: /\b(browser|playwright|screenshot|dom|visual)\b/.test(combined),
+        fuzzEvidence: /\b(fuzz|property|random|quickcheck)\b/.test(combined),
+        oracleEvidence: /\b(oracle|golden|reference|fixture|snapshot)\b/.test(combined),
+        unitEvidence: /\b(test|smoke|spec|vitest|jest|node --test|npm test)\b/.test(combined),
+        openFailure: isFailedJob(job) || isBlockedJob(job) || isStaleJob(job),
+        active: isActiveAgentJob(job),
+        hasMetadata
+    };
+}
+function hasOwn(record, key) {
+    return Object.prototype.hasOwnProperty.call(record, key);
+}
+function testingEvidenceCard(label, value, detail) {
+    return _jsxs("article", { className: "testing-evidence-card", children: [_jsx("span", { children: label }), _jsx("b", { children: value ? formatNumber(value) : '-' }), _jsx("small", { children: detail })] });
+}
+function performanceTimeChartSeries(dashboard, jobs) {
+    const points = timeSeriesPoints(dashboard);
+    if (!points.length)
+        return performanceJobFallbackSeries(jobs);
+    const summary = recordValue(dashboard.timeSeries?.summary);
+    const bucketLabel = `${formatBucketSize(dashboard.timeSeries?.bucketMs)} buckets`;
+    const actualInput = numberValue(summary.actualInputTokens);
+    const estimatedInput = numberValue(summary.estimatedInputTokens);
+    const cachedInput = numberValue(summary.cachedInputTokens);
+    const durationMs = numberValue(summary.durationMs);
+    const cacheHit = actualInput > 0 ? cachedInput / actualInput : 0;
+    const waste = numberValue(summary.warningJobCount)
+        + numberValue(summary.failureJobCount)
+        + numberValue(summary.blockedJobCount)
+        + numberValue(summary.contextBudgetWarningCount)
+        + numberValue(summary.contextBudgetFailedCount);
+    const inputKey = actualInput ? 'actualInputTokens' : 'estimatedInputTokens';
+    return [
+        {
+            id: 'performance-input-tokens',
+            title: actualInput ? 'Input tokens' : 'Estimated input',
+            value: actualInput ? formatNumber(actualInput) : formatNumber(estimatedInput),
+            detail: actualInput ? `${formatNumber(cachedInput)} cached · ${formatNumber(numberValue(summary.uncachedInputTokens))} uncached` : 'estimated by bucket',
+            xLabel: bucketLabel,
+            yLabel: 'tokens',
+            points: points.map((point) => timeSeriesPoint(point, inputKey, actualInput ? 'input tokens' : 'estimated input'))
+        },
+        {
+            id: 'performance-runtime',
+            title: 'Runtime',
+            value: durationMs ? formatDuration(durationMs) : '-',
+            detail: 'bucketed worker duration',
+            xLabel: bucketLabel,
+            yLabel: 'duration',
+            points: points.map((point) => timeSeriesPoint(point, 'durationMs', 'runtime', 'neutral', formatDuration))
+        },
+        {
+            id: 'performance-cache-hit',
+            title: 'Cache hit',
+            value: cacheHit ? formatPercent(cacheHit) : '-',
+            detail: cachedInput ? `${formatNumber(cachedInput)} cached tokens` : 'no cache data',
+            tone: cacheHit >= 0.25 ? 'good' : cacheHit ? 'warn' : 'neutral',
+            xLabel: bucketLabel,
+            yLabel: 'percent cached',
+            points: points.map(cacheHitPoint)
+        },
+        {
+            id: 'performance-waste',
+            title: 'Waste signals',
+            value: formatNumber(waste),
+            detail: 'warnings, failures, blocked, and budget signals',
+            tone: waste ? 'warn' : 'good',
+            xLabel: bucketLabel,
+            yLabel: 'signal count',
+            points: points.map(wasteSignalPoint)
+        }
+    ];
+}
+function performanceJobFallbackSeries(jobs) {
+    const context = contextPressureSummary(jobs);
+    return [
+        {
+            id: 'performance-job-input',
+            title: 'Input tokens',
+            value: context.actualInputTokens ? formatNumber(context.actualInputTokens) : formatNumber(context.estimatedInputTokens),
+            detail: 'per-task usage fallback',
+            xLabel: 'tasks',
+            yLabel: 'tokens',
+            points: jobValuePoints(jobs, context.actualInputTokens ? 'actualInputTokens' : 'estimatedInputTokens', formatNumber)
+        },
+        {
+            id: 'performance-job-runtime',
+            title: 'Runtime',
+            value: formatDuration(sumJobNumber(jobs, 'durationMs')),
+            detail: 'per-task duration fallback',
+            xLabel: 'tasks',
+            yLabel: 'duration',
+            points: jobValuePoints(jobs, 'durationMs', formatDuration)
+        },
+        {
+            id: 'performance-job-cache-hit',
+            title: 'Cache hit',
+            value: context.cacheHitRatio ? formatPercent(context.cacheHitRatio) : '-',
+            detail: context.cachedInputTokens ? `${formatNumber(context.cachedInputTokens)} cached tokens` : 'no cache data',
+            tone: context.cacheHitRatio >= 0.25 ? 'good' : context.cacheHitRatio ? 'warn' : 'neutral',
+            xLabel: 'tasks',
+            yLabel: 'percent cached',
+            points: jobs.slice(-18).map(cacheHitJobPoint)
+        },
+        {
+            id: 'performance-job-waste',
+            title: 'Waste signals',
+            value: formatNumber(jobs.filter((job) => isFailedJob(job) || isBlockedJob(job) || isContextBudgetWarningJob(job) || isContextBudgetFailedJob(job)).length),
+            detail: 'per-task warning fallback',
+            tone: jobs.some((job) => isFailedJob(job) || isBlockedJob(job) || isContextBudgetWarningJob(job) || isContextBudgetFailedJob(job)) ? 'warn' : 'good',
+            xLabel: 'tasks',
+            yLabel: 'signal count',
+            points: jobs.slice(-18).map(wasteSignalJobPoint)
+        }
+    ];
+}
+function cacheHitPoint(point) {
+    const actual = numberValue(point.actualInputTokens);
+    const cached = numberValue(point.cachedInputTokens);
+    const ratio = actual > 0 && cached > 0 ? cached / actual : 0;
+    return {
+        label: formatTime(point.at),
+        value: Math.round(ratio * 100),
+        detail: ratio ? `${formatPercent(ratio)} cache hit` : 'no cache hit reported',
+        tone: ratio >= 0.25 ? 'good' : ratio ? 'warn' : 'neutral'
+    };
+}
+function cacheHitJobPoint(job) {
+    const actual = numberValue(job.actualInputTokens);
+    const cached = numberValue(job.cachedInputTokens);
+    const ratio = actual > 0 && cached > 0 ? cached / actual : 0;
+    return {
+        label: textValue(job.id ?? job.taskId ?? job.title, 'job'),
+        value: Math.round(ratio * 100),
+        detail: ratio ? `${formatPercent(ratio)} cache hit` : 'no cache hit reported',
+        tone: ratio >= 0.25 ? 'good' : ratio ? 'warn' : 'neutral'
+    };
+}
+function wasteSignalPoint(point) {
+    const value = numberValue(point.warningJobCount)
+        + numberValue(point.failureJobCount)
+        + numberValue(point.blockedJobCount)
+        + numberValue(point.contextBudgetWarningCount)
+        + numberValue(point.contextBudgetFailedCount);
+    return {
+        label: formatTime(point.at),
+        value,
+        detail: `${formatNumber(value)} waste signals`,
+        tone: value ? 'warn' : 'good'
+    };
+}
+function wasteSignalJobPoint(job) {
+    const value = (isFailedJob(job) ? 1 : 0)
+        + (isBlockedJob(job) ? 1 : 0)
+        + (isContextBudgetWarningJob(job) ? 1 : 0)
+        + (isContextBudgetFailedJob(job) ? 1 : 0);
+    return {
+        label: textValue(job.id ?? job.taskId ?? job.title, 'job'),
+        value,
+        detail: value ? `${formatNumber(value)} waste signals` : 'no waste signal',
+        tone: value ? 'warn' : 'good'
+    };
+}
+function performanceWasteRows(jobs, attention, audit, context) {
+    return [
+        { label: 'Budget warnings', value: context.warningCount, detail: `${formatNumber(context.failedCount)} failed budget`, tone: context.warningCount || context.failedCount ? 'warn' : 'neutral' },
+        { label: 'Coordinator review', value: attention.failedCount + attention.needsCoordinatorReviewCount + attention.staleCount, detail: `${formatNumber(attention.failedCount)} failed · ${formatNumber(attention.needsCoordinatorReviewCount)} coordinator · ${formatNumber(attention.staleCount)} stale`, tone: attention.failedCount + attention.needsCoordinatorReviewCount + attention.staleCount ? 'warn' : 'neutral' },
+        { label: 'Blocked', value: attention.blockedCount, detail: 'explicit dependency or impossible-task blocks', tone: attention.blockedCount ? 'bad' : 'neutral' },
+        { label: 'Coordinator review', value: attention.needsCoordinatorReviewCount, detail: 'needs coordinator review', tone: attention.needsCoordinatorReviewCount ? 'review' : 'neutral' },
+        { label: 'Generated noise', value: generatedNoiseCount(audit), detail: 'ignored generated/cache output', tone: generatedNoiseCount(audit) ? 'warn' : 'neutral' },
+        { label: 'P95 uncached', value: context.p95UncachedInputTokens, detail: formatNumber(context.p95UncachedInputTokens), tone: context.p95UncachedInputTokens ? 'warn' : 'neutral' },
+        { label: 'Tasks without timing', value: jobs.filter((job) => !jobRuntimeMs(job, Date.now())).length, detail: 'missing duration/start/end', tone: jobs.some((job) => !jobRuntimeMs(job, Date.now())) ? 'warn' : 'neutral' }
+    ];
+}
+function optimizationSignalSummary(dashboard, jobs) {
+    const summary = dashboard.summary ?? {};
+    const routing = recordValue(dashboard.routing);
+    const panelSignals = firstPositiveNumber(routing.panelDecisionCount, routing.panelResultCount, summary.panelDecisionCount, summary.panelResultCount, summary.fusionPanelCount);
+    const tournamentObservations = firstPositiveNumber(routing.tournamentObservationCount, summary.tournamentObservationCount);
+    const tournamentRecommendations = firstPositiveNumber(routing.tournamentRecommendationCount, summary.tournamentRecommendationCount);
+    const routingFeedback = firstPositiveNumber(routing.feedbackCount, routing.preferenceCount, summary.routingFeedbackCount, summary.routingPreferenceCount);
+    const rsiSignals = firstPositiveNumber(routing.rsiSignalCount, routing.selfOptimizationCount, summary.rsiSignalCount, summary.selfOptimizationCount);
+    const models = uniqueStrings(jobs.map(agentModelLabel).filter((model) => model !== 'model unknown'));
+    const usefulOutput = jobs.length ? successLikeJobCount(jobs) / jobs.length : 0;
+    const available = panelSignals + tournamentObservations + tournamentRecommendations + routingFeedback + rsiSignals;
+    return {
+        status: available ? 'optimization telemetry available' : 'no panel/tournament/RSI telemetry yet',
+        rows: [
+            {
+                label: 'Panel decisions',
+                value: panelSignals ? formatNumber(panelSignals) : '-',
+                detail: panelSignals ? 'panel/fusion outputs reported by the run' : 'not emitted by this run yet',
+                tone: panelSignals ? 'good' : 'neutral'
+            },
+            {
+                label: 'Tournament signals',
+                value: tournamentObservations || tournamentRecommendations ? `${formatNumber(tournamentObservations)}/${formatNumber(tournamentRecommendations)}` : '-',
+                detail: 'observations / recommendations',
+                tone: tournamentObservations || tournamentRecommendations ? 'good' : 'neutral'
+            },
+            {
+                label: 'RSI / routing feedback',
+                value: routingFeedback || rsiSignals ? formatNumber(routingFeedback + rsiSignals) : '-',
+                detail: routingFeedback || rsiSignals ? 'feedback available for future routing' : 'answers are not yet fed into model routing here',
+                tone: routingFeedback || rsiSignals ? 'good' : 'neutral'
+            },
+            {
+                label: 'Model diversity',
+                value: models.length ? formatNumber(models.length) : '-',
+                detail: models.length ? models.slice(0, 3).join(', ') : 'no model labels reported',
+                tone: models.length > 1 ? 'good' : 'neutral'
+            },
+            {
+                label: 'Useful output',
+                value: jobs.length ? formatPercent(usefulOutput) : '-',
+                detail: `${formatNumber(successLikeJobCount(jobs))} useful of ${formatNumber(jobs.length)}`,
+                tone: usefulOutput >= 0.8 ? 'good' : usefulOutput ? 'warn' : 'neutral'
+            }
+        ]
+    };
+}
+function optimizationBehaviorSummary(dashboard, jobs) {
+    const summary = dashboard.summary ?? {};
+    const routing = recordValue(dashboard.routing);
+    const points = timeSeriesPoints(dashboard);
+    const panelSignals = currentPanelSignalCount(routing, summary);
+    const tournamentObservations = firstPositiveNumber(routing.tournamentObservationCount, summary.tournamentObservationCount);
+    const tournamentRecommendations = firstPositiveNumber(routing.tournamentRecommendationCount, summary.tournamentRecommendationCount);
+    const routingFeedback = firstPositiveNumber(routing.feedbackCount, routing.preferenceCount, summary.routingFeedbackCount, summary.routingPreferenceCount);
+    const rsiSignals = firstPositiveNumber(routing.rsiSignalCount, routing.selfOptimizationCount, summary.rsiSignalCount, summary.selfOptimizationCount);
+    const available = panelSignals + tournamentObservations + tournamentRecommendations + routingFeedback + rsiSignals;
+    const signalBuckets = points.filter((point) => (optimizationBucketSignalCount(point) ?? 0) > 0).length;
+    const rows = optimizationBehaviorRows(points, jobs);
+    const improving = rows.filter((row) => row.tone === 'good').length;
+    const comparable = rows.filter((row) => row.tone !== 'neutral').length;
+    const status = !available
+        ? 'no optimization telemetry yet'
+        : !points.length
+            ? 'current optimization totals only'
+            : !signalBuckets
+                ? `${formatNumber(available)} current signals; no bucketed signal trend`
+                : `${formatNumber(improving)}/${formatNumber(comparable || rows.length)} workflow indicators improving`;
+    return {
+        status,
+        cards: [
+            {
+                label: 'Panel influence',
+                value: panelSignals ? formatNumber(panelSignals) : '-',
+                detail: panelSignals ? 'panel/fusion decisions reported' : 'no panel fields reported',
+                tone: panelSignals ? 'good' : 'neutral'
+            },
+            {
+                label: 'Tournament loop',
+                value: tournamentObservations || tournamentRecommendations ? `${formatNumber(tournamentObservations)}/${formatNumber(tournamentRecommendations)}` : '-',
+                detail: 'observations / recommendations',
+                tone: tournamentObservations || tournamentRecommendations ? 'good' : 'neutral'
+            },
+            {
+                label: 'RSI routing loop',
+                value: routingFeedback || rsiSignals ? formatNumber(routingFeedback + rsiSignals) : '-',
+                detail: routingFeedback || rsiSignals ? `${formatNumber(routingFeedback)} feedback · ${formatNumber(rsiSignals)} RSI` : 'no feedback fields reported',
+                tone: routingFeedback || rsiSignals ? 'good' : 'neutral'
+            },
+            {
+                label: 'Trend coverage',
+                value: points.length ? `${formatNumber(signalBuckets)}/${formatNumber(points.length)}` : '-',
+                detail: points.length ? 'buckets with optimization counters' : 'time series unavailable',
+                tone: signalBuckets ? 'good' : points.length ? 'warn' : 'neutral'
+            }
+        ],
+        rows
+    };
+}
+function optimizationBehaviorRows(points, jobs) {
+    const signalTrend = bucketTrend(points, optimizationBucketSignalCount, false);
+    const wasteTrend = bucketTrend(points, optimizationBucketWasteCount, true);
+    const cacheTrend = bucketTrend(points, optimizationBucketCacheRatio, false);
+    const usefulTrend = bucketTrend(points, optimizationBucketUsefulRatio, false);
+    const fallbackUseful = jobs.length ? successLikeJobCount(jobs) / jobs.length : 0;
+    return [
+        trendRow('Optimization signal cadence', signalTrend, 'panel, tournament, RSI, and routing feedback counters by bucket', formatNumber, 'no bucketed optimization counters'),
+        trendRow('Waste pressure', wasteTrend, 'warnings, failures, blocked jobs, and context budget signals', formatNumber, 'no bucketed waste counters'),
+        trendRow('Cache behavior', cacheTrend, 'cached input share by bucket', formatPercent, 'no bucketed cache data'),
+        usefulTrend.hasData
+            ? trendRow('Useful throughput', usefulTrend, 'healthy terminal share by bucket', formatPercent, 'no bucketed terminal data')
+            : {
+                label: 'Useful throughput',
+                value: jobs.length ? formatPercent(fallbackUseful) : '-',
+                detail: jobs.length ? `${formatNumber(successLikeJobCount(jobs))} useful of ${formatNumber(jobs.length)} visible tasks; no bucketed terminal trend` : 'no visible tasks',
+                tone: 'neutral'
+            }
+    ];
+}
+function trendRow(label, trend, detail, formatter, unavailable) {
+    if (!trend.hasData)
+        return { label, value: '-', detail: unavailable, tone: 'neutral' };
+    const direction = trend.delta === 0 ? 'flat' : trend.improving ? 'improving' : 'worsening';
+    return {
+        label,
+        value: trendDeltaLabel(trend.delta, formatter),
+        detail: `${direction}; ${formatter(trend.first)} early to ${formatter(trend.last)} recent · ${detail}`,
+        tone: trend.delta === 0 ? 'neutral' : trend.improving ? 'good' : 'warn'
+    };
+}
+function bucketTrend(points, valueOf, lowerIsBetter) {
+    const values = points.map(valueOf).filter((value) => value !== undefined && Number.isFinite(value));
+    if (values.length < 2)
+        return { hasData: false, first: 0, last: 0, delta: 0, improving: false };
+    const split = Math.max(1, Math.floor(values.length / 2));
+    const first = average(values.slice(0, split));
+    const last = average(values.slice(split));
+    const delta = last - first;
+    return { hasData: true, first, last, delta, improving: lowerIsBetter ? delta < 0 : delta > 0 };
+}
+function optimizationBucketSignalCount(point) {
+    const panel = firstKnownBucketNumber(point, ['panelDecisionCount', 'panelResultCount', 'fusionPanelCount']);
+    const tournament = sumKnownBucketNumbers(point, ['tournamentObservationCount', 'tournamentRecommendationCount']);
+    const feedback = sumKnownBucketNumbers(point, ['feedbackCount', 'preferenceCount', 'routingFeedbackCount', 'routingPreferenceCount', 'rsiSignalCount', 'selfOptimizationCount']);
+    if (panel === undefined && tournament === undefined && feedback === undefined)
+        return undefined;
+    return (panel ?? 0) + (tournament ?? 0) + (feedback ?? 0);
+}
+function optimizationBucketWasteCount(point) {
+    return sumKnownBucketNumbers(point, ['warningJobCount', 'failureJobCount', 'blockedJobCount', 'contextBudgetWarningCount', 'contextBudgetFailedCount']);
+}
+function optimizationBucketCacheRatio(point) {
+    if (!hasNumberField(point, 'actualInputTokens') || !hasNumberField(point, 'cachedInputTokens'))
+        return undefined;
+    const actual = numberValue(point.actualInputTokens);
+    const cached = numberValue(point.cachedInputTokens);
+    return actual > 0 ? cached / actual : 0;
+}
+function optimizationBucketUsefulRatio(point) {
+    if (!hasNumberField(point, 'terminalJobCount'))
+        return undefined;
+    const terminal = numberValue(point.terminalJobCount);
+    if (!terminal)
+        return 0;
+    const warnings = numberValue(point.warningJobCount);
+    const failures = numberValue(point.failureJobCount);
+    const blocked = numberValue(point.blockedJobCount);
+    return Math.max(0, terminal - warnings - failures - blocked) / terminal;
+}
+function currentPanelSignalCount(routing, summary) {
+    return firstPositiveNumber(routing.panelDecisionCount, routing.panelResultCount, summary.panelDecisionCount, summary.panelResultCount, summary.fusionPanelCount);
+}
+function firstKnownBucketNumber(point, keys) {
+    for (const key of keys) {
+        if (hasNumberField(point, key))
+            return numberValue(point[key]);
+    }
+    return undefined;
+}
+function sumKnownBucketNumbers(point, keys) {
+    let hasValue = false;
+    let sum = 0;
+    for (const key of keys) {
+        if (!hasNumberField(point, key))
+            continue;
+        hasValue = true;
+        sum += numberValue(point[key]);
+    }
+    return hasValue ? sum : undefined;
+}
+function hasNumberField(record, key) {
+    return record[key] !== undefined && record[key] !== null && record[key] !== '' && Number.isFinite(Number(record[key]));
+}
+function average(values) {
+    return values.length ? values.reduce((sum, value) => sum + value, 0) / values.length : 0;
+}
+function trendDeltaLabel(delta, formatter) {
+    if (!delta)
+        return 'flat';
+    if (formatter === formatPercent)
+        return `${delta > 0 ? '+' : ''}${Math.round(delta * 100)}pp`;
+    const prefix = delta > 0 ? '+' : '';
+    return `${prefix}${formatter(delta)}`;
+}
+function firstPositiveNumber(...values) {
+    for (const value of values) {
+        const number = numberValue(value);
+        if (number > 0)
+            return number;
+    }
+    return 0;
+}
+const OPENAI_STANDARD_PRICING_SOURCE = 'OpenAI standard pricing';
+const MODEL_PRICES_PER_MILLION = [
+    { id: 'gpt-5.5-pro', price: { input: 30, cachedInput: 30, output: 180 }, longContextPrice: { input: 60, cachedInput: 60, output: 270 }, source: OPENAI_STANDARD_PRICING_SOURCE, notes: 'no cached-input discount listed' },
+    { id: 'gpt-5.5', price: { input: 5, cachedInput: 0.5, output: 30 }, longContextThreshold: 272_000, longContextPrice: { input: 10, cachedInput: 1, output: 45 }, source: OPENAI_STANDARD_PRICING_SOURCE },
+    { id: 'gpt-5.4-pro', price: { input: 30, cachedInput: 30, output: 180 }, longContextPrice: { input: 60, cachedInput: 60, output: 270 }, source: OPENAI_STANDARD_PRICING_SOURCE, notes: 'no cached-input discount listed' },
+    { id: 'gpt-5.4-mini', price: { input: 0.75, cachedInput: 0.075, output: 4.5 }, source: OPENAI_STANDARD_PRICING_SOURCE },
+    { id: 'gpt-5.4-nano', price: { input: 0.2, cachedInput: 0.02, output: 1.25 }, source: OPENAI_STANDARD_PRICING_SOURCE },
+    { id: 'gpt-5.4', price: { input: 2.5, cachedInput: 0.25, output: 15 }, longContextPrice: { input: 5, cachedInput: 0.5, output: 22.5 }, source: OPENAI_STANDARD_PRICING_SOURCE },
+    { id: 'gpt-5.3-codex', aliases: ['gpt-5.3-codex-spark'], price: { input: 1.75, cachedInput: 0.175, output: 14 }, source: OPENAI_STANDARD_PRICING_SOURCE },
+    { id: 'gpt-5.2', price: { input: 1.75, cachedInput: 0.175, output: 14 }, source: OPENAI_STANDARD_PRICING_SOURCE },
+    { id: 'gpt-5.1-codex-max', price: { input: 1.25, cachedInput: 0.125, output: 10 }, source: OPENAI_STANDARD_PRICING_SOURCE },
+    { id: 'gpt-5.1-codex-mini', price: { input: 0.25, cachedInput: 0.025, output: 2 }, source: OPENAI_STANDARD_PRICING_SOURCE },
+    { id: 'gpt-5-codex', price: { input: 1.25, cachedInput: 0.125, output: 10 }, source: OPENAI_STANDARD_PRICING_SOURCE },
+    { id: 'gpt-5-chat-latest', aliases: ['chat-latest'], price: { input: 5, cachedInput: 0.5, output: 30 }, source: OPENAI_STANDARD_PRICING_SOURCE },
+    { id: 'gpt-5-mini', price: { input: 0.25, cachedInput: 0.025, output: 2 }, source: OPENAI_STANDARD_PRICING_SOURCE },
+    { id: 'gpt-5-nano', price: { input: 0.05, cachedInput: 0.005, output: 0.4 }, source: OPENAI_STANDARD_PRICING_SOURCE },
+    { id: 'gpt-5', price: { input: 1.25, cachedInput: 0.125, output: 10 }, source: OPENAI_STANDARD_PRICING_SOURCE },
+    { id: 'gpt-4.1-mini', price: { input: 0.4, cachedInput: 0.1, output: 1.6 }, source: OPENAI_STANDARD_PRICING_SOURCE },
+    { id: 'gpt-4.1-nano', price: { input: 0.1, cachedInput: 0.025, output: 0.4 }, source: OPENAI_STANDARD_PRICING_SOURCE },
+    { id: 'gpt-4.1', price: { input: 2, cachedInput: 0.5, output: 8 }, source: OPENAI_STANDARD_PRICING_SOURCE },
+    { id: 'o4-mini-deep-research', price: { input: 1, cachedInput: 1, output: 4 }, source: OPENAI_STANDARD_PRICING_SOURCE, notes: 'cached-input discount not listed for deep research' },
+    { id: 'o4-mini', price: { input: 1.1, cachedInput: 0.275, output: 4.4 }, source: OPENAI_STANDARD_PRICING_SOURCE }
+];
+function modelCostSummary(jobs) {
+    const allCosts = jobs.map(modelCostForJob);
+    const costs = allCosts.filter((entry) => entry.price);
+    const unpricedCount = allCosts.length - costs.length;
+    const total = costs.reduce((sum, entry) => sum + entry.cost, 0);
+    if (!costs.length)
+        return { value: '-', detail: 'no priced model labels in this run' };
+    const billableTokenJobs = costs.filter((entry) => entry.uncachedInputTokens > 0 || entry.cachedInputTokens > 0 || entry.outputTokens > 0).length;
+    const models = uniqueStrings(costs.map((entry) => entry.model));
+    const outputJobs = costs.filter((entry) => entry.outputTokens > 0).length;
+    const estimated = costs.filter((entry) => entry.estimatedInput).length;
+    const longContextJobs = costs.filter((entry) => entry.longContext).length;
+    const pricingSources = uniqueStrings(costs.map((entry) => entry.pricingSource).filter((value) => Boolean(value)));
+    const modelText = models.length > 3 ? `${models.slice(0, 3).join(', ')} +${models.length - 3}` : models.join(', ');
+    const sourceText = pricingSources.length ? ` · ${pricingSources.join(', ')}` : '';
+    const unpricedText = unpricedCount ? ` · ${formatNumber(unpricedCount)} unpriced jobs` : '';
+    if (!billableTokenJobs || total <= 0) {
+        return { value: 'unknown', detail: `priced models found, awaiting billable token counts · ${modelText}${sourceText}${unpricedText}` };
+    }
+    const scope = outputJobs === 0 ? 'input-only' : outputJobs === costs.length ? 'input+output' : 'input+partial output';
+    const estimatedText = estimated ? ` · ${formatNumber(estimated)} estimated-input jobs` : '';
+    const longContextText = longContextJobs ? ` · ${formatNumber(longContextJobs)} long-context priced` : '';
+    const missingOutputText = outputJobs > 0 && outputJobs < costs.length ? ` · ${formatNumber(costs.length - outputJobs)} without output tokens` : '';
+    const noOutputText = outputJobs === 0 ? ' · no output tokens reported' : '';
+    return { value: formatUsd(total), detail: `${scope} estimate · ${modelText}${sourceText}${longContextText}${estimatedText}${missingOutputText}${noOutputText}${unpricedText}` };
+}
+function modelCostRows(jobs) {
+    return jobs
+        .map((job) => ({ job, cost: modelCostForJob(job) }))
+        .filter((entry) => entry.cost.price && entry.cost.cost > 0)
+        .sort((left, right) => right.cost.cost - left.cost.cost)
+        .slice(0, 5)
+        .map(({ job, cost }) => ({
+        label: `${ticketId(job)} · ${taskTitle(job)}`,
+        value: formatUsd(cost.cost),
+        detail: `${cost.model} estimate · ${formatNumber(cost.uncachedInputTokens)} uncached · ${formatNumber(cost.cachedInputTokens)} cached${cost.outputTokens ? ` · ${formatNumber(cost.outputTokens)} output` : ''}${cost.longContext ? ' · long context' : ''}${cost.estimatedInput ? ' · estimated input' : ''}`
+    }));
+}
+function modelCostForJob(job) {
+    const model = agentModelLabel(job);
+    const priceEntry = modelPriceEntryForModel(model);
+    const input = inputTokenBreakdownForJob(job);
+    const outputTokens = jobOutputTokens(job);
+    const longContext = Boolean(priceEntry?.longContextPrice && priceEntry.longContextThreshold && input.inputTokens > priceEntry.longContextThreshold);
+    const price = priceEntry ? (longContext ? priceEntry.longContextPrice ?? priceEntry.price : priceEntry.price) : undefined;
+    if (!price)
+        return { model, ...input, outputTokens, longContext: false, cost: 0 };
+    const cost = ((input.uncachedInputTokens * price.input) + (input.cachedInputTokens * price.cachedInput) + (outputTokens * price.output)) / 1_000_000;
+    return { model, price, pricingSource: priceEntry?.source, ...input, outputTokens, longContext, cost };
+}
+function modelPriceEntryForModel(model) {
+    const key = normalizedModelKey(model);
+    return MODEL_PRICES_PER_MILLION.find((entry) => modelPriceEntryMatches(key, entry));
+}
+function modelPriceEntryMatches(key, entry) {
+    return [entry.id, ...(entry.aliases ?? [])].some((candidate) => {
+        const normalizedCandidate = normalizedModelKey(candidate);
+        return key === normalizedCandidate || isDatedModelVariant(key, normalizedCandidate);
+    });
+}
+function isDatedModelVariant(key, base) {
+    if (!key.startsWith(`${base}-`))
+        return false;
+    const suffix = key.slice(base.length + 1);
+    return /^\d{4}-\d{2}-\d{2}(?:$|-)/.test(suffix);
+}
+function normalizedModelKey(value) {
+    const raw = value.toLowerCase().trim();
+    const pathKey = raw.includes('/') ? raw.split('/').pop() ?? raw : raw;
+    return pathKey.includes(':') ? pathKey.split(':').pop() ?? pathKey : pathKey;
+}
+function inputTokenBreakdownForJob(job) {
+    const usage = usageRecord(job);
+    const inputDetails = recordValue(job.inputTokensDetails ?? job.input_tokens_details ?? usage.input_tokens_details);
+    const promptDetails = recordValue(job.promptTokensDetails ?? job.prompt_tokens_details ?? usage.prompt_tokens_details);
+    const actualInput = firstPositiveNumber(job.actualInputTokens, job.inputTokens, job.promptTokens, job.actual_input_tokens, job.input_tokens, job.prompt_tokens, usage.input_tokens, usage.prompt_tokens);
+    const estimatedInput = firstPositiveNumber(job.estimatedInputTokens, job.estimated_input_tokens);
+    const reportedCached = firstPositiveNumber(job.cachedInputTokens, job.cachedPromptTokens, job.cached_input_tokens, job.cached_prompt_tokens, inputDetails.cached_tokens, promptDetails.cached_tokens, usage.cached_input_tokens, usage.cached_prompt_tokens, usage.cached_tokens);
+    const reportedUncached = firstPositiveNumber(job.uncachedInputTokens, job.uncached_input_tokens, usage.uncached_input_tokens);
+    const inputTokens = actualInput || estimatedInput || reportedCached + reportedUncached;
+    if (!actualInput) {
+        return {
+            inputTokens,
+            cachedInputTokens: 0,
+            uncachedInputTokens: inputTokens,
+            estimatedInput: inputTokens > 0
+        };
+    }
+    let cachedInputTokens = reportedCached ? Math.min(actualInput, reportedCached) : 0;
+    let uncachedInputTokens = reportedUncached ? Math.min(actualInput, reportedUncached) : Math.max(0, actualInput - cachedInputTokens);
+    if (reportedUncached && !reportedCached)
+        cachedInputTokens = Math.max(0, actualInput - uncachedInputTokens);
+    if (cachedInputTokens + uncachedInputTokens > actualInput) {
+        uncachedInputTokens = Math.min(actualInput, uncachedInputTokens);
+        cachedInputTokens = Math.max(0, actualInput - uncachedInputTokens);
+    }
+    if (cachedInputTokens + uncachedInputTokens < actualInput) {
+        uncachedInputTokens += actualInput - cachedInputTokens - uncachedInputTokens;
+    }
+    return {
+        inputTokens: actualInput,
+        cachedInputTokens,
+        uncachedInputTokens,
+        estimatedInput: false
+    };
+}
+function usageRecord(job) {
+    return recordValue(job.usage ?? job.tokenUsage ?? job.openaiUsage ?? job.openAIUsage);
+}
+function jobOutputTokens(job) {
+    const usage = usageRecord(job);
+    return firstPositiveNumber(job.actualOutputTokens, job.outputTokens, job.completionTokens, job.responseTokens, job.generatedTokens, job.actual_output_tokens, job.output_tokens, job.completion_tokens, job.response_tokens, job.generated_tokens, usage.output_tokens, usage.completion_tokens, usage.response_tokens, usage.generated_tokens);
+}
+function timeSeriesPoints(dashboard) {
+    const points = dashboard.timeSeries?.points;
+    return Array.isArray(points) ? points : [];
+}
+function timeSeriesPoint(point, key, label, tone = 'neutral', formatter = formatNumber) {
+    const value = numberValue(point[key]);
+    return {
+        label: formatTime(point.at),
+        value,
+        detail: `${formatter(value)} ${label}`,
+        tone
+    };
+}
+function contextPressureLabel(jobs) {
+    const summary = contextPressureSummary(jobs);
+    if (summary.failedCount)
+        return `${text(summary.failedCount)} failed budget`;
+    if (summary.warningCount)
+        return `${text(summary.warningCount)} warnings`;
+    if (summary.uncachedInputTokens)
+        return `${formatRatio(summary.uncachedRatio)} uncached/estimated`;
+    return 'no pressure';
+}
+function contextPressureSummary(jobs) {
+    const inputBreakdowns = jobs.map(inputTokenBreakdownForJob);
+    const actualValues = inputBreakdowns
+        .filter((input) => !input.estimatedInput)
+        .map((input) => input.inputTokens)
+        .filter((value) => value > 0)
+        .sort((left, right) => left - right);
+    const uncachedValues = inputBreakdowns
+        .map((input) => input.uncachedInputTokens)
+        .filter((value) => value > 0)
+        .sort((left, right) => left - right);
+    const estimatedInputTokens = inputBreakdowns.reduce((sum, input) => sum + (input.estimatedInput ? input.inputTokens : 0), 0);
+    const actualInputTokens = inputBreakdowns.reduce((sum, input) => sum + (input.estimatedInput ? 0 : input.inputTokens), 0);
+    const cachedInputTokens = inputBreakdowns.reduce((sum, input) => sum + input.cachedInputTokens, 0);
+    const uncachedInputTokens = inputBreakdowns.reduce((sum, input) => sum + input.uncachedInputTokens, 0);
+    return {
+        warningCount: jobs.filter(isContextBudgetWarningJob).length,
+        failedCount: jobs.filter(isContextBudgetFailedJob).length,
+        estimatedInputTokens,
+        actualInputTokens,
+        cachedInputTokens,
+        uncachedInputTokens,
+        p95ActualInputTokens: percentileValue(actualValues, 0.95),
+        p95UncachedInputTokens: percentileValue(uncachedValues, 0.95),
+        ratio: estimatedInputTokens > 0 && actualInputTokens > 0 ? actualInputTokens / estimatedInputTokens : 0,
+        uncachedRatio: estimatedInputTokens > 0 && uncachedInputTokens > 0 ? uncachedInputTokens / estimatedInputTokens : 0,
+        cacheHitRatio: actualInputTokens > 0 && cachedInputTokens > 0 ? cachedInputTokens / actualInputTokens : 0
+    };
+}
+function contextOffenderRows(jobs) {
+    return jobs
+        .map((job) => {
+        const input = inputTokenBreakdownForJob(job);
+        const actualInputTokens = input.estimatedInput ? 0 : input.inputTokens;
+        const uncachedInputTokens = input.uncachedInputTokens;
+        const estimatedInputTokens = input.estimatedInput ? input.inputTokens : 0;
+        const warning = isContextBudgetWarningJob(job);
+        const failed = isContextBudgetFailedJob(job);
+        return {
+            id: textValue(job.id ?? job.taskId ?? job.title, 'job'),
+            label: `${ticketId(job)} · ${taskTitle(job)}`,
+            lane: laneOf(job),
+            sourceLabel: textValue(job.sourceLabel, ''),
+            actualInputTokens,
+            uncachedInputTokens,
+            estimatedInputTokens,
+            statusLabel: failed ? 'budget failed' : warning ? 'budget warning' : 'reported usage'
+        };
+    })
+        .filter((job) => job.actualInputTokens > 0 || job.estimatedInputTokens > 0)
+        .sort((left, right) => (right.uncachedInputTokens || right.actualInputTokens || right.estimatedInputTokens) - (left.uncachedInputTokens || left.actualInputTokens || left.estimatedInputTokens))
+        .slice(0, 5);
+}
+function contextDriverDetail(job) {
+    return [job.lane, job.sourceLabel, job.statusLabel].filter(Boolean).join(' · ');
+}
+function uncachedInputTokensForJob(job) {
+    return inputTokenBreakdownForJob(job).uncachedInputTokens;
+}
+function isContextBudgetWarningJob(job) {
+    return numberValue(job.contextBudgetWarningCount) > 0
+        || normalized(job.contextBudgetStatus) === 'warning';
+}
+function isContextBudgetFailedJob(job) {
+    return numberValue(job.contextBudgetErrorCount) > 0
+        || normalized(job.contextBudgetStatus) === 'failed';
+}
+function percentileValue(values, percentile) {
+    if (!values.length)
+        return 0;
+    const index = Math.min(values.length - 1, Math.max(0, Math.ceil(values.length * percentile) - 1));
+    return values[index] ?? 0;
+}
+function failureOwnershipRows(attention, audit) {
+    return [
+        { label: 'Failed jobs', value: attention.failedCount, tone: 'bad' },
+        { label: 'Coordinator review', value: attention.needsCoordinatorReviewCount, tone: 'review' },
+        { label: 'Stale jobs', value: attention.staleCount, tone: 'warn' },
+        { label: 'Source violations', value: audit.sourceOwnershipViolationCount, tone: audit.sourceOwnershipViolationCount ? 'bad' : 'neutral' },
+        { label: 'Generated noise', value: generatedNoiseCount(audit), tone: generatedNoiseCount(audit) ? 'warn' : 'neutral' },
+        { label: 'Quarantined', value: audit.quarantinedChangedPathCount, tone: audit.quarantinedChangedPathCount ? 'warn' : 'neutral' }
+    ];
+}
+function eventBucketPoints(events, predicate, tone = 'neutral') {
+    const count = 12;
+    const buckets = Array.from({ length: count }, () => 0);
+    const times = events
+        .map((event) => Number(event.at))
+        .filter((value) => Number.isFinite(value) && value > 0);
+    const hasTimes = times.length > 0;
+    const min = hasTimes ? Math.min(...times) : 0;
+    const max = hasTimes ? Math.max(...times) : 0;
+    const span = Math.max(1, max - min);
+    events.forEach((event, index) => {
+        if (!predicate(event))
+            return;
+        const at = Number(event.at);
+        const bucket = hasTimes && Number.isFinite(at) && at > 0
+            ? Math.min(count - 1, Math.max(0, Math.floor(((at - min) / span) * (count - 1))))
+            : Math.min(count - 1, Math.floor((index / Math.max(1, events.length)) * count));
+        buckets[bucket] += 1;
+    });
+    return buckets.map((value, index) => ({
+        label: hasTimes ? formatTime(min + Math.round((span * index) / Math.max(1, count - 1))) : `Bucket ${index + 1}`,
+        value,
+        detail: `${formatNumber(value)} events`,
+        tone
+    }));
+}
+function jobValuePoints(jobs, key, formatter) {
+    return jobs.slice(-18).map((job) => {
+        const value = numberValue(job[key]);
+        return {
+            label: textValue(job.id ?? job.taskId ?? job.title, 'job'),
+            value,
+            detail: formatter(value)
+        };
+    });
+}
+function isProgressEvent(event) {
+    const value = `${textValue(event.type, '')} ${textValue(event.message, '')}`.toLowerCase();
+    return value.includes('complete')
+        || value.includes('ready')
+        || value.includes('accepted')
+        || value.includes('applied')
+        || value.includes('success');
+}
+function isAttentionEvent(event) {
+    const value = `${textValue(event.type, '')} ${textValue(event.message, '')}`.toLowerCase();
+    return value.includes('fail')
+        || value.includes('error')
+        || value.includes('reject')
+        || value.includes('blocked')
+        || value.includes('stale')
+        || value.includes('needs');
+}
+function formatNumber(value) {
+    return new Intl.NumberFormat('en-US').format(Math.round(value));
+}
+function formatUsd(value) {
+    if (!Number.isFinite(value) || value <= 0)
+        return '$0.00';
+    if (value < 0.01)
+        return `$${value.toFixed(4)}`;
+    return new Intl.NumberFormat('en-US', { style: 'currency', currency: 'USD', maximumFractionDigits: value < 10 ? 2 : 0 }).format(value);
+}
+function formatBytes(value) {
+    if (!value)
+        return '0 B';
+    const units = ['B', 'KiB', 'MiB', 'GiB'];
+    let size = value;
+    let unit = 0;
+    while (size >= 1024 && unit < units.length - 1) {
+        size /= 1024;
+        unit += 1;
+    }
+    return `${size >= 10 || unit === 0 ? Math.round(size) : size.toFixed(1)} ${units[unit]}`;
+}
+function formatRatio(value) {
+    if (!Number.isFinite(value) || value <= 0)
+        return '-';
+    return `${value >= 10 ? Math.round(value) : value.toFixed(1)}x`;
+}
+function formatPercent(value) {
+    if (!Number.isFinite(value) || value <= 0)
+        return '0%';
+    const percent = value * 100;
+    if (value < 1 && percent > 99)
+        return `${floorToDecimal(percent, 1)}%`;
+    if (Math.abs(percent - Math.round(percent)) >= 0.25)
+        return `${percent.toFixed(1)}%`;
+    return `${Math.round(percent)}%`;
+}
+function percentNumber(value) {
+    if (!Number.isFinite(value) || value <= 0)
+        return 0;
+    const percent = value * 100;
+    if (value < 1 && percent > 99)
+        return floorToDecimal(percent, 1);
+    return Math.round(percent * 10) / 10;
+}
+function floorToDecimal(value, digits) {
+    const scale = 10 ** digits;
+    return Math.floor(value * scale) / scale;
+}
+function formatDuration(value) {
+    if (!value)
+        return '0 ms';
+    if (value < 1000)
+        return `${Math.round(value)} ms`;
+    const seconds = value / 1000;
+    if (seconds < 60)
+        return `${seconds >= 10 ? Math.round(seconds) : seconds.toFixed(1)} s`;
+    const minutes = seconds / 60;
+    return `${minutes >= 10 ? Math.round(minutes) : minutes.toFixed(1)} min`;
+}
+function formatBucketSize(value) {
+    const ms = numberValue(value);
+    if (!ms)
+        return 'time';
+    if (ms < 1000)
+        return `${ms} ms`;
+    if (ms < 60000)
+        return `${Math.round(ms / 1000)} s`;
+    return `${Math.round(ms / 60000)} min`;
+}
+function semanticMetrics(value) {
+    const input = recordValue(value);
+    const imports = recordValue(input.import);
+    const edit = recordValue(input.edit);
+    const script = recordValue(edit.script);
+    const replay = recordValue(input.replay);
+    const admission = recordValue(input.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)
+    };
+    return {
+        ...metrics,
+        total: metrics.expected + metrics.satisfied + metrics.candidates + metrics.autoMerge + metrics.acceptedClean + metrics.conflicts,
+        admissionRows,
+        admissionTotal: admissionRows.reduce((sum, row) => sum + row.value, 0)
+    };
+}
+function semanticSuccessRows(value) {
+    const input = recordValue(value);
+    const imports = recordValue(input.import);
+    const edit = recordValue(input.edit);
+    const script = recordValue(edit.script);
+    const projection = recordValue(edit.projection);
+    const replay = recordValue(input.replay);
+    const rows = [
+        { label: 'Imports satisfied', value: numberValue(imports.expectedSatisfiedCount), tone: 'good' },
+        { label: 'Auto-merge candidates', value: numberValue(script.autoMergeCandidateCount), tone: 'good' },
+        { label: 'Portable edit scripts', value: numberValue(script.portableCount), tone: 'good' },
+        { label: 'Projected edits', value: numberValue(projection.appliedEditCount), tone: 'good' },
+        { label: 'Replay accepted clean', value: numberValue(replay.acceptedCleanCount), tone: 'good' },
+        { label: 'Already applied', value: numberValue(replay.alreadyAppliedCount), tone: 'good' }
+    ];
+    return rows.filter((row) => row.value > 0);
+}
+function semanticAdmissionRows(value, prefix) {
+    const input = recordValue(value);
+    const statusCounts = recordValue(input.statusCounts);
+    const rows = Object.entries(statusCounts)
+        .map(([label, count]) => ({
+        label: `${prefix} ${label}`,
+        value: numberValue(count),
+        tone: admissionTone(label)
+    }))
+        .filter((row) => row.value > 0);
+    for (const [key, label] of [
+        ['autoMergeCandidateCount', 'auto-merge'],
+        ['cleanEligibleCount', 'clean eligible'],
+        ['portableCount', 'portable'],
+        ['cleanEligibleCandidateCount', 'clean candidates']
+    ]) {
+        const value = numberValue(input[key]);
+        if (value > 0)
+            rows.push({ label: `${prefix} ${label}`, value, tone: admissionTone(label) });
+    }
+    return rows;
+}
+function admissionTone(value) {
+    const label = value.toLowerCase();
+    if (label.includes('fail') || label.includes('reject') || label.includes('conflict') || label.includes('blocked') || label.includes('stale'))
+        return 'bad';
+    if (label.includes('needs') || label.includes('warning'))
+        return 'warn';
+    if (label.includes('clean') || label.includes('auto') || label.includes('portable') || label.includes('accept'))
+        return 'good';
+    return 'neutral';
+}
+function recordValue(value) {
+    return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+}
+function arrayRecords(value) {
+    return Array.isArray(value) ? value.map(recordValue).filter((entry) => Object.keys(entry).length > 0) : [];
+}
+function stringArray(value) {
+    return Array.isArray(value) ? value.map(String).filter(Boolean) : [];
+}
+function normalized(value) {
+    return textValue(value, '').toLowerCase();
+}
+function formatTime(value) {
+    const number = Number(value);
+    if (!Number.isFinite(number) || number <= 0)
+        return '-';
+    return new Date(number).toISOString().replace('T', ' ').replace('.000Z', 'Z');
+}
+function bucketText(value) {
+    if (!value || typeof value !== 'object')
+        return '-';
+    const counts = value;
+    return `${text(counts['ready-to-apply'])}/${text(counts.total)}`;
+}
+//# sourceMappingURL=client.js.map