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

package/dist/server.js

@@ -4,7 +4,7 @@ import fs from 'node:fs/promises';
 import http from 'node:http';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
-import { readCodexDashboardSnapshot } from '@shapeshift-labs/frontier-swarm-codex';
+import { estimateCodexModelCost, readCodexDashboardSnapshot } from '@shapeshift-labs/frontier-swarm-codex';
 const packageDir = path.dirname(fileURLToPath(import.meta.url));
 const HEALTH_JSON_PARSE_MAX_BYTES = 16 * 1024 * 1024;
 const TASK_DETAIL_PATCH_MAX_BYTES = 512 * 1024;
@@ -13,13 +13,20 @@ const ARTIFACT_VIEW_MAX_BYTES = 768 * 1024;
 const ARTIFACT_DIRECTORY_MAX_ENTRIES = 200;
 const HUMAN_ACTION_ANSWER_MAX_BYTES = 16 * 1024;
 const CODEX_EVENTS_USAGE_MAX_BYTES = 8 * 1024 * 1024;
-const LIFETIME_DASHBOARD_MAX_SOURCES = 80;
+const DASHBOARD_SNAPSHOT_CACHE_MS = 5000;
+const LIFETIME_DASHBOARD_MAX_SOURCES = 24;
 const LIFETIME_DASHBOARD_MAX_JOBS = 800;
 const LIFETIME_DASHBOARD_SCAN_MAX_FILES = 600;
 const LIFETIME_DASHBOARD_SCAN_MAX_DEPTH = 5;
+const LIFETIME_DASHBOARD_MAX_AUTONOMOUS_DECISION_FILES = 400;
+const LIFETIME_DASHBOARD_MAX_DRAIN_RUNS = 6;
+const LIFETIME_DASHBOARD_MAX_ACTIVE_PID_RUNS = 32;
+const LIFETIME_DASHBOARD_MAX_QUEUE_TASKS = 500;
+const LIFETIME_DASHBOARD_SOURCE_TIMEOUT_MS = 2500;
 const LIFETIME_DASHBOARD_RESET_FILE = '.loom-ui-reset.json';
 const REVIEW_DECISIONS_FILE = '.loom-ui-review-decisions.json';
 const dashboardStreamListeners = new Set();
+let dashboardSnapshotCache;
 export function createLoomUiServer(options = {}) {
     const normalized = normalizeServerOptions(options);
     const server = http.createServer(async (request, response) => {
@@ -64,10 +71,10 @@ async function handleRequest(request, response, options) {
         await streamDashboard(request, response, options);
     }
     else if (request.method === 'GET' && url.pathname === '/api/dashboard') {
-        writeJson(response, 200, await readDashboardSnapshot(options));
+        writeJson(response, 200, await readDashboardSnapshotCached(options));
     }
     else if (request.method === 'GET' && url.pathname === '/api/task-details') {
-        writeJson(response, 200, await readTaskDetails(options, textValue(url.searchParams.get('id'), '')));
+        writeJson(response, 200, await readTaskDetails(options, textValue(url.searchParams.get('id'), ''), textValue(url.searchParams.get('sourceRun'), '')));
     }
     else if (request.method === 'GET' && url.pathname === '/api/artifact') {
         writeJson(response, 200, await readArtifact(options, textValue(url.searchParams.get('path'), '')));
@@ -114,7 +121,7 @@ async function streamDashboard(request, response, options) {
             return;
         pending = true;
         try {
-            const snapshot = await readDashboardSnapshot(options);
+            const snapshot = await readDashboardSnapshotCached(options);
             const signature = dashboardStreamSignature(snapshot);
             const body = JSON.stringify(snapshot);
             if (signature !== lastSignature) {
@@ -172,6 +179,16 @@ function debounce(fn, delayMs) {
         }, delayMs);
     };
 }
+function withTimeout(promise, timeoutMs, message) {
+    let timer;
+    const timeout = new Promise((_resolve, reject) => {
+        timer = setTimeout(() => reject(new Error(message)), timeoutMs);
+    });
+    return Promise.race([promise, timeout]).finally(() => {
+        if (timer)
+            clearTimeout(timer);
+    });
+}
 async function createDashboardWatchers(options, onChange) {
     const roots = await dashboardWatchRoots(options);
     const watchers = [];
@@ -189,7 +206,10 @@ async function createDashboardWatchers(options, onChange) {
 }
 function watchDirectory(root, recursive, onChange) {
     try {
-        return watch(root, { recursive }, onChange);
+        return watch(root, { recursive }, () => {
+            invalidateDashboardSnapshotCache();
+            onChange();
+        });
     }
     catch {
         return undefined;
@@ -209,6 +229,9 @@ async function dashboardWatchRoots(options) {
         const agentRuns = path.join(options.cwd, 'agent-runs');
         if (await fileExists(agentRuns))
             roots.push(agentRuns);
+        const loomQueues = path.join(options.cwd, '.loom', 'queues');
+        if (await fileExists(loomQueues))
+            roots.push(loomQueues);
     }
     return uniquePaths(roots);
 }
@@ -247,10 +270,39 @@ async function readDashboardSnapshot(options) {
         return readLifetimeDashboardSnapshot(options);
     return readScopedDashboardSnapshot(options);
 }
-async function readScopedDashboardSnapshot(options) {
+async function readDashboardSnapshotCached(options) {
+    const key = JSON.stringify(dashboardInput(options));
+    const now = Date.now();
+    if (dashboardSnapshotCache?.key === key) {
+        if (dashboardSnapshotCache.value !== undefined && now - dashboardSnapshotCache.at < DASHBOARD_SNAPSHOT_CACHE_MS) {
+            return dashboardSnapshotCache.value;
+        }
+        if (dashboardSnapshotCache.pending)
+            return dashboardSnapshotCache.pending;
+    }
+    const pending = readDashboardSnapshot(options).then((value) => {
+        dashboardSnapshotCache = { key, at: Date.now(), value };
+        return value;
+    }, (error) => {
+        if (dashboardSnapshotCache?.key === key) {
+            dashboardSnapshotCache = dashboardSnapshotCache.value === undefined
+                ? undefined
+                : { key, at: dashboardSnapshotCache.at, value: dashboardSnapshotCache.value };
+        }
+        throw error;
+    });
+    dashboardSnapshotCache = { key, at: now, value: dashboardSnapshotCache?.key === key ? dashboardSnapshotCache.value : undefined, pending };
+    return pending;
+}
+function invalidateDashboardSnapshotCache() {
+    dashboardSnapshotCache = undefined;
+}
+async function readScopedDashboardSnapshot(options, readOptions = {}) {
     const snapshot = await readCodexDashboardSnapshot(dashboardInput(options));
-    const activeRunSnapshot = await readActiveRunSnapshot(options);
+    const activeRunSnapshot = readOptions.includeActiveRun === false ? undefined : await readActiveRunSnapshot(options);
     const reviewDecisions = await readCoordinatorReviewDecisions(options.cwd);
+    const autonomousDecisions = await readAutonomousMergeDecisions(options.cwd);
+    const decisions = mergeReviewDecisionLists(reviewDecisions, autonomousDecisions);
     if (!snapshot || typeof snapshot !== 'object' || Array.isArray(snapshot))
         return activeRunSnapshot ?? snapshot;
     const answers = await readHumanActionAnswers(options);
@@ -258,15 +310,18 @@ async function readScopedDashboardSnapshot(options) {
     const jobs = Array.isArray(record.jobs) ? record.jobs : [];
     const activeJobs = recordArray(activeRunSnapshot?.jobs);
     if (shouldPreferActiveRunSnapshot(jobs, activeJobs)) {
+        const activeAgentRows = activeAgentsFromJobs(activeJobs);
         return {
             ...activeRunSnapshot,
             collectionJobs: jobs,
+            activeAgents: activeAgentRows,
             humanActions: recordArray(record.humanActions),
             humanActionAnswers: answers,
             sources: {
                 ...recordValue(record.sources),
                 ...recordValue(activeRunSnapshot?.sources),
                 ...(reviewDecisions.length ? { coordinatorReviewDecisions: coordinatorReviewDecisionPath(options.cwd) } : {}),
+                ...(autonomousDecisions.length ? { autonomousMergeDecisions: autonomousDecisionSourceSummary(autonomousDecisions) } : {}),
                 ...(answers.length ? { humanActionAnswers: await humanActionAnswerLogPath(options) } : {})
             },
             raw: {
@@ -279,14 +334,16 @@ async function readScopedDashboardSnapshot(options) {
             }
         };
     }
-    const mergedJobs = applyCoordinatorReviewDecisions(mergeActiveRunJobTelemetry(jobs, activeJobs), reviewDecisions);
+    const mergedJobs = applyCoordinatorReviewDecisions(mergeActiveRunJobTelemetry(jobs, activeJobs), decisions).map(withRecomputedCostFields);
     return {
         ...normalizeCoordinatorFacingSnapshot(record),
         jobs: mergedJobs,
+        activeAgents: activeAgentsFromJobs(mergedJobs),
         humanActionAnswers: answers,
         sources: {
             ...recordValue(record.sources),
             ...(reviewDecisions.length ? { coordinatorReviewDecisions: coordinatorReviewDecisionPath(options.cwd) } : {}),
+            ...(autonomousDecisions.length ? { autonomousMergeDecisions: autonomousDecisionSourceSummary(autonomousDecisions) } : {}),
             ...(answers.length ? { humanActionAnswers: await humanActionAnswerLogPath(options) } : {})
         }
     };
@@ -294,22 +351,39 @@ async function readScopedDashboardSnapshot(options) {
 async function readLifetimeDashboardSnapshot(options) {
     const sources = await discoverLifetimeDashboardSources(options.cwd);
     const snapshots = [];
+    let skippedSourceCount = 0;
+    let timedOutSourceCount = 0;
     for (const source of sources.slice(0, LIFETIME_DASHBOARD_MAX_SOURCES)) {
         try {
-            const snapshot = recordValue(await readScopedDashboardSnapshot({
-                ...options,
-                run: source.run,
-                collection: source.collection,
-                continuation: source.continuation
-            }));
+            const snapshot = await withTimeout((async () => {
+                const scopedSnapshot = await readScopedDashboardSnapshot({
+                    ...options,
+                    run: source.run,
+                    collection: source.collection,
+                    continuation: source.continuation
+                }, { includeActiveRun: false });
+                return enrichLifetimeRunSnapshotEvidence(options.cwd, source, recordValue(scopedSnapshot));
+            })(), LIFETIME_DASHBOARD_SOURCE_TIMEOUT_MS, `lifetime source timed out: ${source.path}`);
             if (Object.keys(snapshot).length)
                 snapshots.push({ source, snapshot });
         }
-        catch {
+        catch (error) {
+            skippedSourceCount++;
+            if (error instanceof Error && error.message.startsWith('lifetime source timed out:'))
+                timedOutSourceCount++;
             continue;
         }
     }
-    return combineLifetimeDashboardSnapshots(options, sources, snapshots, await readCoordinatorReviewDecisions(options.cwd));
+    const lifetime = await combineLifetimeDashboardSnapshots(options, sources, snapshots, mergeReviewDecisionLists(await readCoordinatorReviewDecisions(options.cwd), await readAutonomousMergeDecisions(options.cwd)), await readLifetimeQueueBacklog(options.cwd));
+    const lifetimeWithSourceHealth = {
+        ...lifetime,
+        sources: {
+            ...recordValue(lifetime.sources),
+            skippedSourceCount,
+            timedOutSourceCount
+        }
+    };
+    return mergeLifetimeActiveRunSnapshot(mergeLifetimeDrainCoordinatorSnapshot(lifetimeWithSourceHealth, await readLatestDrainCoordinatorSnapshot(options.cwd)), await readLifetimeActiveRunSnapshot(options));
 }
 async function discoverLifetimeDashboardSources(cwd) {
     const root = path.join(cwd, 'agent-runs');
@@ -341,7 +415,7 @@ async function discoverLifetimeDashboardSources(cwd) {
             continue;
         const hasCollection = entry.files.has('collection.json') || entry.files.has('coordinator-query.json');
         const hasContinuation = entry.files.has('continuation.json');
-        const hasRun = entry.files.has('swarm-results.json') || entry.files.has('pids.json') || entry.files.has('coordinator-dashboard.json');
+        const hasRun = entry.files.has('swarm-results.json') || entry.files.has('coordinator-dashboard.json');
         if (hasCollection) {
             out.push({
                 id: `collection:${relative}`,
@@ -378,17 +452,54 @@ async function discoverLifetimeDashboardSources(cwd) {
     return dedupeLifetimeDashboardSources(out).sort((left, right) => right.mtimeMs - left.mtimeMs || left.path.localeCompare(right.path));
 }
 function dedupeLifetimeDashboardSources(sources) {
-    const collections = new Set(sources.filter((source) => source.kind === 'collection').map(lifetimeRunFamilyKey));
+    const preferredCollections = preferredLifetimeCollectionsByFamily(sources);
     const runs = new Set(sources.filter((source) => source.kind === 'run').map(lifetimeRunFamilyKey));
     return sources.filter((source) => {
         const family = lifetimeRunFamilyKey(source);
-        if (source.kind === 'run' && collections.has(family))
+        if (source.kind === 'collection' && preferredCollections.get(family) !== source)
             return false;
         if (source.kind === 'collection' && source.path.endsWith('/collected-missing') && runs.has(family))
             return false;
         return true;
     });
 }
+function preferredLifetimeCollectionsByFamily(sources) {
+    const out = new Map();
+    for (const source of sources) {
+        if (source.kind !== 'collection')
+            continue;
+        const family = lifetimeRunFamilyKey(source);
+        const current = out.get(family);
+        if (!current || compareLifetimeCollectionPreference(source, current) > 0)
+            out.set(family, source);
+    }
+    return out;
+}
+function compareLifetimeCollectionPreference(left, right) {
+    return lifetimeCollectionPreference(left) - lifetimeCollectionPreference(right)
+        || left.mtimeMs - right.mtimeMs
+        || right.path.localeCompare(left.path);
+}
+function lifetimeCollectionPreference(source) {
+    const pathLabel = normalized(source.path);
+    if (pathLabel.endsWith('/post-coordinator-collected') || pathLabel.includes('/post-coordinator-collected'))
+        return 80;
+    if (pathLabel.endsWith('/coordinator-collected') || pathLabel.includes('/coordinator-collected'))
+        return 70;
+    if (pathLabel.endsWith('/collected-resolved') || pathLabel.includes('/collected-resolved-'))
+        return 60;
+    if (pathLabel.endsWith('/collected-with-decisions') || pathLabel.includes('/collected-with-decisions-'))
+        return 55;
+    if (pathLabel.endsWith('/collected'))
+        return 50;
+    if (pathLabel.includes('/collected-current'))
+        return 30;
+    if (pathLabel.includes('/collected-partial'))
+        return 20;
+    if (pathLabel.includes('/collected-missing'))
+        return 10;
+    return 40;
+}
 function lifetimeRunFamilyKey(source) {
     const parts = source.path.split(/[\\/]/g).filter(Boolean);
     if (!parts.length)
@@ -397,6 +508,283 @@ function lifetimeRunFamilyKey(source) {
     const start = agentRunsIndex >= 0 ? agentRunsIndex + 1 : 0;
     return parts[start] ?? source.path;
 }
+function lifetimeRunRootKey(source) {
+    const parts = source.path.split(/[\\/]/g).filter(Boolean);
+    if (!parts.length)
+        return source.path;
+    const agentRunsIndex = parts.lastIndexOf('agent-runs');
+    const start = agentRunsIndex >= 0 ? agentRunsIndex + 1 : 0;
+    const rootParts = parts.slice(start, start + 2);
+    return rootParts.length ? rootParts.join('/') : source.path;
+}
+function isDrainedAutonomousRunSnapshot(snapshot) {
+    const rawRun = recordValue(recordValue(snapshot.raw).run);
+    const autoDrain = recordValue(rawRun.autoDrain);
+    const autoDrainSummary = recordValue(autoDrain.summary);
+    const artifactSummary = recordValue(recordValue(rawRun.autoDrainArtifacts).summary);
+    const summary = Object.keys(autoDrainSummary).length ? autoDrainSummary : artifactSummary;
+    if (!Object.keys(summary).length)
+        return false;
+    if (textValue(summary.rerunManifestTerminalState, '') !== 'drained')
+        return false;
+    if (numberValue(summary.remainingReadyCount) > 0)
+        return false;
+    if (numberValue(summary.humanBlockedCount) > 0 || numberValue(summary.humanBlockedDecisionCount) > 0)
+        return false;
+    if (numberValue(summary.conflictBlockedCount) > 0 || numberValue(summary.rerunTaskCount) > 0)
+        return false;
+    return numberValue(summary.committedDecisionCount) > 0 || numberValue(summary.terminalCount) > 0 || numberValue(summary.decisionCount) > 0;
+}
+function collapseSupersededLifetimeReviewJobs(jobs) {
+    const resolvedAtByJob = new Map();
+    for (const job of jobs) {
+        if (!isResolvedCoordinatorReviewRecord(job))
+            continue;
+        const key = lifetimeReviewDedupeKey(job);
+        if (!key)
+            continue;
+        resolvedAtByJob.set(key, Math.max(resolvedAtByJob.get(key) ?? 0, numberValue(job.generatedAt)));
+    }
+    return jobs.filter((job) => {
+        if (!isOpenCoordinatorReviewRecord(job))
+            return true;
+        const key = lifetimeReviewDedupeKey(job);
+        if (!key)
+            return true;
+        return (resolvedAtByJob.get(key) ?? 0) < numberValue(job.generatedAt);
+    });
+}
+function dedupeLifetimeDashboardJobs(jobs) {
+    const byTask = new Map();
+    for (const job of jobs) {
+        const key = lifetimeJobDedupeKey(job);
+        if (!key)
+            continue;
+        const current = byTask.get(key);
+        if (!current || compareLifetimeJobPreference(job, current) > 0)
+            byTask.set(key, job);
+    }
+    return Array.from(byTask.values()).sort((left, right) => {
+        return numberValue(right.generatedAt) - numberValue(left.generatedAt)
+            || textValue(left.lane, '').localeCompare(textValue(right.lane, ''))
+            || textValue(left.title, '').localeCompare(textValue(right.title, ''));
+    });
+}
+function lifetimeJobDedupeKey(job) {
+    return canonicalLifetimeTaskKey(textValue(job.originalJobId ?? job.taskId ?? job.id ?? job.jobId, ''));
+}
+function compareLifetimeJobPreference(left, right) {
+    return lifetimeJobPreference(left) - lifetimeJobPreference(right)
+        || numberValue(left.generatedAt) - numberValue(right.generatedAt)
+        || textValue(right.sourceLabel, '').localeCompare(textValue(left.sourceLabel, ''));
+}
+function lifetimeJobPreference(job) {
+    const status = normalized(job.status);
+    const bucket = normalized(job.bucket);
+    const liveness = normalized(job.liveness);
+    let score = 0;
+    if (status === 'running')
+        score += 120;
+    else if (status === 'completed')
+        score += 100;
+    else if (status === 'failed' || status === 'blocked')
+        score += 70;
+    else if (['queued', 'pending', 'todo', 'open'].includes(status) || ['queued', 'todo'].includes(bucket))
+        score += 40;
+    if (liveness === 'missing' || status === 'planned')
+        score -= 60;
+    if (numberValue(job.changedPathCount))
+        score += 12;
+    if (numberValue(job.evidencePathCount))
+        score += 8;
+    if (numberValue(job.actualInputTokens) || numberValue(job.estimatedInputTokens))
+        score += 4;
+    return score;
+}
+function lifetimeReviewDedupeKey(job) {
+    return canonicalLifetimeTaskKey(textValue(job.originalJobId ?? job.jobId ?? job.taskId, ''));
+}
+function canonicalLifetimeTaskKey(value) {
+    return unscopedLifetimeTaskKey(value)
+        .trim()
+        .replace(/(?:-continuation)?-rerun(?:-\d+)?$/u, '')
+        .replace(/(?:-continuation)?-retry(?:-\d+)?$/u, '');
+}
+function unscopedLifetimeTaskKey(value) {
+    const trimmed = value.trim();
+    const match = /^(?:run|collection|continuation):.+:([^:]+)$/u.exec(trimmed);
+    return match?.[1] ?? trimmed;
+}
+function isOpenCoordinatorReviewRecord(job) {
+    if (isResolvedCoordinatorReviewRecord(job))
+        return false;
+    return isCoordinatorPortBucket(job.bucket)
+        || isCoordinatorPortBucket(job.disposition)
+        || isCoordinatorPortBucket(job.mergeReadiness)
+        || normalized(job.status) === 'needs-review';
+}
+function isResolvedCoordinatorReviewRecord(job) {
+    const bucket = normalized(job.bucket);
+    if (bucket === 'review-resolved' || bucket === 'resolved-review' || job.reviewResolved === true)
+        return true;
+    const status = textValue(job.coordinatorDecisionStatus ?? recordValue(job.coordinatorDecision).status, '');
+    return Boolean(status) && isResolvedCoordinatorDecision(status);
+}
+async function readLifetimeQueueBacklog(cwd) {
+    const root = path.join(cwd, '.loom', 'queues');
+    const stat = await fs.stat(root).catch(() => undefined);
+    if (!stat?.isDirectory())
+        return { entries: [], manifests: [], sourceCount: 0, paths: [], generatedAt: 0 };
+    const queueDirs = await fs.readdir(root, { withFileTypes: true }).catch(() => []);
+    const entriesById = new Map();
+    const manifests = [];
+    const paths = [];
+    let generatedAt = 0;
+    for (const queueDir of queueDirs) {
+        if (!queueDir.isDirectory())
+            continue;
+        const dir = path.join(root, queueDir.name);
+        const manifestFile = await preferredQueueManifestFile(dir);
+        if (manifestFile) {
+            const manifestStat = await fs.stat(manifestFile).catch(() => undefined);
+            generatedAt = Math.max(generatedAt, manifestStat?.mtimeMs ?? 0);
+            const manifest = await readQueueCapacityManifest(cwd, manifestFile);
+            if (manifest)
+                manifests.push(manifest);
+        }
+        for (const taskFile of await queueTaskFiles(dir)) {
+            const fileStat = await fs.stat(taskFile).catch(() => undefined);
+            generatedAt = Math.max(generatedAt, fileStat?.mtimeMs ?? 0);
+            paths.push(path.relative(cwd, taskFile));
+            const tasks = await readQueueTaskFile(taskFile);
+            for (const task of tasks) {
+                const id = textValue(task.id ?? task.taskId ?? task.title, '');
+                if (!id)
+                    continue;
+                entriesById.set(id, normalizeQueueBacklogEntry(cwd, queueDir.name, taskFile, task));
+                if (entriesById.size >= LIFETIME_DASHBOARD_MAX_QUEUE_TASKS)
+                    break;
+            }
+            if (entriesById.size >= LIFETIME_DASHBOARD_MAX_QUEUE_TASKS)
+                break;
+        }
+        if (entriesById.size >= LIFETIME_DASHBOARD_MAX_QUEUE_TASKS)
+            break;
+    }
+    return {
+        entries: Array.from(entriesById.values()),
+        manifests,
+        sourceCount: paths.length,
+        paths,
+        generatedAt
+    };
+}
+async function queueTaskFiles(dir) {
+    const entries = await fs.readdir(dir, { withFileTypes: true }).catch(() => []);
+    const candidates = [];
+    for (const entry of entries) {
+        if (!entry.isFile() || !/^tasks(?:\.(?:remaining|backlog)-[\w.-]+)?\.json$/.test(entry.name))
+            continue;
+        const file = path.join(dir, entry.name);
+        const stat = await fs.stat(file).catch(() => undefined);
+        candidates.push({
+            file,
+            mtimeMs: stat?.mtimeMs ?? 0,
+            preferred: entry.name.startsWith('tasks.backlog-') ? 2 : entry.name.startsWith('tasks.remaining-') ? 1 : 0
+        });
+    }
+    return candidates
+        .sort((left, right) => left.mtimeMs - right.mtimeMs || left.preferred - right.preferred || left.file.localeCompare(right.file))
+        .map((candidate) => candidate.file);
+}
+async function preferredQueueManifestFile(dir) {
+    const entries = await fs.readdir(dir, { withFileTypes: true }).catch(() => []);
+    const candidates = [];
+    for (const entry of entries) {
+        if (!entry.isFile() || !/^manifest(?:\.[\w.-]+)?\.json$/.test(entry.name))
+            continue;
+        const file = path.join(dir, entry.name);
+        const stat = await fs.stat(file).catch(() => undefined);
+        candidates.push({
+            file,
+            mtimeMs: stat?.mtimeMs ?? 0,
+            preferred: entry.name.includes('high-concurrency') ? 2 : entry.name === 'manifest.json' ? 1 : 0
+        });
+    }
+    return candidates.sort((left, right) => right.preferred - left.preferred || right.mtimeMs - left.mtimeMs || left.file.localeCompare(right.file))[0]?.file;
+}
+async function readQueueCapacityManifest(cwd, file) {
+    const raw = recordValue(await readJsonFile(file));
+    if (!Object.keys(raw).length)
+        return undefined;
+    const computeRows = recordArray(raw.compute);
+    const computeById = new Map(computeRows.map((entry) => [textValue(entry.id, ''), entry]));
+    const defaultComputeId = textValue(recordValue(raw.policy).defaultCompute, textValue(computeRows[0]?.id, ''));
+    const defaultCompute = recordValue(computeById.get(defaultComputeId) ?? computeRows[0]);
+    const defaultConcurrency = numberValue(recordValue(raw.policy).defaultConcurrency);
+    const computeMaxConcurrency = computeRows.reduce((max, entry) => Math.max(max, numberValue(entry.maxConcurrency)), 0);
+    const manifestMaxConcurrency = numberValue(raw.maxConcurrency);
+    const lanes = recordArray(raw.lanes).map((lane) => {
+        const computeId = textValue(lane.compute, defaultComputeId);
+        const compute = recordValue(computeById.get(computeId) ?? defaultCompute);
+        return {
+            id: textValue(lane.id, 'lane'),
+            title: textValue(lane.title ?? lane.id, 'Lane'),
+            layer: textValue(lane.layer, ''),
+            compute: computeId,
+            model: textValue(compute.model, textValue(compute.id, '')),
+            maxConcurrency: numberValue(lane.maxConcurrency) || 1
+        };
+    });
+    return {
+        path: path.relative(cwd, file),
+        id: textValue(raw.id, path.basename(file, '.json')),
+        title: textValue(raw.title, 'Swarm manifest'),
+        defaultConcurrency,
+        computeMaxConcurrency,
+        maxConcurrency: manifestMaxConcurrency || defaultConcurrency || computeMaxConcurrency || lanes.reduce((sum, lane) => sum + lane.maxConcurrency, 0),
+        lanes
+    };
+}
+async function readQueueTaskFile(file) {
+    const raw = await readJsonFile(file);
+    if (Array.isArray(raw))
+        return raw.map(recordValue).filter((entry) => Object.keys(entry).length);
+    const record = recordValue(raw);
+    return recordArray(record.tasks ?? record.entries ?? record.items);
+}
+function normalizeQueueBacklogEntry(cwd, queueId, file, task) {
+    const id = textValue(task.id ?? task.taskId ?? task.title, 'task');
+    const queueStatus = textValue(task.status ?? task.state, 'open');
+    const status = ['done', 'completed', 'failed', 'blocked'].includes(normalized(queueStatus)) ? queueStatus : 'todo';
+    const sourceRefs = stringArray(task.sourceRefs);
+    const targetRefs = stringArray(task.targetRefs);
+    const allowedWrites = stringArray(task.allowedWrites);
+    const files = uniquePaths([...targetRefs, ...allowedWrites, ...sourceRefs]).slice(0, 40);
+    return {
+        id,
+        taskId: id,
+        title: textValue(task.title ?? task.objective ?? id, id),
+        objective: textValue(task.objective ?? task.summary, ''),
+        status,
+        queueStatus,
+        ready: status === 'todo',
+        lane: textValue(task.lane ?? task.groupId ?? task.epicId, queueId),
+        group: textValue(task.groupId ?? task.epicId, queueId),
+        epicId: textValue(task.epicId, ''),
+        priority: numberValue(task.priority),
+        changedPaths: files,
+        changedPathCount: files.length,
+        sourceRefs,
+        targetRefs,
+        allowedWrites,
+        acceptance: stringArray(task.acceptance),
+        verification: recordArray(task.verification),
+        tags: stringArray(task.tags),
+        sourceLabel: path.relative(cwd, file),
+        sourceQueue: queueId
+    };
+}
 async function readLifetimeDashboardResetCutoff(root) {
     const reset = recordValue(await readJsonFile(path.join(root, LIFETIME_DASHBOARD_RESET_FILE)));
     return numberValue(reset.resetAt ?? reset.generatedAt);
@@ -431,23 +819,47 @@ async function findLifetimeDashboardArtifactFiles(root, input) {
     await walk(root, 0);
     return out;
 }
-function combineLifetimeDashboardSnapshots(options, discoveredSources, snapshots, reviewDecisions) {
-    const jobs = applyCoordinatorReviewDecisions(snapshots.flatMap(({ source, snapshot }) => {
-        return recordArray(snapshot.jobs).map((job) => ({
-            ...job,
-            id: lifetimeScopedId(source, textValue(job.id ?? job.jobId ?? job.taskId, 'job')),
-            originalJobId: textValue(job.id ?? job.jobId ?? job.taskId, 'job'),
-            sourceRun: source.run,
-            sourceCollection: source.collection,
-            sourceContinuation: source.continuation,
-            sourceLabel: source.label,
-            generatedAt: numberValue(job.generatedAt) || numberValue(snapshot.generatedAt) || source.mtimeMs
-        }));
-    }), reviewDecisions).slice(0, LIFETIME_DASHBOARD_MAX_JOBS);
-    const humanActionAnswers = recordArray(awaitNoop([]));
-    const summary = lifetimeDashboardSummary(jobs);
-    const latestGeneratedAt = Math.max(Date.now(), ...snapshots.map((entry) => numberValue(entry.snapshot.generatedAt)), ...discoveredSources.map((source) => source.mtimeMs));
-    const events = snapshots.flatMap(({ source, snapshot }) => recordArray(snapshot.events).map((event) => ({
+async function combineLifetimeDashboardSnapshots(options, discoveredSources, snapshots, reviewDecisions, queueBacklog) {
+    const drainedRunRoots = new Set(snapshots
+        .filter((entry) => entry.source.kind === 'run' && isDrainedAutonomousRunSnapshot(entry.snapshot))
+        .map((entry) => lifetimeRunRootKey(entry.source)));
+    const visibleSnapshots = snapshots.filter((entry) => {
+        if (entry.source.kind !== 'collection')
+            return true;
+        return !drainedRunRoots.has(lifetimeRunRootKey(entry.source));
+    });
+    const autoDrainDelays = lifetimeAutoDrainDelayRecords(visibleSnapshots);
+    const jobs = dedupeLifetimeDashboardJobs(collapseSupersededLifetimeReviewJobs(applyCoordinatorReviewDecisions(visibleSnapshots.flatMap(({ source, snapshot }) => {
+        const autoDrainDelay = lifetimeAutoDrainDelayRecord(source, snapshot);
+        return recordArray(snapshot.jobs).map((job) => {
+            const sourceJobId = textValue(job.id ?? job.jobId ?? job.taskId, 'job');
+            return withRecomputedCostFields({
+                ...job,
+                id: lifetimeScopedId(source, sourceJobId),
+                sourceJobId,
+                originalJobId: unscopedLifetimeTaskKey(sourceJobId),
+                sourceRun: source.run,
+                sourceCollection: source.collection,
+                sourceContinuation: source.continuation,
+                sourceLabel: source.label,
+                ...(autoDrainDelay ? {
+                    coordinationDelay: autoDrainDelay.reason,
+                    autoDrainSkippedReason: autoDrainDelay.skippedReason,
+                    autoDrainDirtyPathCount: autoDrainDelay.dirtyPathCount
+                } : {}),
+                generatedAt: numberValue(job.generatedAt) || numberValue(snapshot.generatedAt) || source.mtimeMs
+            });
+        });
+    }), reviewDecisions))).slice(0, LIFETIME_DASHBOARD_MAX_JOBS);
+    const humanActionAnswers = await readHumanActionAnswers(options);
+    const summary = {
+        ...lifetimeDashboardSummary(jobs),
+        coordinationDelayCount: autoDrainDelays.length,
+        dirtyAutoDrainSkipCount: autoDrainDelays.filter((record) => record.skippedReason === 'dirty-worktree').length
+    };
+    const queueOverlay = lifetimeQueueBacklogOverlay(queueBacklog, jobs);
+    const latestGeneratedAt = Math.max(Date.now(), numberValue(queueBacklog.generatedAt), ...visibleSnapshots.map((entry) => numberValue(entry.snapshot.generatedAt)), ...discoveredSources.map((source) => source.mtimeMs));
+    const events = visibleSnapshots.flatMap(({ source, snapshot }) => recordArray(snapshot.events).map((event) => ({
         ...event,
         sourceLabel: source.label,
         message: textValue(event.message, textValue(event.type, 'event')),
@@ -456,14 +868,19 @@ function combineLifetimeDashboardSnapshots(options, discoveredSources, snapshots
     return {
         kind: 'frontier.loom-ui.lifetime-dashboard',
         version: 1,
-        ok: snapshots.some(({ snapshot }) => Boolean(snapshot.ok)),
+        ok: true,
         generatedAt: latestGeneratedAt,
         cwd: options.cwd,
         sources: {
             workspace: options.cwd,
             lifetimeRoot: path.join(options.cwd, 'agent-runs'),
+            queueRoot: path.join(options.cwd, '.loom', 'queues'),
             sourceCount: discoveredSources.length,
-            loadedSourceCount: snapshots.length,
+            loadedSourceCount: visibleSnapshots.length,
+            suppressedCollectionSourceCount: snapshots.length - visibleSnapshots.length,
+            queueSourceCount: queueBacklog.sourceCount,
+            coordinationDelayCount: autoDrainDelays.length,
+            ...(humanActionAnswers.length ? { humanActionAnswers: await humanActionAnswerLogPath(options) } : {}),
             ...(reviewDecisions.length ? { coordinatorReviewDecisions: coordinatorReviewDecisionPath(options.cwd) } : {})
         },
         summary,
@@ -472,22 +889,32 @@ function combineLifetimeDashboardSnapshots(options, discoveredSources, snapshots
         quality: {},
         timeSeries: lifetimeTimeSeries(jobs, events),
         lanes: lifetimeLaneRows(jobs),
+        capacity: lifetimeCapacitySummary(queueBacklog, jobs, queueOverlay.entries),
         jobs,
-        humanActions: snapshots.flatMap(({ snapshot }) => recordArray(snapshot.humanActions)).slice(-100),
+        humanActions: visibleSnapshots.flatMap(({ snapshot }) => recordArray(snapshot.humanActions)).slice(-100),
         humanActionAnswers,
         events,
-        routing: lifetimeRoutingSummary(snapshots.map((entry) => entry.snapshot)),
+        routing: await lifetimeRoutingSummary(options.cwd, visibleSnapshots),
         backlog: {
             id: 'workspace-lifetime',
-            entryCount: snapshots.reduce((sum, entry) => sum + numberValue(recordValue(entry.snapshot.backlog).entryCount), 0),
-            readyCount: snapshots.reduce((sum, entry) => sum + numberValue(recordValue(entry.snapshot.backlog).readyCount), 0)
+            entryCount: queueOverlay.totalCount,
+            readyCount: queueOverlay.readyCount,
+            activeCount: queueOverlay.activeCount,
+            doneCount: queueOverlay.doneCount,
+            failedCount: queueOverlay.failedCount,
+            representedCount: queueOverlay.representedCount,
+            entries: queueOverlay.entries
         },
         raw: {
             lifetime: {
                 mode: 'workspace',
                 sourceCount: discoveredSources.length,
-                loadedSourceCount: snapshots.length,
-                sources: discoveredSources.slice(0, LIFETIME_DASHBOARD_MAX_SOURCES)
+                loadedSourceCount: visibleSnapshots.length,
+                suppressedCollectionSourceCount: snapshots.length - visibleSnapshots.length,
+                autoDrainDelays,
+                sources: discoveredSources.slice(0, LIFETIME_DASHBOARD_MAX_SOURCES),
+                manifests: queueBacklog.manifests,
+                queueSources: queueBacklog.paths
             }
         }
     };
@@ -495,6 +922,723 @@ function combineLifetimeDashboardSnapshots(options, discoveredSources, snapshots
 function lifetimeScopedId(source, id) {
     return `${source.id}:${id}`.replaceAll(/[^\w:.-]+/g, '-');
 }
+function lifetimeAutoDrainDelayRecords(entries) {
+    return entries
+        .map(({ source, snapshot }) => lifetimeAutoDrainDelayRecord(source, snapshot))
+        .filter((record) => Boolean(record));
+}
+function lifetimeAutoDrainDelayRecord(source, snapshot) {
+    const rawRun = recordValue(recordValue(snapshot.raw).run);
+    const autoDrain = recordValue(rawRun.autoDrain);
+    const skippedReason = textValue(autoDrain.skippedReason, '');
+    if (skippedReason !== 'dirty-worktree')
+        return undefined;
+    const summary = recordValue(autoDrain.summary);
+    const dirtyPaths = stringArray(autoDrain.dirtyPaths);
+    return {
+        source: source.path,
+        sourceLabel: source.label,
+        reason: 'apply-delayed-by-dirty-worktree',
+        skippedReason,
+        dirtyPathCount: dirtyPaths.length,
+        dirtyPaths: dirtyPaths.slice(0, 12),
+        remainingReadyCount: numberValue(summary.remainingReadyCount),
+        generatedAt: numberValue(autoDrain.generatedAt) || numberValue(snapshot.generatedAt) || source.mtimeMs
+    };
+}
+async function enrichLifetimeRunSnapshotEvidence(cwd, source, snapshot) {
+    if (source.kind !== 'run' || !source.run)
+        return snapshot;
+    const runRoot = safeCwdRelativeDirectory(cwd, source.run);
+    if (!runRoot)
+        return snapshot;
+    const jobs = recordArray(snapshot.jobs);
+    if (!jobs.length)
+        return snapshot;
+    const enrichedJobs = await Promise.all(jobs.map((job) => enrichLifetimeRunJobEvidence(cwd, runRoot, job)));
+    return {
+        ...snapshot,
+        jobs: enrichedJobs
+    };
+}
+async function enrichLifetimeRunJobEvidence(cwd, runRoot, job) {
+    const jobDir = await findBestRawRunJobDir(runRoot, rawRunJobIdCandidates(job));
+    if (!jobDir)
+        return job;
+    const evidenceDir = path.join(jobDir, 'evidence');
+    const eventsPath = path.join(jobDir, 'codex-events.jsonl');
+    const rootMerge = recordValue(await readJsonFile(path.join(jobDir, 'merge.json')));
+    const evidenceMerge = recordValue(await readJsonFile(path.join(evidenceDir, 'merge.json')));
+    const evidenceRecord = recordValue(await readJsonFile(path.join(evidenceDir, 'evidence.json')));
+    const merge = Object.keys(rootMerge).length ? rootMerge : evidenceMerge;
+    const rawPatchPath = await firstExistingRelativePath(cwd, rawRunPatchCandidates(jobDir));
+    const usage = await readCodexEventUsageSummary(eventsPath);
+    const evidencePaths = await existingRelativePaths(cwd, [
+        path.join(jobDir, 'last-message.md'),
+        eventsPath,
+        path.join(jobDir, 'merge.json'),
+        path.join(evidenceDir, 'last-message.md'),
+        path.join(evidenceDir, 'handoff.md'),
+        path.join(evidenceDir, 'evidence.json'),
+        path.join(evidenceDir, 'merge.json'),
+        path.join(evidenceDir, 'human-question.json'),
+        path.join(evidenceDir, 'resource-allocation.json'),
+        path.join(evidenceDir, 'model-availability.json'),
+        ...rawRunPatchCandidates(jobDir)
+    ]);
+    if (!evidencePaths.length && !rawPatchPath && !Object.keys(merge).length)
+        return job;
+    const patchChangedPaths = await readPatchChangedPathList(cwd, rawPatchPath);
+    const changedPaths = uniquePaths([
+        ...stringArray(job.changedPaths),
+        ...stringArray(merge.changedPaths),
+        ...patchChangedPaths
+    ]);
+    const ownershipViolations = uniquePaths([
+        ...stringArray(job.ownershipViolations),
+        ...stringArray(merge.ownershipViolations)
+    ]);
+    const status = lifetimeRunEvidenceStatus(job, merge, evidencePaths);
+    const bucket = lifetimeRunEvidenceBucket(job, status, evidencePaths, rawPatchPath);
+    const collectReasonClasses = uniquePaths([
+        ...stringArray(job.collectReasonClasses),
+        status === 'failed' && evidencePaths.length ? 'worker failed with evidence' : 'raw run evidence discovered'
+    ]);
+    const mergedEvidencePaths = uniquePaths([...stringArray(job.evidencePaths), ...evidencePaths]);
+    const commandEvidence = commandEvidenceFromRecords(job, merge, evidenceRecord);
+    return withRecomputedCostFields({
+        ...job,
+        status,
+        bucket,
+        disposition: textValue(merge.disposition, textValue(job.disposition, status)),
+        mergeReadiness: textValue(merge.mergeReadiness, textValue(job.mergeReadiness, status)),
+        ...(rawPatchPath ? { patchPath: rawPatchPath, artifactPaths: uniquePaths([rawPatchPath, ...stringArray(job.artifactPaths)]) } : {}),
+        changedPaths,
+        changedPathCount: changedPaths.length || numberValue(job.changedPathCount),
+        ownershipViolations,
+        ownershipViolationCount: ownershipViolations.length || numberValue(job.ownershipViolationCount),
+        ...(usage.inputTokens ? { actualInputTokens: usage.inputTokens, inputTokens: usage.inputTokens } : {}),
+        ...(!usage.inputTokens && usage.estimatedInputTokens ? { estimatedInputTokens: usage.estimatedInputTokens } : {}),
+        ...(usage.cachedInputTokens ? { cachedInputTokens: usage.cachedInputTokens } : {}),
+        ...(usage.uncachedInputTokens ? { uncachedInputTokens: usage.uncachedInputTokens } : {}),
+        ...(usage.outputTokens ? { actualOutputTokens: usage.outputTokens, outputTokens: usage.outputTokens } : {}),
+        ...(usage.reasoningOutputTokens ? { reasoningOutputTokens: usage.reasoningOutputTokens } : {}),
+        ...(usage.eventCount || usage.estimatedInputTokens ? {
+            usage: {
+                ...recordValue(job.usage),
+                input_tokens: usage.inputTokens,
+                cached_input_tokens: usage.cachedInputTokens,
+                uncached_input_tokens: usage.uncachedInputTokens,
+                output_tokens: usage.outputTokens,
+                reasoning_output_tokens: usage.reasoningOutputTokens,
+                estimated_input_tokens: usage.estimatedInputTokens,
+                estimated_from_event_bytes: usage.estimatedFromEventBytes,
+                source: usage.eventCount ? 'codex-events.jsonl' : 'codex-events.jsonl-estimate',
+                event_count: usage.eventCount
+            }
+        } : {}),
+        evidencePaths: mergedEvidencePaths,
+        evidencePathCount: mergedEvidencePaths.length,
+        reasons: stringArray(job.reasons).length ? stringArray(job.reasons) : stringArray(merge.reasons),
+        commandsPassed: commandEvidence.passed,
+        commandsFailed: commandEvidence.failed,
+        collectReasonClasses,
+        runEvidenceRecovered: true
+    });
+}
+function rawRunJobIdCandidates(job) {
+    const values = [
+        textValue(job.originalJobId, ''),
+        textValue(job.jobId, ''),
+        textValue(job.id, ''),
+        textValue(job.taskId, '')
+    ].filter(Boolean);
+    const out = new Set();
+    for (const value of values) {
+        out.add(value);
+        const parts = value.split(':').filter(Boolean);
+        if (parts.length)
+            out.add(parts[parts.length - 1]);
+    }
+    return Array.from(out);
+}
+async function findBestRawRunJobDir(runRoot, candidates) {
+    const matches = new Map();
+    for (const candidate of candidates) {
+        const direct = path.join(runRoot, candidate);
+        if (await rawRunJobHasArtifacts(direct))
+            matches.set(direct, await rawRunJobEvidenceScore(direct));
+        for (const match of await findRawRunJobDirs(runRoot, candidate, 0)) {
+            matches.set(match, await rawRunJobEvidenceScore(match));
+        }
+    }
+    return Array.from(matches.entries()).sort((left, right) => right[1] - left[1] || right[0].localeCompare(left[0]))[0]?.[0];
+}
+async function rawRunJobEvidenceScore(jobDir) {
+    let score = 0;
+    for (const [relative, weight] of [
+        ['last-message.md', 100],
+        ['evidence/merge.json', 80],
+        ['merge.json', 80],
+        ['evidence/evidence.json', 50],
+        ['evidence/changes.patch', 40],
+        ['changes.patch', 40],
+        ['codex-events.jsonl', 20]
+    ]) {
+        const stat = await fs.stat(path.join(jobDir, relative)).catch(() => undefined);
+        if (stat?.isFile())
+            score += weight + Math.min(10, Math.floor(stat.size / 1024));
+    }
+    const stat = await fs.stat(jobDir).catch(() => undefined);
+    return score + Math.floor((stat?.mtimeMs ?? 0) / 1_000_000_000);
+}
+function lifetimeRunEvidenceStatus(job, merge, evidencePaths) {
+    const mergeStatus = textValue(coordinatorFacingMachineLabel(merge.status), '');
+    if (mergeStatus)
+        return mergeStatus;
+    const status = textValue(coordinatorFacingMachineLabel(job.status), '');
+    if (status)
+        return status === 'failed' && evidencePaths.some((entry) => entry.endsWith('last-message.md')) ? 'completed' : status;
+    return evidencePaths.some((entry) => entry.endsWith('last-message.md')) ? 'completed' : 'failed';
+}
+function lifetimeRunEvidenceBucket(job, status, evidencePaths, patchPath) {
+    const bucket = textValue(coordinatorFacingMachineLabel(job.bucket), '');
+    if (status === 'running')
+        return 'running';
+    if (status === 'completed')
+        return bucket && bucket !== 'failed-evidence' ? bucket : 'completed';
+    if (status === 'failed' && (evidencePaths.length || patchPath))
+        return 'worker-failed';
+    return bucket || (status === 'failed' ? 'failed-evidence' : status);
+}
+async function readLatestDrainCoordinatorSnapshot(cwd) {
+    const root = path.join(cwd, 'agent-runs', 'frontier-swarm-codex');
+    const drains = await findDrainCoordinatorRunDirs(root);
+    const activeDrainRoot = drains[0] ? drainRootForRunDir(drains[0]) : '';
+    const runDirs = drains
+        .filter((runDir) => drainRootForRunDir(runDir) === activeDrainRoot)
+        .slice(0, LIFETIME_DASHBOARD_MAX_DRAIN_RUNS);
+    const jobs = [];
+    for (const runDir of runDirs)
+        jobs.push(...await readDrainCoordinatorJobs(cwd, runDir));
+    if (!jobs.length)
+        return undefined;
+    const generatedAt = Math.max(...jobs.map((job) => numberValue(job.generatedAt)), Date.now());
+    return {
+        ok: true,
+        generatedAt,
+        cwd,
+        sources: {
+            activeDrain: runDirs[0],
+            activeDrainSources: runDirs
+        },
+        summary: lifetimeDashboardSummary(jobs),
+        lanes: lifetimeLaneRows(jobs),
+        jobs,
+        events: activeRunEvents(jobs),
+        raw: {
+            activeDrain: {
+                runDirs,
+                jobCount: jobs.length,
+                runningCount: jobs.filter((job) => textValue(job.status, '') === 'running').length
+            }
+        }
+    };
+}
+async function findDrainCoordinatorRunDirs(root) {
+    const out = [];
+    const rootEntries = await fs.readdir(root, { withFileTypes: true }).catch(() => []);
+    for (const drain of rootEntries) {
+        if (!drain.isDirectory() || !drain.name.startsWith('drain-'))
+            continue;
+        const drainDir = path.join(root, drain.name);
+        const iterationEntries = await fs.readdir(drainDir, { withFileTypes: true }).catch(() => []);
+        for (const iteration of iterationEntries) {
+            if (!iteration.isDirectory() || !iteration.name.startsWith('iteration-'))
+                continue;
+            for (const runDirName of ['coordinator-run', 'worker-run']) {
+                const runDir = path.join(drainDir, iteration.name, runDirName);
+                const stat = await fs.stat(runDir).catch(() => undefined);
+                if (stat?.isDirectory())
+                    out.push({ dir: runDir, mtimeMs: stat.mtimeMs });
+            }
+        }
+    }
+    return out.sort((left, right) => right.mtimeMs - left.mtimeMs || right.dir.localeCompare(left.dir)).map((entry) => entry.dir);
+}
+function drainRootForRunDir(runDir) {
+    return path.dirname(path.dirname(runDir));
+}
+async function readDrainCoordinatorJobs(cwd, coordinatorRunDir) {
+    const entries = await fs.readdir(coordinatorRunDir, { withFileTypes: true }).catch(() => []);
+    const liveLines = liveProcessLinesForPath(coordinatorRunDir);
+    const now = Date.now();
+    const jobs = [];
+    const seenJobIds = new Set();
+    for (const entry of entries) {
+        if (!entry.isDirectory() || entry.name === 'streams')
+            continue;
+        seenJobIds.add(entry.name);
+        jobs.push(await readDrainCoordinatorJob(cwd, coordinatorRunDir, path.join(coordinatorRunDir, entry.name), liveLines, now));
+    }
+    const pidEntries = await readRunPidEntries(coordinatorRunDir);
+    const planJobs = await readRunPlanJobs(coordinatorRunDir);
+    for (const entry of pidEntries) {
+        const jobId = textValue(entry.jobId, '');
+        if (!jobId || seenJobIds.has(jobId))
+            continue;
+        jobs.push(readDrainPidManifestJob(cwd, coordinatorRunDir, entry, planJobs.get(jobId), now));
+    }
+    return jobs.sort((left, right) => textValue(left.lane, '').localeCompare(textValue(right.lane, '')));
+}
+async function readRunPidEntries(runDir) {
+    const pidManifest = recordValue(await readJsonFile(path.join(runDir, 'pids.json')));
+    return recordArray(pidManifest.entries).filter((entry) => textValue(entry.role, '') === 'codex');
+}
+async function readRunPlanJobs(runDir) {
+    const plan = recordValue(await readJsonFile(path.join(runDir, 'swarm-plan.json')));
+    const entries = [];
+    for (const job of recordArray(plan.jobs)) {
+        const id = textValue(job.id, '');
+        if (id)
+            entries.push([id, job]);
+    }
+    return new Map(entries);
+}
+function readDrainPidManifestJob(cwd, coordinatorRunDir, entry, planJob, now) {
+    const jobId = textValue(entry.jobId, 'job');
+    const runKind = path.basename(coordinatorRunDir) === 'worker-run' ? 'worker' : 'coordinator';
+    const task = recordValue(planJob?.task);
+    const compute = recordValue(planJob?.compute);
+    const command = stringArray(entry.command);
+    const live = isProcessLive(numberValue(entry.pid), entry);
+    const status = live ? 'running' : 'failed';
+    const startedAt = numberValue(entry.startedAt);
+    const lane = textValue(planJob?.lane ?? task.lane, drainCoordinatorLane(jobId, runKind));
+    return withRecomputedCostFields({
+        id: jobId,
+        originalJobId: jobId,
+        taskId: textValue(planJob?.taskId ?? task.id, jobId),
+        title: textValue(planJob?.title ?? task.title, runKind === 'coordinator' ? `Coordinate lane review for ${lane}` : `Continue ${lane} work`),
+        lane,
+        status,
+        bucket: status === 'running' ? 'running' : 'failed-evidence',
+        disposition: status === 'running' ? 'active' : 'failed',
+        agentId: jobId,
+        workerId: jobId,
+        model: textValue(compute.model, commandOptionValue(command, '--model') || 'gpt-5.5'),
+        computeId: textValue(compute.id, runKind === 'coordinator' ? 'coordinator-agent' : 'continuation-worker'),
+        reasoningEffort: textValue(compute.reasoningEffort, ''),
+        startedAt: startedAt || undefined,
+        durationMs: startedAt ? Math.max(0, now - startedAt) : 0,
+        evidencePaths: [],
+        evidencePathCount: 0,
+        changedPathCount: 0,
+        collectReasonClasses: status === 'running' ? [`active drain ${runKind}`] : [`missing ${runKind} output`],
+        mergeReadiness: status,
+        sourceRun: path.relative(cwd, coordinatorRunDir),
+        sourceLabel: path.relative(cwd, coordinatorRunDir),
+        generatedAt: now
+    });
+}
+function commandOptionValue(command, option) {
+    const index = command.indexOf(option);
+    return index >= 0 ? textValue(command[index + 1], '') : '';
+}
+async function readDrainCoordinatorJob(cwd, coordinatorRunDir, jobDir, liveLines, now) {
+    const jobId = path.basename(jobDir);
+    const runKind = path.basename(coordinatorRunDir) === 'worker-run' ? 'worker' : 'coordinator';
+    const evidenceDir = path.join(jobDir, 'evidence');
+    const eventsPath = path.join(jobDir, 'codex-events.jsonl');
+    const lastMessagePath = path.join(jobDir, 'last-message.md');
+    const decisionsJson = path.join(evidenceDir, 'coordinator-decisions.json');
+    const decisionsJsonl = path.join(evidenceDir, 'coordinator-decisions.jsonl');
+    const modelAvailability = recordValue(await readJsonFile(path.join(evidenceDir, 'model-availability.json')));
+    const evidenceRecord = recordValue(await readJsonFile(path.join(evidenceDir, 'evidence.json')));
+    const eventStat = await fs.stat(eventsPath).catch(() => undefined);
+    const lastMessageStat = await fs.stat(lastMessagePath).catch(() => undefined);
+    const decisionJsonStat = await fs.stat(decisionsJson).catch(() => undefined);
+    const decisionJsonlStat = await fs.stat(decisionsJsonl).catch(() => undefined);
+    const live = liveLines.some((line) => line.includes(jobDir) || line.includes(jobId));
+    const hasDecision = Boolean(decisionJsonStat?.isFile() || decisionJsonlStat?.isFile());
+    const failed = !live && !lastMessageStat && !hasDecision && await codexEventsHaveFailure(eventsPath);
+    const status = live && !lastMessageStat
+        ? 'running'
+        : lastMessageStat || hasDecision
+            ? 'completed'
+            : 'failed';
+    const startedAt = numberValue(eventStat?.birthtimeMs ?? eventStat?.ctimeMs ?? eventStat?.mtimeMs);
+    const finishedAt = status === 'running'
+        ? undefined
+        : Math.max(numberValue(lastMessageStat?.mtimeMs), numberValue(decisionJsonStat?.mtimeMs), numberValue(decisionJsonlStat?.mtimeMs), numberValue(eventStat?.mtimeMs));
+    const usage = await readCodexEventUsageSummary(eventsPath);
+    const lane = drainCoordinatorLane(jobId, runKind);
+    const evidencePaths = await existingRelativePaths(cwd, [
+        eventsPath,
+        lastMessagePath,
+        decisionsJson,
+        decisionsJsonl,
+        path.join(evidenceDir, 'merge.json'),
+        path.join(evidenceDir, 'evidence.json'),
+        path.join(evidenceDir, 'human-question.json'),
+        path.join(evidenceDir, 'resource-allocation.json'),
+        path.join(evidenceDir, 'model-availability.json')
+    ]);
+    const commandEvidence = commandEvidenceFromRecords(evidenceRecord);
+    return withRecomputedCostFields({
+        id: jobId,
+        originalJobId: jobId,
+        taskId: jobId,
+        title: runKind === 'coordinator' ? `Coordinate lane review for ${lane}` : `Continue ${lane} work`,
+        lane,
+        status,
+        bucket: status === 'running' ? 'running' : status === 'completed' ? 'completed' : 'failed-evidence',
+        disposition: status === 'running' ? 'active' : status,
+        agentId: jobId,
+        workerId: jobId,
+        model: textValue(modelAvailability.effectiveModel ?? modelAvailability.requestedModel, 'gpt-5.5'),
+        computeId: runKind === 'coordinator' ? 'coordinator-agent' : 'continuation-worker',
+        startedAt: startedAt || undefined,
+        ...(finishedAt ? { finishedAt } : {}),
+        durationMs: startedAt ? Math.max(0, (finishedAt ?? now) - startedAt) : 0,
+        ...(usage.inputTokens ? { actualInputTokens: usage.inputTokens, inputTokens: usage.inputTokens } : {}),
+        ...(!usage.inputTokens && usage.estimatedInputTokens ? { estimatedInputTokens: usage.estimatedInputTokens } : {}),
+        ...(usage.cachedInputTokens ? { cachedInputTokens: usage.cachedInputTokens } : {}),
+        ...(usage.uncachedInputTokens ? { uncachedInputTokens: usage.uncachedInputTokens } : {}),
+        ...(usage.outputTokens ? { actualOutputTokens: usage.outputTokens, outputTokens: usage.outputTokens } : {}),
+        ...(usage.reasoningOutputTokens ? { reasoningOutputTokens: usage.reasoningOutputTokens } : {}),
+        ...(usage.eventCount ? { usage: { ...usage, source: 'codex-events.jsonl' } } : {}),
+        evidencePaths,
+        evidencePathCount: evidencePaths.length,
+        commandsPassed: commandEvidence.passed,
+        commandsFailed: commandEvidence.failed,
+        changedPathCount: 0,
+        collectReasonClasses: status === 'running' ? [`active drain ${runKind}`] : [`drain ${runKind}`],
+        mergeReadiness: status,
+        sourceRun: path.relative(cwd, coordinatorRunDir),
+        sourceLabel: path.relative(cwd, coordinatorRunDir),
+        generatedAt: numberValue(finishedAt) || numberValue(eventStat?.mtimeMs) || now
+    });
+}
+function liveProcessLinesForPath(needle) {
+    const result = spawnSync('pgrep', ['-fl', needle], { encoding: 'utf8' });
+    if (result.status !== 0 && !result.stdout)
+        return [];
+    return result.stdout.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+}
+async function existingRelativePaths(cwd, files) {
+    const out = [];
+    for (const file of files) {
+        const stat = await fs.stat(file).catch(() => undefined);
+        if (stat?.isFile())
+            out.push(path.relative(cwd, file));
+    }
+    return out;
+}
+async function firstExistingRelativePath(cwd, files) {
+    for (const file of files) {
+        const stat = await fs.stat(file).catch(() => undefined);
+        if (stat?.isFile())
+            return path.relative(cwd, file);
+    }
+    return undefined;
+}
+function rawRunPatchCandidates(jobDir) {
+    return [
+        path.join(jobDir, 'changes.patch'),
+        path.join(jobDir, 'source.patch'),
+        path.join(jobDir, 'evidence', 'changes.patch'),
+        path.join(jobDir, 'evidence', 'source.patch')
+    ];
+}
+async function readPatchChangedPathList(cwd, patchPath) {
+    if (!patchPath)
+        return [];
+    const absolute = path.resolve(cwd, patchPath);
+    if (!isPathInside(cwd, absolute))
+        return [];
+    const stat = await fs.stat(absolute).catch(() => undefined);
+    if (!stat?.isFile() || stat.size > TASK_DETAIL_PATCH_MAX_BYTES)
+        return [];
+    const patch = await fs.readFile(absolute, 'utf8');
+    return uniquePaths(parseUnifiedPatchFiles(patch).map((file) => file.path).filter(Boolean));
+}
+async function codexEventsHaveFailure(file) {
+    const text = await fs.readFile(file, 'utf8').catch(() => '');
+    return /"type":"(?:error|turn\.failed)"/.test(text);
+}
+async function codexEventsHaveQuotaLimit(file) {
+    const text = await fs.readFile(file, 'utf8').catch(() => '');
+    return /usage limit|quota|purchase more credits/i.test(text);
+}
+function drainCoordinatorLane(jobId, runKind = 'coordinator') {
+    if (runKind === 'worker') {
+        for (const marker of [
+            '-continuation-rerun-',
+            '-continuation-supersede-',
+            '-continuation-reject-',
+            '-continuation-',
+            '-queue-candidate-package-'
+        ]) {
+            const index = jobId.indexOf(marker);
+            if (index > 0)
+                return jobId.slice(0, index);
+        }
+    }
+    const marker = '-coordinator-agent-';
+    const index = jobId.indexOf(marker);
+    return index > 0 ? jobId.slice(0, index) : jobId;
+}
+function mergeLifetimeDrainCoordinatorSnapshot(lifetime, drain) {
+    const drainJobs = recordArray(drain?.jobs);
+    if (!drainJobs.length)
+        return lifetime;
+    const existingJobs = recordArray(lifetime.jobs).filter((job) => {
+        const source = textValue(job.sourceRun ?? job.sourceLabel, '');
+        return !/agent-runs\/frontier-swarm-codex\/drain-.*\/(?:coordinator-run|worker-run)/.test(source);
+    });
+    const jobs = [...drainJobs, ...existingJobs].slice(0, LIFETIME_DASHBOARD_MAX_JOBS);
+    const events = [...recordArray(lifetime.events), ...recordArray(drain?.events)]
+        .sort((left, right) => numberValue(left.at) - numberValue(right.at))
+        .slice(-160);
+    return {
+        ...lifetime,
+        generatedAt: Math.max(numberValue(lifetime.generatedAt), numberValue(drain?.generatedAt), Date.now()),
+        sources: {
+            ...recordValue(lifetime.sources),
+            ...recordValue(drain?.sources)
+        },
+        summary: lifetimeDashboardSummary(jobs),
+        health: lifetimeHealthSummary(jobs),
+        lanes: lifetimeLaneRows(jobs),
+        jobs,
+        events,
+        raw: {
+            ...recordValue(lifetime.raw),
+            activeDrain: recordValue(recordValue(drain?.raw).activeDrain)
+        }
+    };
+}
+function mergeLifetimeActiveRunSnapshot(lifetime, active) {
+    const activeJobs = recordArray(active?.jobs).filter((job) => textValue(job.status, '') === 'running');
+    if (!activeJobs.length)
+        return lifetime;
+    const activeKeys = new Set(activeJobs.map(lifetimeJobDedupeKey).filter(Boolean));
+    const existingJobs = recordArray(lifetime.jobs).filter((job) => !activeKeys.has(lifetimeJobDedupeKey(job)));
+    const jobs = [...activeJobs, ...existingJobs].slice(0, LIFETIME_DASHBOARD_MAX_JOBS);
+    const activeAgents = activeAgentsFromJobs(jobs);
+    const events = [...recordArray(lifetime.events), ...recordArray(active?.events)]
+        .sort((left, right) => numberValue(left.at) - numberValue(right.at))
+        .slice(-160);
+    return {
+        ...lifetime,
+        generatedAt: Math.max(numberValue(lifetime.generatedAt), numberValue(active?.generatedAt), Date.now()),
+        sources: {
+            ...recordValue(lifetime.sources),
+            ...recordValue(active?.sources)
+        },
+        summary: lifetimeDashboardSummary(jobs),
+        health: lifetimeHealthSummary(jobs),
+        lanes: lifetimeLaneRows(jobs),
+        capacity: lifetimeCapacitySummary({
+            entries: recordArray(recordValue(lifetime.backlog).entries),
+            manifests: recordArray(recordValue(recordValue(lifetime.raw).lifetime).manifests),
+            sourceCount: numberValue(recordValue(lifetime.backlog).entryCount),
+            paths: stringArray(recordValue(recordValue(lifetime.raw).lifetime).queueSources),
+            generatedAt: numberValue(lifetime.generatedAt)
+        }, jobs, recordArray(recordValue(lifetime.backlog).entries)),
+        jobs,
+        activeAgents,
+        events,
+        raw: {
+            ...recordValue(lifetime.raw),
+            activeRuns: recordValue(recordValue(active?.raw).activeRuns)
+        }
+    };
+}
+async function readLifetimeActiveRunSnapshot(options) {
+    const jobs = await readLiveCodexProcessJobs(options.cwd);
+    const sources = uniquePaths(jobs.map((job) => textValue(job.sourceRun, '')).filter(Boolean));
+    if (!jobs.length)
+        return undefined;
+    const generatedAt = Date.now();
+    return {
+        ok: true,
+        generatedAt,
+        cwd: options.cwd,
+        sources: {
+            activeRuns: sources,
+            activeRunCount: sources.length
+        },
+        summary: lifetimeDashboardSummary(jobs),
+        lanes: lifetimeLaneRows(jobs),
+        jobs,
+        activeAgents: activeAgentsFromJobs(jobs),
+        events: activeRunEvents(jobs),
+        raw: {
+            activeRuns: {
+                runDirs: sources,
+                jobCount: jobs.length,
+                runningCount: jobs.length
+            }
+        }
+    };
+}
+async function readLiveCodexProcessJobs(cwd) {
+    if (process.platform === 'win32')
+        return [];
+    const result = spawnSync('ps', ['-axo', 'pid,ppid,etime,command'], {
+        encoding: 'utf8',
+        stdio: ['ignore', 'pipe', 'ignore']
+    });
+    if (result.status !== 0 && !result.stdout)
+        return [];
+    const agentWorktreeRoot = `${path.join(cwd, 'agent-worktrees')}/`;
+    const now = Date.now();
+    const byWorker = new Map();
+    for (const line of result.stdout.split(/\r?\n/)) {
+        if (!line.includes('codex ') || !line.includes(' exec ') || !line.includes(agentWorktreeRoot))
+            continue;
+        const fields = /^\s*(\d+)\s+(\d+)\s+(\S+)\s+(.+)$/.exec(line);
+        if (!fields)
+            continue;
+        const command = fields[4];
+        const cd = commandOptionValue(splitCommandWords(command), '--cd') || regexCommandOption(command, '--cd');
+        if (!cd.startsWith(agentWorktreeRoot))
+            continue;
+        const outputLastMessage = commandOptionValue(splitCommandWords(command), '--output-last-message') || regexCommandOption(command, '--output-last-message');
+        const model = commandOptionValue(splitCommandWords(command), '--model') || regexCommandOption(command, '--model') || '';
+        const runDir = outputLastMessage ? path.dirname(path.dirname(outputLastMessage)) : '';
+        const jobId = outputLastMessage ? path.basename(path.dirname(outputLastMessage)) : path.basename(cd);
+        const key = outputLastMessage || cd;
+        const pid = Number(fields[1]);
+        const current = byWorker.get(key);
+        if (!current || pid < current.pid)
+            byWorker.set(key, { pid, etime: fields[3], cd, model, outputLastMessage, runDir, jobId });
+    }
+    const planCache = new Map();
+    const jobs = [];
+    for (const worker of byWorker.values()) {
+        const relativeRun = worker.runDir && isPathInside(cwd, worker.runDir) ? path.relative(cwd, worker.runDir) : '';
+        const planJobs = worker.runDir
+            ? await (planCache.get(worker.runDir) ?? planCache.set(worker.runDir, readRunPlanJobs(worker.runDir)).get(worker.runDir))
+            : new Map();
+        const planJob = planJobs.get(worker.jobId);
+        const task = recordValue(planJob?.task);
+        const compute = recordValue(planJob?.compute);
+        const startedAt = now - parsePsElapsedMs(worker.etime);
+        const title = textValue(planJob?.title ?? task.title, humanizeWorkerJobId(worker.jobId));
+        const lane = textValue(planJob?.lane ?? task.lane, inferLaneFromWorkerJobId(worker.jobId));
+        jobs.push({
+            id: relativeRun ? `run:${relativeRun.replaceAll(/[^\w:.-]+/g, '-')}:${worker.jobId}` : worker.jobId,
+            originalJobId: worker.jobId,
+            taskId: textValue(planJob?.taskId ?? task.id, worker.jobId),
+            title,
+            lane,
+            status: 'running',
+            bucket: 'running',
+            disposition: 'active',
+            agentId: worker.jobId,
+            workerId: worker.jobId,
+            model: textValue(compute.model, worker.model),
+            computeId: textValue(compute.id, ''),
+            reasoningEffort: textValue(compute.reasoningEffort, ''),
+            startedAt,
+            durationMs: Math.max(0, now - startedAt),
+            evidencePaths: worker.outputLastMessage && isPathInside(cwd, worker.outputLastMessage) ? [path.relative(cwd, worker.outputLastMessage)] : [],
+            evidencePathCount: worker.outputLastMessage ? 1 : 0,
+            changedPathCount: 0,
+            collectReasonClasses: ['active worker process'],
+            mergeReadiness: 'running',
+            sourceRun: relativeRun,
+            sourceLabel: relativeRun ? lifetimeSourceLabel(relativeRun) : 'active-process',
+            generatedAt: now
+        });
+    }
+    return jobs.sort((left, right) => textValue(left.lane, '').localeCompare(textValue(right.lane, '')) || textValue(left.title, '').localeCompare(textValue(right.title, '')));
+}
+function regexCommandOption(command, option) {
+    const escaped = option.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const match = new RegExp(`${escaped}\\s+([^\\s]+)`).exec(command);
+    return match?.[1] ?? '';
+}
+function splitCommandWords(command) {
+    return command.match(/"[^"]*"|'[^']*'|\S+/g)?.map((word) => word.replace(/^(['"])(.*)\1$/u, '$2')) ?? [];
+}
+function parsePsElapsedMs(value) {
+    const daySplit = value.split('-');
+    const days = daySplit.length === 2 ? Number(daySplit[0]) || 0 : 0;
+    const time = daySplit.at(-1) ?? '';
+    const parts = time.split(':').map((part) => Number(part) || 0);
+    const [hours, minutes, seconds] = parts.length === 3 ? parts : [0, parts[0] ?? 0, parts[1] ?? 0];
+    return (((days * 24 + hours) * 60 + minutes) * 60 + seconds) * 1000;
+}
+function inferLaneFromWorkerJobId(jobId) {
+    const parts = jobId.split('-');
+    const half = Math.floor(parts.length / 2);
+    if (half > 0 && parts.slice(0, half).join('-') === parts.slice(half, half * 2).join('-'))
+        return parts.slice(0, half).join('-');
+    return parts.slice(0, Math.max(1, parts.length - 1)).join('-');
+}
+function humanizeWorkerJobId(jobId) {
+    return inferLaneFromWorkerJobId(jobId).split('-').filter(Boolean).map((part) => part[0]?.toUpperCase() + part.slice(1)).join(' ') || jobId;
+}
+async function findLifetimeActiveRunDirs(cwd) {
+    const root = path.join(cwd, 'agent-runs');
+    const stat = await fs.stat(root).catch(() => undefined);
+    if (!stat?.isDirectory())
+        return [];
+    const resetAt = await readLifetimeDashboardResetCutoff(root);
+    const files = await findPidManifestFiles(root, LIFETIME_DASHBOARD_SCAN_MAX_DEPTH, LIFETIME_DASHBOARD_SCAN_MAX_FILES, resetAt);
+    const candidates = await Promise.all(files.map(async (file) => ({
+        file,
+        dir: path.dirname(file),
+        mtimeMs: (await fs.stat(file).catch(() => undefined))?.mtimeMs ?? 0
+    })));
+    const out = [];
+    for (const candidate of candidates.sort((left, right) => right.mtimeMs - left.mtimeMs || right.file.localeCompare(left.file))) {
+        if (out.length >= LIFETIME_DASHBOARD_MAX_ACTIVE_PID_RUNS)
+            break;
+        if (await pidManifestHasLiveCodexEntry(candidate.file))
+            out.push(candidate.dir);
+    }
+    return uniquePaths(out);
+}
+async function findPidManifestFiles(root, maxDepth, maxFiles, resetAt) {
+    const out = [];
+    const skipDirs = new Set(['.git', 'node_modules', 'dist', 'coverage', 'evidence', 'streams', 'patch-scores', 'apply-ledger', 'artifact-index']);
+    async function walk(current, depth) {
+        if (out.length >= maxFiles || depth > maxDepth)
+            return;
+        const entries = await fs.readdir(current, { withFileTypes: true }).catch(() => []);
+        for (const entry of entries) {
+            if (out.length >= maxFiles)
+                return;
+            const absolute = path.join(current, entry.name);
+            if (entry.isDirectory()) {
+                if (skipDirs.has(entry.name) || entry.name.startsWith('.'))
+                    continue;
+                if (resetAt && depth === 0) {
+                    const dirStat = await fs.stat(absolute).catch(() => undefined);
+                    if ((dirStat?.mtimeMs ?? 0) <= resetAt)
+                        continue;
+                }
+                await walk(absolute, depth + 1);
+            }
+            else if (entry.isFile() && entry.name === 'pids.json') {
+                out.push(absolute);
+            }
+        }
+    }
+    await walk(root, 0);
+    return out;
+}
+async function pidManifestHasLiveCodexEntry(file) {
+    const manifest = recordValue(await readJsonFile(file));
+    return recordArray(manifest.entries)
+        .filter((entry) => textValue(entry.role, '') === 'codex')
+        .some((entry) => isProcessLive(numberValue(entry.pid), entry));
+}
 async function readCoordinatorReviewDecisions(cwd) {
     const file = coordinatorReviewDecisionPath(cwd);
     const raw = await readJsonFile(file);
@@ -506,6 +1650,127 @@ async function readCoordinatorReviewDecisions(cwd) {
 function coordinatorReviewDecisionPath(cwd) {
     return path.join(cwd, 'agent-runs', REVIEW_DECISIONS_FILE);
 }
+async function readAutonomousMergeDecisions(cwd) {
+    const root = path.join(cwd, 'agent-runs');
+    const stat = await fs.stat(root).catch(() => undefined);
+    if (!stat?.isDirectory())
+        return [];
+    const files = await findAutonomousMergeDecisionFiles(root);
+    const out = [];
+    for (const file of files) {
+        const text = await fs.readFile(file, 'utf8').catch(() => '');
+        for (const line of text.split(/\r?\n/u)) {
+            const trimmed = line.trim();
+            if (!trimmed)
+                continue;
+            const raw = safeJsonObject(trimmed);
+            if (!raw)
+                continue;
+            const normalizedDecision = normalizeAutonomousMergeDecision(cwd, file, raw);
+            if (normalizedDecision)
+                out.push(normalizedDecision);
+        }
+    }
+    return out.sort(compareCoordinatorReviewDecisionRecency);
+}
+async function findAutonomousMergeDecisionFiles(root) {
+    const out = [];
+    async function walk(current, depth) {
+        if (out.length >= LIFETIME_DASHBOARD_MAX_AUTONOMOUS_DECISION_FILES || depth > LIFETIME_DASHBOARD_SCAN_MAX_DEPTH)
+            return;
+        const entries = await fs.readdir(current, { withFileTypes: true }).catch(() => []);
+        for (const entry of entries) {
+            if (out.length >= LIFETIME_DASHBOARD_MAX_AUTONOMOUS_DECISION_FILES)
+                return;
+            const absolute = path.join(current, entry.name);
+            if (entry.isDirectory()) {
+                if (entry.name === 'node_modules' || entry.name === '.git' || entry.name === 'artifact-store' || entry.name.startsWith('.'))
+                    continue;
+                await walk(absolute, depth + 1);
+            }
+            else if (entry.isFile() && entry.name === 'autonomous-merge-decisions.jsonl') {
+                const stat = await fs.stat(absolute).catch(() => undefined);
+                out.push({ file: absolute, mtimeMs: stat?.mtimeMs ?? 0 });
+            }
+        }
+    }
+    await walk(root, 0);
+    return out.sort((left, right) => right.mtimeMs - left.mtimeMs || right.file.localeCompare(left.file)).map((entry) => entry.file);
+}
+function normalizeAutonomousMergeDecision(cwd, file, raw) {
+    const status = autonomousDecisionStatus(textValue(raw.status ?? raw.decision, ''));
+    if (!status)
+        return undefined;
+    const ids = Array.from(new Set([
+        textValue(raw.jobId, ''),
+        textValue(raw.taskId, ''),
+        ...stringArray(raw.queueItemIds),
+        ...stringArray(raw.queueKeys).map((key) => key.replace(/^(?:queue|task|job):/u, ''))
+    ].filter(Boolean)));
+    if (!ids.length)
+        return undefined;
+    const decidedAtMs = Math.max(numberValue(raw.finishedAt), numberValue(raw.startedAt), Date.parse(textValue(raw.finishedAtIso ?? raw.decidedAt ?? raw.generatedAt, '')) || 0);
+    const relativeFile = path.relative(cwd, file);
+    return {
+        id: textValue(raw.id, ids[0]),
+        jobId: textValue(raw.jobId, ''),
+        taskId: textValue(raw.taskId, ''),
+        matchIds: ids,
+        status,
+        decision: status,
+        reason: textValue(raw.reason, ''),
+        decidedAt: decidedAtMs ? new Date(decidedAtMs).toISOString() : '',
+        decidedAtMs,
+        sourceArtifact: relativeFile,
+        sourceKind: 'autonomous-merge-decision',
+        latestPath: textValue(raw.bundlePath ?? raw.patchPath, relativeFile),
+        autonomousDecision: raw
+    };
+}
+function autonomousDecisionStatus(value) {
+    const status = normalized(value);
+    if (status === 'committed' || status === 'applied')
+        return status;
+    if (status === 'accepted' || status === 'accepted-applied')
+        return 'applied';
+    if (status === 'rejected' || status === 'rerun' || status === 'superseded')
+        return status;
+    if (status === 'conflict' || status === 'conflict-blocked')
+        return 'conflict-blocked';
+    if (status === 'human-blocked' || status === 'human-question')
+        return 'human-blocked';
+    return status;
+}
+function mergeReviewDecisionLists(...groups) {
+    return groups.flat().sort(compareCoordinatorReviewDecisionRecency);
+}
+function compareCoordinatorReviewDecisionRecency(left, right) {
+    return decisionTime(right) - decisionTime(left)
+        || textValue(right.sourceArtifact ?? right.latestPath, '').localeCompare(textValue(left.sourceArtifact ?? left.latestPath, ''));
+}
+function decisionTime(decision) {
+    return numberValue(decision.decidedAtMs)
+        || numberValue(decision.finishedAt)
+        || numberValue(decision.startedAt)
+        || Date.parse(textValue(decision.decidedAt, ''))
+        || 0;
+}
+function autonomousDecisionSourceSummary(decisions) {
+    const files = Array.from(new Set(decisions.map((decision) => textValue(decision.sourceArtifact, '')).filter(Boolean)));
+    return {
+        count: decisions.length,
+        fileCount: files.length,
+        files: files.slice(0, 20)
+    };
+}
+function safeJsonObject(value) {
+    try {
+        return recordValue(JSON.parse(value));
+    }
+    catch {
+        return undefined;
+    }
+}
 function applyCoordinatorReviewDecisions(jobs, decisions) {
     const records = jobs
         .map(recordValue)
@@ -519,25 +1784,103 @@ function applyCoordinatorReviewDecisions(jobs, decisions) {
             return record;
         const status = textValue(decision.status ?? decision.decision, 'resolved');
         const resolved = isResolvedCoordinatorDecision(status);
-        return {
+        const decided = {
             ...record,
             coordinatorDecision: decision,
             coordinatorDecisionStatus: status,
             coordinatorDecisionAt: textValue(decision.decidedAt, ''),
             reviewResolved: resolved,
-            ...(resolved && isCoordinatorPortBucket(record.bucket) ? { bucket: 'review-resolved' } : {}),
             ...(resolved ? { disposition: status } : {})
         };
+        return resolved ? markCoordinatorReviewResolved(decided, status) : decided;
     });
 }
 function normalizeCoordinatorFacingJob(record) {
-    return {
+    const status = coordinatorFacingMachineLabel(record.status);
+    let bucket = coordinatorFacingMachineLabel(record.bucket);
+    if (!bucket && status === 'completed')
+        bucket = 'completed';
+    else if (!bucket && status === 'running')
+        bucket = 'running';
+    else if (!bucket && status === 'failed')
+        bucket = 'failed-evidence';
+    else if (!bucket && status === 'blocked')
+        bucket = 'blocked';
+    let normalizedRecord = {
         ...record,
-        bucket: coordinatorFacingMachineLabel(record.bucket),
-        status: coordinatorFacingMachineLabel(record.status),
+        bucket,
+        status,
         disposition: coordinatorFacingMachineLabel(record.disposition),
         mergeReadiness: coordinatorFacingMachineLabel(record.mergeReadiness)
     };
+    normalizedRecord = normalizeHistoricalEvidenceFailureJob(normalizedRecord);
+    if (!isResolvedCoordinatorReviewRecord(normalizedRecord))
+        return normalizedRecord;
+    return markCoordinatorReviewResolved(normalizedRecord, textValue(normalizedRecord.coordinatorDecisionStatus ?? normalizedRecord.disposition, 'review-resolved'));
+}
+function normalizeHistoricalEvidenceFailureJob(record) {
+    if (!isHistoricalOwnershipRescopeCandidate(record))
+        return record;
+    return {
+        ...record,
+        reviewResolved: false,
+        originalBucket: record.originalBucket ?? record.bucket,
+        originalStatus: record.originalStatus ?? record.status,
+        originalDisposition: record.originalDisposition ?? record.disposition,
+        bucket: 'rerun-work',
+        status: 'completed',
+        disposition: 'needs-rerun',
+        mergeReadiness: 'needs-rerun',
+        evidenceFailureNormalized: true,
+        collectReasonClasses: uniquePaths([...stringArray(record.collectReasonClasses), 'ownership-rescope-rerun'])
+    };
+}
+function isHistoricalOwnershipRescopeCandidate(record) {
+    const bucket = normalized(record.bucket);
+    const status = normalized(record.status);
+    const disposition = normalized(record.disposition);
+    const readiness = normalized(record.mergeReadiness);
+    const failedEvidence = bucket === 'failed-evidence'
+        || bucket === 'worker-failed'
+        || status === 'failed'
+        || disposition === 'rejected'
+        || disposition === 'failed'
+        || readiness === 'rejected'
+        || readiness === 'blocked';
+    if (!failedEvidence)
+        return false;
+    const ownershipViolationCount = numberValue(record.ownershipViolationCount)
+        || stringArray(record.ownershipViolations).length;
+    if (!ownershipViolationCount)
+        return false;
+    const changedPathCount = numberValue(record.changedPathCount)
+        || stringArray(record.changedPaths).length;
+    if (!changedPathCount)
+        return false;
+    return Boolean(textValue(record.patchPath, '') || textValue(record.patchArtifactPath, '') || changedPathCount);
+}
+function markCoordinatorReviewResolved(record, disposition) {
+    const existingOriginalReasons = stringArray(record.originalReasons);
+    const originalReasons = existingOriginalReasons.length ? existingOriginalReasons : stringArray(record.reasons);
+    const retainedReasons = originalReasons.filter((reason) => !isOpenCoordinatorReviewReason(reason));
+    const decisionReason = textValue(recordValue(record.coordinatorDecision).reason, '');
+    const reasons = uniquePaths([
+        ...retainedReasons,
+        ...(decisionReason ? [decisionReason] : [])
+    ]);
+    return {
+        ...record,
+        reviewResolved: true,
+        originalBucket: record.originalBucket ?? record.bucket,
+        originalStatus: record.originalStatus ?? record.status,
+        ...(originalReasons.length ? { originalReasons } : {}),
+        bucket: 'review-resolved',
+        status: 'completed',
+        disposition: disposition || 'review-resolved',
+        mergeReadiness: 'review-resolved',
+        reasons,
+        health: ['failed', 'warning'].includes(normalized(record.health)) ? 'resolved' : record.health
+    };
 }
 function normalizeCoordinatorFacingSnapshot(record) {
     return {
@@ -583,6 +1926,14 @@ function isCoordinatorPortBucket(value) {
         || bucket === 'needs-coordinator-review'
         || bucket === 'needs-coordinator-decision';
 }
+function isOpenCoordinatorReviewReason(value) {
+    const reason = normalized(value);
+    return isCoordinatorPortBucket(reason)
+        || reason === 'needs-port'
+        || reason === 'needs-review'
+        || reason === 'manual-port-required'
+        || reason === 'manual port required';
+}
 function coordinatorFacingMachineKey(value) {
     return textValue(coordinatorFacingMachineLabel(value), value);
 }
@@ -616,6 +1967,8 @@ function coordinatorReviewDecisionMatches(job, decision) {
     const decisionSource = textValue(decision.source ?? decision.sourceCollection ?? decision.sourceRun ?? decision.sourceLabel, '');
     if (!decisionSource)
         return true;
+    if (isHistoricalReviewDrainDecision(decision))
+        return historicalReviewDrainDecisionMatches(job, decision);
     const jobSources = [
         textValue(job.sourceLabel, ''),
         textValue(job.sourceCollection, ''),
@@ -624,6 +1977,46 @@ function coordinatorReviewDecisionMatches(job, decision) {
     ].filter(Boolean);
     return jobSources.some((source) => source === decisionSource || source.endsWith(decisionSource) || decisionSource.endsWith(source));
 }
+function isHistoricalReviewDrainDecision(decision) {
+    const sources = [
+        textValue(decision.source, ''),
+        textValue(decision.sourceCollection, ''),
+        textValue(decision.sourceRun, ''),
+        textValue(decision.sourceLabel, ''),
+        textValue(decision.sourceArtifact, '')
+    ];
+    return sources.some((source) => normalized(source).includes('historical-review-drain'));
+}
+function historicalReviewDrainDecisionMatches(job, decision) {
+    if (normalized(job.status) === 'running' || normalized(job.bucket) === 'running')
+        return false;
+    const latestPath = textValue(decision.latestPath, '');
+    if (!latestPath)
+        return false;
+    const latestRoot = historicalReviewDrainSourceRoot(latestPath);
+    if (!latestRoot)
+        return false;
+    const jobSources = [
+        textValue(job.sourceLabel, ''),
+        textValue(job.sourceCollection, ''),
+        textValue(job.sourceRun, ''),
+        textValue(job.sourceContinuation, '')
+    ].filter(Boolean);
+    return jobSources.some((source) => {
+        const jobRoot = historicalReviewDrainSourceRoot(source);
+        return Boolean(jobRoot) && (jobRoot === latestRoot || jobRoot.endsWith(latestRoot) || latestRoot.endsWith(jobRoot));
+    });
+}
+function historicalReviewDrainSourceRoot(value) {
+    const normalizedPath = value.replaceAll('\\', '/').replace(/\/(?:queue-overlay|collection|coordinator-query|swarm-results|coordinator-dashboard)\.json$/u, '');
+    const autoDrainIndex = normalizedPath.indexOf('/auto-drain/');
+    if (autoDrainIndex >= 0)
+        return normalizedPath.slice(0, autoDrainIndex);
+    const collectionIndex = normalizedPath.search(/\/(?:collection|collected|post-coordinator-collected|coordinator-collected)[^/]*(?:\/|$)/u);
+    if (collectionIndex >= 0)
+        return normalizedPath.slice(0, collectionIndex);
+    return normalizedPath.replace(/\/$/u, '');
+}
 function coordinatorDecisionIds(record) {
     return Array.from(new Set([
         textValue(record.id, ''),
@@ -675,10 +2068,27 @@ function lifetimeDashboardSummary(jobs) {
         averageDurationMs: jobs.length ? Math.round(durationMs / jobs.length) : 0,
         maxDurationMs: jobs.reduce((max, job) => Math.max(max, numberValue(job.durationMs)), 0),
         actualInputTokens: jobs.reduce((sum, job) => sum + numberValue(job.actualInputTokens), 0),
+        estimatedInputTokens: jobs.reduce((sum, job) => sum + numberValue(job.estimatedInputTokens), 0),
         cachedInputTokens: jobs.reduce((sum, job) => sum + numberValue(job.cachedInputTokens), 0),
-        uncachedInputTokens: jobs.reduce((sum, job) => sum + numberValue(job.uncachedInputTokens), 0)
+        uncachedInputTokens: jobs.reduce((sum, job) => sum + numberValue(job.uncachedInputTokens), 0),
+        estimatedCostUsd: roundUsd(jobs.reduce((sum, job) => sum + numberValue(job.estimatedCostUsd), 0)),
+        estimatedInputCostUsd: roundUsd(jobs.reduce((sum, job) => sum + numberValue(job.estimatedInputCostUsd), 0)),
+        estimatedCachedInputCostUsd: roundUsd(jobs.reduce((sum, job) => sum + numberValue(job.estimatedCachedInputCostUsd), 0)),
+        estimatedUncachedInputCostUsd: roundUsd(jobs.reduce((sum, job) => sum + numberValue(job.estimatedUncachedInputCostUsd), 0)),
+        estimatedOutputCostUsd: roundUsd(jobs.reduce((sum, job) => sum + numberValue(job.estimatedOutputCostUsd), 0)),
+        estimatedCostMicroUsd: jobs.reduce((sum, job) => sum + numberValue(job.estimatedCostMicroUsd), 0),
+        priceKnownJobCount: jobs.filter((job) => job.priceKnown === true).length,
+        bucketCounts: countJobsByBucket(jobs)
     };
 }
+function countJobsByBucket(jobs) {
+    const counts = {};
+    for (const job of jobs) {
+        const bucket = textValue(job.bucket, 'unknown') || 'unknown';
+        counts[bucket] = (counts[bucket] ?? 0) + 1;
+    }
+    return counts;
+}
 function lifetimeHealthSummary(jobs) {
     const summary = lifetimeDashboardSummary(jobs);
     const failedJobCount = numberValue(summary.failedCount);
@@ -719,6 +2129,144 @@ function lifetimeLaneRows(jobs) {
         runningCount: entries.filter((job) => textValue(job.status, '') === 'running').length
     }));
 }
+function lifetimeQueueBacklogOverlay(queueBacklog, jobs) {
+    const jobsByKey = new Map();
+    for (const job of jobs) {
+        for (const key of recordIdentityKeys(job).map(canonicalLifetimeTaskKey).filter(Boolean)) {
+            jobsByKey.set(key, [...(jobsByKey.get(key) ?? []), job]);
+        }
+    }
+    let activeCount = 0;
+    let doneCount = 0;
+    let failedCount = 0;
+    let representedCount = 0;
+    const entries = [];
+    for (const entry of queueBacklog.entries) {
+        const matchedJobs = Array.from(new Set(recordIdentityKeys(entry).map(canonicalLifetimeTaskKey).flatMap((key) => jobsByKey.get(key) ?? [])));
+        if (!matchedJobs.length) {
+            entries.push(entry);
+            continue;
+        }
+        representedCount += 1;
+        if (matchedJobs.some((job) => textValue(job.status, '') === 'running'))
+            activeCount += 1;
+        else if (matchedJobs.some(isLifetimeFailedJob))
+            failedCount += 1;
+        else if (matchedJobs.some((job) => textValue(job.status, '') === 'completed' || isResolvedCoordinatorReviewRecord(job)))
+            doneCount += 1;
+        else
+            activeCount += 1;
+    }
+    return {
+        entries,
+        totalCount: queueBacklog.entries.length,
+        readyCount: entries.filter((entry) => textValue(entry.status, '') === 'todo').length,
+        activeCount,
+        doneCount,
+        failedCount,
+        representedCount
+    };
+}
+function lifetimeCapacitySummary(queueBacklog, jobs, openQueueEntries = queueBacklog.entries) {
+    const manifest = queueBacklog.manifests[0];
+    const laneRows = new Map();
+    const terminalTaskIds = new Set(jobs
+        .filter((job) => ['completed', 'failed', 'blocked'].includes(textValue(job.status, '').toLowerCase()))
+        .flatMap((job) => recordIdentityKeys(job).map(canonicalLifetimeTaskKey)));
+    const representedTaskIds = new Set(jobs.flatMap((job) => recordIdentityKeys(job).map(canonicalLifetimeTaskKey)));
+    const openEntries = openQueueEntries.filter((entry) => {
+        const ids = recordIdentityKeys(entry);
+        return !ids.some((id) => terminalTaskIds.has(canonicalLifetimeTaskKey(id)) || representedTaskIds.has(canonicalLifetimeTaskKey(id)));
+    });
+    const queuedByLane = groupRecordsByText(openEntries, (entry) => textValue(entry.lane ?? entry.group ?? entry.sourceQueue, 'unassigned'));
+    const jobsByLane = groupRecordsByText(jobs, (job) => textValue(job.lane, 'unassigned'));
+    const manifestLanes = manifest?.lanes ?? [];
+    for (const lane of manifestLanes) {
+        laneRows.set(lane.id, capacityLaneRow(lane, queuedByLane.get(lane.id) ?? [], jobsByLane.get(lane.id) ?? []));
+    }
+    for (const [laneId, entries] of queuedByLane) {
+        if (!laneRows.has(laneId))
+            laneRows.set(laneId, capacityLaneRow({ id: laneId, title: laneId, layer: '', compute: '', model: '', maxConcurrency: 1 }, entries, jobsByLane.get(laneId) ?? []));
+    }
+    for (const [laneId, entries] of jobsByLane) {
+        if (!laneRows.has(laneId))
+            laneRows.set(laneId, capacityLaneRow({ id: laneId, title: laneId, layer: '', compute: '', model: '', maxConcurrency: 1 }, queuedByLane.get(laneId) ?? [], entries));
+    }
+    const lanes = Array.from(laneRows.values()).sort((left, right) => {
+        const pressure = numberValue(right.runningCount) - numberValue(left.runningCount)
+            || numberValue(right.queuedTaskCount) - numberValue(left.queuedTaskCount);
+        return pressure || textValue(left.id, '').localeCompare(textValue(right.id, ''));
+    });
+    const runningAgentCount = jobs.filter((job) => textValue(job.status, '') === 'running').length;
+    const queuedTaskCount = lanes.reduce((sum, lane) => sum + numberValue(lane.queuedTaskCount), 0);
+    return {
+        manifestPath: manifest?.path ?? '',
+        manifestId: manifest?.id ?? '',
+        title: manifest?.title ?? 'Swarm capacity',
+        defaultConcurrency: manifest?.defaultConcurrency ?? 0,
+        computeMaxConcurrency: manifest?.computeMaxConcurrency ?? 0,
+        maxConcurrency: manifest?.maxConcurrency ?? 0,
+        laneCount: lanes.length,
+        openLaneCount: lanes.filter((lane) => numberValue(lane.queuedTaskCount) > 0 || numberValue(lane.runningCount) > 0).length,
+        activeLaneCount: lanes.filter((lane) => numberValue(lane.runningCount) > 0).length,
+        runningAgentCount,
+        assignedAgentCount: lanes.reduce((sum, lane) => sum + numberValue(lane.assignedAgentCount), 0),
+        queuedTaskCount,
+        totalTaskCount: queueBacklog.entries.length,
+        completedTaskCount: jobs.filter((job) => textValue(job.status, '') === 'completed').length,
+        lanes,
+        queueSources: queueBacklog.paths
+    };
+}
+function capacityLaneRow(lane, queuedEntries, laneJobs) {
+    const runningJobs = laneJobs.filter((job) => textValue(job.status, '') === 'running');
+    const queuedJobs = laneJobs.filter((job) => textValue(job.status, '') === 'queued');
+    const assignedAgents = Array.from(new Set(runningJobs.map((job) => textValue(job.agentId ?? job.workerId ?? job.id, '')).filter(Boolean))).slice(0, 6);
+    const queuedKeys = new Set([
+        ...queuedEntries.filter((entry) => {
+            const status = normalized(entry.status ?? entry.queueStatus);
+            return !status || ['todo', 'queued', 'pending', 'ready', 'open'].includes(status);
+        }).map(primaryRecordIdentityKey).filter(Boolean),
+        ...queuedJobs.map(primaryRecordIdentityKey).filter(Boolean)
+    ]);
+    return {
+        id: lane.id,
+        title: lane.title || lane.id,
+        layer: lane.layer,
+        compute: lane.compute,
+        model: lane.model,
+        maxConcurrency: lane.maxConcurrency,
+        queuedTaskCount: queuedKeys.size,
+        totalTaskCount: queuedEntries.length,
+        runningCount: runningJobs.length,
+        completedCount: laneJobs.filter((job) => textValue(job.status, '') === 'completed').length,
+        failedCount: laneJobs.filter(isLifetimeFailedJob).length,
+        assignedAgentCount: assignedAgents.length,
+        assignedAgents
+    };
+}
+function recordIdentityKeys(record) {
+    return Array.from(new Set([
+        textValue(record.id, ''),
+        textValue(record.originalJobId, ''),
+        textValue(record.jobId, ''),
+        textValue(record.taskId, '')
+    ].filter(Boolean)));
+}
+function primaryRecordIdentityKey(record) {
+    return canonicalLifetimeTaskKey(textValue(record.taskId, ''))
+        || canonicalLifetimeTaskKey(textValue(record.originalJobId, ''))
+        || canonicalLifetimeTaskKey(textValue(record.jobId, ''))
+        || canonicalLifetimeTaskKey(textValue(record.id, ''));
+}
+function groupRecordsByText(records, keyFor) {
+    const groups = new Map();
+    for (const record of records) {
+        const key = keyFor(record) || 'unassigned';
+        groups.set(key, [...(groups.get(key) ?? []), record]);
+    }
+    return groups;
+}
 function lifetimeTimeSeries(jobs, events) {
     const bucketMs = 24 * 60 * 60 * 1000;
     const buckets = new Map();
@@ -727,7 +2275,7 @@ function lifetimeTimeSeries(jobs, events) {
         if (!at)
             continue;
         const bucketAt = startOfLocalDay(at);
-        const bucket = buckets.get(bucketAt) ?? { at: bucketAt, terminalJobCount: 0, warningJobCount: 0, failureJobCount: 0, durationMs: 0, actualInputTokens: 0, uncachedInputTokens: 0, eventCount: 0 };
+        const bucket = buckets.get(bucketAt) ?? emptyLifetimeTimeBucket(bucketAt);
         if (['completed', 'failed', 'blocked'].includes(textValue(job.status, '').toLowerCase()))
             bucket.terminalJobCount += 1;
         if (textValue(job.health, '') === 'warning')
@@ -736,7 +2284,10 @@ function lifetimeTimeSeries(jobs, events) {
             bucket.failureJobCount += 1;
         bucket.durationMs += numberValue(job.durationMs);
         bucket.actualInputTokens += numberValue(job.actualInputTokens);
+        bucket.estimatedInputTokens += numberValue(job.estimatedInputTokens);
         bucket.uncachedInputTokens += numberValue(job.uncachedInputTokens);
+        bucket.estimatedCostUsd = roundUsd(bucket.estimatedCostUsd + numberValue(job.estimatedCostUsd));
+        bucket.estimatedCostMicroUsd += numberValue(job.estimatedCostMicroUsd);
         buckets.set(bucketAt, bucket);
     }
     for (const event of events) {
@@ -744,7 +2295,7 @@ function lifetimeTimeSeries(jobs, events) {
         if (!at)
             continue;
         const bucketAt = startOfLocalDay(at);
-        const bucket = buckets.get(bucketAt) ?? { at: bucketAt, terminalJobCount: 0, warningJobCount: 0, failureJobCount: 0, durationMs: 0, actualInputTokens: 0, uncachedInputTokens: 0, eventCount: 0 };
+        const bucket = buckets.get(bucketAt) ?? emptyLifetimeTimeBucket(bucketAt);
         bucket.eventCount += 1;
         buckets.set(bucketAt, bucket);
     }
@@ -759,11 +2310,29 @@ function lifetimeTimeSeries(jobs, events) {
             failureJobCount: points.reduce((sum, point) => sum + point.failureJobCount, 0),
             durationMs: points.reduce((sum, point) => sum + point.durationMs, 0),
             actualInputTokens: points.reduce((sum, point) => sum + point.actualInputTokens, 0),
+            estimatedInputTokens: points.reduce((sum, point) => sum + point.estimatedInputTokens, 0),
             uncachedInputTokens: points.reduce((sum, point) => sum + point.uncachedInputTokens, 0),
+            estimatedCostUsd: roundUsd(points.reduce((sum, point) => sum + point.estimatedCostUsd, 0)),
+            estimatedCostMicroUsd: points.reduce((sum, point) => sum + point.estimatedCostMicroUsd, 0),
             missingTimestampJobCount: jobs.filter((job) => !numberValue(job.finishedAt) && !numberValue(job.generatedAt) && !numberValue(job.startedAt)).length
         }
     };
 }
+function emptyLifetimeTimeBucket(at) {
+    return {
+        at,
+        terminalJobCount: 0,
+        warningJobCount: 0,
+        failureJobCount: 0,
+        durationMs: 0,
+        actualInputTokens: 0,
+        estimatedInputTokens: 0,
+        uncachedInputTokens: 0,
+        estimatedCostUsd: 0,
+        estimatedCostMicroUsd: 0,
+        eventCount: 0
+    };
+}
 function startOfLocalDay(value) {
     const date = new Date(value);
     return new Date(date.getFullYear(), date.getMonth(), date.getDate()).getTime();
@@ -777,28 +2346,92 @@ function lifetimeSemanticSummary(jobs) {
         conflicts: jobs.filter((job) => textValue(job.semanticReadiness, '') === 'blocked').length
     };
 }
-function lifetimeRoutingSummary(snapshots) {
-    const routingRows = snapshots.map((snapshot) => recordValue(snapshot.routing)).filter((entry) => Object.keys(entry).length);
-    if (!routingRows.length)
+async function lifetimeRoutingSummary(cwd, entries) {
+    const routingRows = entries.map(({ snapshot }) => recordValue(snapshot.routing)).filter((entry) => Object.keys(entry).length);
+    const sidecars = await readLifetimeRoutingSidecars(cwd, entries.map(({ source }) => source));
+    if (!routingRows.length && !sidecars.tournamentCount && !sidecars.feedbackArtifactCount && !sidecars.historyCount)
         return undefined;
     return {
         policyId: 'workspace-lifetime',
         preferenceCount: routingRows.reduce((sum, row) => sum + numberValue(row.preferenceCount), 0),
         preferCount: routingRows.reduce((sum, row) => sum + numberValue(row.preferCount), 0),
         avoidCount: routingRows.reduce((sum, row) => sum + numberValue(row.avoidCount), 0),
-        tournamentObservationCount: routingRows.reduce((sum, row) => sum + numberValue(row.tournamentObservationCount), 0),
-        tournamentRecommendationCount: routingRows.reduce((sum, row) => sum + numberValue(row.tournamentRecommendationCount), 0)
+        feedbackCount: routingRows.reduce((sum, row) => sum + numberValue(row.feedbackCount), 0) + sidecars.feedbackSignalCount,
+        tournamentObservationCount: routingRows.reduce((sum, row) => sum + numberValue(row.tournamentObservationCount), 0) + sidecars.tournamentObservationCount,
+        tournamentRecommendationCount: routingRows.reduce((sum, row) => sum + numberValue(row.tournamentRecommendationCount), 0) + sidecars.tournamentRecommendationCount,
+        tournamentCount: sidecars.tournamentCount,
+        tournamentMatchCount: sidecars.tournamentMatchCount,
+        tournamentVerifiedCount: sidecars.tournamentVerifiedCount,
+        tournamentTopStrategyId: sidecars.topStrategyId,
+        tournamentDecisionGrade: sidecars.decisionGrade,
+        strategyHistoryCount: sidecars.historyCount,
+        feedbackArtifactCount: sidecars.feedbackArtifactCount
+    };
+}
+async function readLifetimeRoutingSidecars(cwd, sources) {
+    const out = {
+        tournamentCount: 0,
+        tournamentMatchCount: 0,
+        tournamentVerifiedCount: 0,
+        tournamentObservationCount: 0,
+        tournamentRecommendationCount: 0,
+        feedbackSignalCount: 0,
+        feedbackArtifactCount: 0,
+        historyCount: 0,
+        topStrategyId: '',
+        decisionGrade: ''
     };
+    const seen = new Set();
+    for (const source of sources) {
+        const dir = lifetimeRoutingSidecarDir(cwd, source);
+        if (!dir || seen.has(dir))
+            continue;
+        seen.add(dir);
+        const tournament = recordValue(await readJsonFile(path.join(dir, 'strategy-tournament.json')));
+        const tournamentSummary = recordValue(tournament.summary);
+        if (Object.keys(tournament).length) {
+            out.tournamentCount += 1;
+            out.tournamentMatchCount += numberValue(tournamentSummary.matchCount);
+            out.tournamentVerifiedCount += numberValue(tournamentSummary.verifiedCount);
+            out.tournamentObservationCount += numberValue(tournamentSummary.matchCount) || recordArray(tournament.matches).length;
+            out.tournamentRecommendationCount += textValue(tournament.winnerId ?? tournamentSummary.topStrategyId, '') ? 1 : 0;
+            if (!out.topStrategyId)
+                out.topStrategyId = textValue(tournamentSummary.topStrategyId ?? tournament.winnerId, '');
+            if (!out.decisionGrade)
+                out.decisionGrade = textValue(tournamentSummary.decisionGrade, '');
+        }
+        const feedback = recordValue(await readJsonFile(path.join(dir, 'tournament-adaptive-feedback.json')));
+        const feedbackSummary = recordValue(feedback.summary);
+        if (Object.keys(feedback).length) {
+            out.feedbackArtifactCount += 1;
+            out.tournamentObservationCount += numberValue(feedbackSummary.observationCount) || recordArray(feedback.observations).length;
+            out.tournamentRecommendationCount += numberValue(feedbackSummary.recommendationCount) || recordArray(feedback.recommendations).length;
+            out.feedbackSignalCount += numberValue(feedbackSummary.reduceSignals) + numberValue(feedbackSummary.increaseSignals) + numberValue(feedbackSummary.holdSignals);
+        }
+        const history = recordValue(await readJsonFile(path.join(dir, 'strategy-history.json')));
+        if (Object.keys(history).length) {
+            out.historyCount += recordArray(history.tournaments).length || 1;
+        }
+    }
+    return out;
+}
+function lifetimeRoutingSidecarDir(cwd, source) {
+    const relative = source.collection ?? source.continuation ?? source.run;
+    if (!relative)
+        return undefined;
+    const absolute = path.resolve(cwd, relative);
+    return isPathInside(cwd, absolute) ? absolute : undefined;
 }
 function isLifetimeFailedJob(job) {
+    if (isResolvedCoordinatorReviewRecord(job))
+        return false;
     const status = textValue(job.status, '').toLowerCase();
     const health = textValue(job.health, '').toLowerCase();
     const bucket = textValue(job.bucket, '').toLowerCase();
+    if (bucket === 'rerun-work')
+        return false;
     return status === 'failed' || health === 'failed' || bucket === 'failed-evidence';
 }
-function awaitNoop(value) {
-    return value;
-}
 function shouldPreferActiveRunSnapshot(jobs, activeJobs) {
     if (!activeJobs.length)
         return false;
@@ -807,24 +2440,27 @@ function shouldPreferActiveRunSnapshot(jobs, activeJobs) {
         return true;
     return activeJobs.length > jobs.length;
 }
-async function readActiveRunSnapshot(options) {
+async function readActiveRunSnapshot(options, readOptions = {}) {
     const runDir = await resolveRunDirectory(options);
     if (!runDir)
         return undefined;
     const pidPath = path.join(runDir, 'pids.json');
     const pidManifest = recordValue(await readJsonFile(pidPath));
-    const entries = recordArray(pidManifest.entries).filter((entry) => textValue(entry.role, '') === 'codex');
+    let entries = recordArray(pidManifest.entries).filter((entry) => textValue(entry.role, '') === 'codex');
+    if (readOptions.runningOnly)
+        entries = entries.filter((entry) => isProcessLive(numberValue(entry.pid), entry));
     if (!entries.length)
         return undefined;
     const planPath = path.join(runDir, 'swarm-plan.json');
     const plan = recordValue(await readJsonFile(planPath));
     const planJobs = new Map(recordArray(plan.jobs).map((job) => [textValue(job.id, ''), job]));
     const now = Date.now();
-    const jobs = await Promise.all(entries.map((entry) => activeRunJob(runDir, entry, planJobs.get(textValue(entry.jobId, '')), now)));
+    const jobs = await Promise.all(entries.map((entry) => activeRunJob(options.cwd, runDir, entry, planJobs.get(textValue(entry.jobId, '')), now, readOptions)));
     const runningCount = jobs.filter((job) => textValue(job.status, '') === 'running').length;
     const completedCount = jobs.filter((job) => textValue(job.status, '') === 'completed').length;
     const failedCount = jobs.filter((job) => textValue(job.status, '') === 'failed').length;
     const actualInputTokens = jobs.reduce((sum, job) => sum + numberValue(job.actualInputTokens), 0);
+    const estimatedInputTokens = jobs.reduce((sum, job) => sum + numberValue(job.estimatedInputTokens), 0);
     const cachedInputTokens = jobs.reduce((sum, job) => sum + numberValue(job.cachedInputTokens), 0);
     return {
         ok: true,
@@ -837,6 +2473,7 @@ async function readActiveRunSnapshot(options) {
             runningCount,
             blockedCount: 0,
             actualInputTokens,
+            estimatedInputTokens,
             cachedInputTokens,
             uncachedInputTokens: Math.max(0, actualInputTokens - cachedInputTokens),
             durationMs: jobs.reduce((sum, job) => Math.max(sum, numberValue(job.durationMs)), 0),
@@ -849,6 +2486,7 @@ async function readActiveRunSnapshot(options) {
         },
         lanes: activeRunLanes(jobs),
         jobs,
+        activeAgents: activeAgentsFromJobs(jobs),
         events: activeRunEvents(jobs),
         sources: {
             run: runDir,
@@ -864,35 +2502,53 @@ async function readActiveRunSnapshot(options) {
         }
     };
 }
-async function activeRunJob(runDir, entry, planJob, now) {
+async function activeRunJob(cwd, runDir, entry, planJob, now, readOptions = {}) {
     const jobId = textValue(entry.jobId, 'job');
     const jobDir = path.join(runDir, jobId);
     const lastMessagePath = path.join(jobDir, 'last-message.md');
     const mergePath = path.join(jobDir, 'merge.json');
+    const eventsPath = path.join(jobDir, 'codex-events.jsonl');
+    const evidenceRecord = recordValue(await readJsonFile(path.join(jobDir, 'evidence', 'evidence.json')));
     const lastMessage = await fs.stat(lastMessagePath).catch(() => undefined);
     const merge = recordValue(await readJsonFile(mergePath));
     const live = isProcessLive(numberValue(entry.pid), entry);
-    const status = live && !lastMessage ? 'running' : lastMessage || Object.keys(merge).length ? 'completed' : 'failed';
+    const quotaDeferred = !live && !lastMessage && !Object.keys(merge).length && await codexEventsHaveQuotaLimit(eventsPath);
+    const status = live && !lastMessage ? 'running' : quotaDeferred ? 'completed' : lastMessage || Object.keys(merge).length ? 'completed' : 'failed';
     const startedAt = numberValue(entry.startedAt);
     const finishedAt = status === 'running' ? undefined : Math.max(numberValue(lastMessage?.mtimeMs), numberValue(merge.generatedAt));
-    const evidencePaths = [
-        path.relative(optionsSafeCwd(runDir), lastMessagePath),
-        path.relative(optionsSafeCwd(runDir), path.join(jobDir, 'codex-events.jsonl')),
-        path.relative(optionsSafeCwd(runDir), path.join(jobDir, 'evidence', 'resource-allocation.json')),
-        ...(Object.keys(merge).length ? [path.relative(optionsSafeCwd(runDir), mergePath)] : [])
-    ];
-    const usage = await readCodexEventUsageSummary(path.join(jobDir, 'codex-events.jsonl'));
+    const rawPatchPath = await firstExistingRelativePath(cwd, rawRunPatchCandidates(jobDir));
+    const evidencePaths = await existingRelativePaths(cwd, [
+        lastMessagePath,
+        eventsPath,
+        path.join(jobDir, 'evidence', 'last-message.md'),
+        path.join(jobDir, 'evidence', 'handoff.md'),
+        path.join(jobDir, 'evidence', 'evidence.json'),
+        path.join(jobDir, 'evidence', 'resource-allocation.json'),
+        ...rawRunPatchCandidates(jobDir),
+        ...(Object.keys(merge).length ? [mergePath] : [])
+    ]);
+    const usage = readOptions.includeUsage === false ? emptyCodexEventUsageSummary() : await readCodexEventUsageSummary(eventsPath);
     const task = recordValue(planJob?.task);
     const compute = recordValue(planJob?.compute);
-    const changedPaths = stringArray(merge.changedPaths);
-    return {
+    const changedPaths = uniquePaths([
+        ...stringArray(merge.changedPaths),
+        ...await readPatchChangedPathList(cwd, rawPatchPath)
+    ]);
+    const commandEvidence = commandEvidenceFromRecords(merge, evidenceRecord);
+    return withRecomputedCostFields({
         id: jobId,
         taskId: textValue(planJob?.taskId ?? task.id, jobId),
         title: textValue(planJob?.title ?? task.title, jobId),
         lane: textValue(planJob?.lane ?? task.lane, 'active-run'),
         status,
-        bucket: status === 'running' ? 'running' : status === 'completed' ? 'completed' : 'failed-evidence',
-        disposition: status === 'running' ? 'active' : status,
+        bucket: quotaDeferred ? 'review-resolved' : status === 'running' ? 'running' : status === 'completed' ? 'completed' : 'failed-evidence',
+        disposition: status === 'running' ? 'active' : quotaDeferred ? 'quota-deferred' : status,
+        ...(quotaDeferred ? {
+            reviewResolved: true,
+            coordinatorDecisionStatus: 'quota-deferred',
+            originalStatus: 'queued',
+            originalBucket: 'queued'
+        } : {}),
         agentId: jobId,
         workerId: jobId,
         model: textValue(compute.model, ''),
@@ -902,6 +2558,7 @@ async function activeRunJob(runDir, entry, planJob, now) {
         ...(finishedAt ? { finishedAt } : {}),
         durationMs: startedAt ? Math.max(0, (finishedAt ?? now) - startedAt) : 0,
         ...(usage.inputTokens ? { actualInputTokens: usage.inputTokens, inputTokens: usage.inputTokens } : {}),
+        ...(!usage.inputTokens && usage.estimatedInputTokens ? { estimatedInputTokens: usage.estimatedInputTokens } : {}),
         ...(usage.cachedInputTokens ? { cachedInputTokens: usage.cachedInputTokens } : {}),
         ...(usage.uncachedInputTokens ? { uncachedInputTokens: usage.uncachedInputTokens } : {}),
         ...(usage.outputTokens ? { actualOutputTokens: usage.outputTokens, outputTokens: usage.outputTokens } : {}),
@@ -913,19 +2570,22 @@ async function activeRunJob(runDir, entry, planJob, now) {
                 uncached_input_tokens: usage.uncachedInputTokens,
                 output_tokens: usage.outputTokens,
                 reasoning_output_tokens: usage.reasoningOutputTokens,
+                estimated_input_tokens: usage.estimatedInputTokens,
+                estimated_from_event_bytes: usage.estimatedFromEventBytes,
                 source: 'codex-events.jsonl',
                 event_count: usage.eventCount
             }
         } : {}),
         changedPaths,
         changedPathCount: changedPaths.length || numberValue(merge.changedPathCount),
+        ...(rawPatchPath ? { patchPath: rawPatchPath, artifactPaths: [rawPatchPath] } : {}),
         evidencePaths,
         evidencePathCount: evidencePaths.length,
-        commandsPassed: recordArray(merge.commandsPassed),
-        commandsFailed: recordArray(merge.commandsFailed),
-        collectReasonClasses: status === 'running' ? ['active worker'] : [],
-        mergeReadiness: textValue(merge.mergeReadiness, status)
-    };
+        commandsPassed: commandEvidence.passed,
+        commandsFailed: commandEvidence.failed,
+        collectReasonClasses: status === 'running' ? ['active worker'] : quotaDeferred ? ['quota deferred'] : [],
+        mergeReadiness: quotaDeferred ? 'quota-deferred' : textValue(merge.mergeReadiness, status)
+    });
 }
 function activeRunLanes(jobs) {
     const byLane = new Map();
@@ -952,6 +2612,39 @@ function activeRunEvents(jobs) {
         message: `${textValue(job.title, 'worker')} ${textValue(job.status, 'running')}`
     }));
 }
+function activeAgentsFromJobs(jobs) {
+    return jobs
+        .map(recordValue)
+        .filter((job) => textValue(job.status, '') === 'running')
+        .map((job) => {
+        const id = textValue(job.agentId ?? job.workerId ?? job.originalJobId ?? job.id, 'agent');
+        return {
+            id,
+            agentId: id,
+            workerId: textValue(job.workerId ?? job.agentId ?? id, id),
+            jobId: textValue(job.originalJobId ?? job.id ?? job.taskId, id),
+            taskId: textValue(job.taskId ?? job.originalJobId ?? job.id, id),
+            title: textValue(job.title, id),
+            lane: textValue(job.lane, ''),
+            status: 'active',
+            model: textValue(job.model, ''),
+            computeId: textValue(job.computeId, ''),
+            reasoningEffort: textValue(job.reasoningEffort, ''),
+            startedAt: numberValue(job.startedAt) || undefined,
+            durationMs: numberValue(job.durationMs),
+            inputTokens: numberValue(job.inputTokens || job.actualInputTokens || job.estimatedInputTokens),
+            uncachedInputTokens: numberValue(job.uncachedInputTokens),
+            cachedInputTokens: numberValue(job.cachedInputTokens),
+            outputTokens: numberValue(job.outputTokens || job.actualOutputTokens),
+            changedPaths: stringArray(job.changedPaths),
+            changedPathCount: numberValue(job.changedPathCount) || stringArray(job.changedPaths).length,
+            evidencePaths: stringArray(job.evidencePaths),
+            evidencePathCount: numberValue(job.evidencePathCount) || stringArray(job.evidencePaths).length,
+            sourceRun: textValue(job.sourceRun, ''),
+            sourceLabel: textValue(job.sourceLabel, '')
+        };
+    });
+}
 function mergeActiveRunJobTelemetry(jobs, activeJobs) {
     if (!activeJobs.length)
         return jobs;
@@ -975,6 +2668,7 @@ function mergeActiveRunJobTelemetry(jobs, activeJobs) {
             ...record,
             ...(numberValue(activeJob.actualInputTokens) ? { actualInputTokens: numberValue(activeJob.actualInputTokens) } : {}),
             ...(numberValue(activeJob.inputTokens) ? { inputTokens: numberValue(activeJob.inputTokens) } : {}),
+            ...(numberValue(activeJob.estimatedInputTokens) ? { estimatedInputTokens: numberValue(activeJob.estimatedInputTokens) } : {}),
             ...(numberValue(activeJob.cachedInputTokens) ? { cachedInputTokens: numberValue(activeJob.cachedInputTokens) } : {}),
             ...(numberValue(activeJob.uncachedInputTokens) ? { uncachedInputTokens: numberValue(activeJob.uncachedInputTokens) } : {}),
             ...(numberValue(activeJob.actualOutputTokens) ? { actualOutputTokens: numberValue(activeJob.actualOutputTokens) } : {}),
@@ -999,6 +2693,7 @@ function jobTelemetryKeys(job) {
 function hasTokenTelemetry(job) {
     return numberValue(job.actualInputTokens)
         + numberValue(job.inputTokens)
+        + numberValue(job.estimatedInputTokens)
         + numberValue(job.cachedInputTokens)
         + numberValue(job.uncachedInputTokens)
         + numberValue(job.outputTokens)
@@ -1013,6 +2708,7 @@ async function readCodexEventUsageSummary(file) {
     if (!text)
         return empty;
     const summary = emptyCodexEventUsageSummary();
+    summary.estimatedFromEventBytes = Buffer.byteLength(text, 'utf8');
     for (const line of text.split(/\r?\n/g)) {
         const trimmed = line.trim();
         if (!trimmed)
@@ -1040,6 +2736,9 @@ async function readCodexEventUsageSummary(file) {
     if (summary.inputTokens && !summary.uncachedInputTokens) {
         summary.uncachedInputTokens = Math.max(0, summary.inputTokens - summary.cachedInputTokens);
     }
+    if (!hasCodexUsageValues(summary)) {
+        summary.estimatedInputTokens = estimateInputTokensFromEventText(text);
+    }
     return summary;
 }
 function emptyCodexEventUsageSummary() {
@@ -1049,9 +2748,17 @@ function emptyCodexEventUsageSummary() {
         uncachedInputTokens: 0,
         outputTokens: 0,
         reasoningOutputTokens: 0,
+        estimatedInputTokens: 0,
+        estimatedFromEventBytes: 0,
         eventCount: 0
     };
 }
+function estimateInputTokensFromEventText(text) {
+    const compactText = text.replace(/\s+/g, ' ').trim();
+    if (!compactText)
+        return 0;
+    return Math.max(1, Math.ceil(compactText.length / 4));
+}
 function collectCodexUsageRecords(value, depth = 0) {
     if (depth > 5 || !value || typeof value !== 'object')
         return [];
@@ -1090,7 +2797,9 @@ function normalizeCodexUsageRecord(record) {
         uncachedInputTokens,
         outputTokens,
         reasoningOutputTokens,
-        eventCount: hasCodexUsageValues({ inputTokens, cachedInputTokens, uncachedInputTokens, outputTokens, reasoningOutputTokens, eventCount: 0 }) ? 1 : 0
+        estimatedInputTokens: 0,
+        estimatedFromEventBytes: 0,
+        eventCount: hasCodexUsageValues({ inputTokens, cachedInputTokens, uncachedInputTokens, outputTokens, reasoningOutputTokens }) ? 1 : 0
     };
 }
 function hasCodexUsageValues(usage) {
@@ -1123,6 +2832,196 @@ async function readJsonFile(file) {
         return undefined;
     }
 }
+function withRecomputedCostFields(record) {
+    const model = textValue(record.model ?? record.pricingModel ?? record.pricingMatchedModel, '');
+    if (!model || !hasCostTokenEvidence(record))
+        return record;
+    const cost = estimateCodexModelCost({
+        model,
+        estimatedInputTokens: firstCostTokenNumber(record.estimatedInputTokens, record.estimated_input_tokens),
+        actualInputTokens: firstCostTokenNumber(record.actualInputTokens, record.inputTokens, record.promptTokens, record.actual_input_tokens, record.input_tokens, record.prompt_tokens),
+        cachedInputTokens: firstCostTokenNumber(record.cachedInputTokens, record.cachedPromptTokens, record.cached_input_tokens, record.cached_prompt_tokens),
+        uncachedInputTokens: firstCostTokenNumber(record.uncachedInputTokens, record.uncached_input_tokens),
+        outputTokens: optionalCostTokenNumber(record.actualOutputTokens, record.outputTokens, record.completionTokens, record.responseTokens, record.actual_output_tokens, record.output_tokens, record.completion_tokens, record.response_tokens)
+    });
+    return {
+        ...record,
+        billableInputTokens: cost.billableInputTokens,
+        priceKnown: cost.priceKnown,
+        ...(cost.pricingModel ? { pricingModel: cost.pricingModel } : {}),
+        ...(cost.pricingMatchedModel ? { pricingMatchedModel: cost.pricingMatchedModel } : {}),
+        ...(cost.pricingSource ? { pricingSource: cost.pricingSource } : {}),
+        ...(cost.pricingUpdatedAt ? { pricingUpdatedAt: cost.pricingUpdatedAt } : {}),
+        estimatedCostUsd: cost.estimatedCostUsd,
+        estimatedInputCostUsd: cost.estimatedInputCostUsd,
+        estimatedCachedInputCostUsd: cost.estimatedCachedInputCostUsd,
+        estimatedUncachedInputCostUsd: cost.estimatedUncachedInputCostUsd,
+        estimatedOutputCostUsd: cost.estimatedOutputCostUsd,
+        estimatedCostMicroUsd: cost.estimatedCostMicroUsd,
+        costEstimateInputOnly: cost.costEstimateInputOnly,
+        costEstimateEstimatedInput: cost.costEstimateEstimatedInput,
+        costEstimateMissingOutputTokens: cost.costEstimateMissingOutputTokens,
+        costEstimateLongContext: cost.costEstimateLongContext,
+        ...(cost.unknownPricingReason ? { unknownPricingReason: cost.unknownPricingReason } : { unknownPricingReason: undefined })
+    };
+}
+function hasCostTokenEvidence(record) {
+    return [
+        record.actualInputTokens,
+        record.inputTokens,
+        record.promptTokens,
+        record.estimatedInputTokens,
+        record.cachedInputTokens,
+        record.uncachedInputTokens,
+        record.actualOutputTokens,
+        record.outputTokens,
+        record.completionTokens,
+        record.responseTokens,
+        record.actual_input_tokens,
+        record.input_tokens,
+        record.prompt_tokens,
+        record.estimated_input_tokens,
+        record.cached_input_tokens,
+        record.uncached_input_tokens,
+        record.actual_output_tokens,
+        record.output_tokens,
+        record.completion_tokens,
+        record.response_tokens
+    ].some((value) => optionalCostTokenNumber(value) !== undefined && optionalCostTokenNumber(value) > 0);
+}
+function firstCostTokenNumber(...values) {
+    for (const value of values) {
+        const number = optionalCostTokenNumber(value);
+        if (number !== undefined && number > 0)
+            return number;
+    }
+    return 0;
+}
+function optionalCostTokenNumber(...values) {
+    for (const value of values) {
+        if (value === undefined || value === null || value === '')
+            continue;
+        const number = Number(value);
+        if (Number.isFinite(number) && number >= 0)
+            return number;
+    }
+    return undefined;
+}
+function roundUsd(value) {
+    return Math.round(value * 1_000_000_000) / 1_000_000_000;
+}
+async function commandEvidenceFromArtifactPaths(cwd, evidencePaths, outputDir = '') {
+    let out = emptyCommandEvidence();
+    for (const evidencePath of evidencePaths.slice(0, 60)) {
+        if (!evidencePath.endsWith('.json'))
+            continue;
+        const displayPath = resolveRelativeArtifactPath(outputDir, evidencePath);
+        const absolute = path.isAbsolute(displayPath) ? displayPath : path.resolve(cwd, displayPath);
+        const roots = uniquePaths([cwd, outputDir].filter(Boolean).map((root) => path.resolve(root)));
+        if (!roots.some((root) => isPathInside(root, absolute)))
+            continue;
+        out = mergeCommandEvidence(out, commandEvidenceFromRecords(recordValue(await readJsonFile(absolute))));
+    }
+    return out;
+}
+function commandEvidenceFromRecords(...records) {
+    let out = emptyCommandEvidence();
+    for (const record of records) {
+        out = mergeCommandEvidence(out, {
+            passed: [
+                ...commandRecordsFromKnownBucket(record.commandsPassed, 'passed'),
+                ...commandRecordsFromKnownBucket(record.passedCommands, 'passed')
+            ],
+            failed: [
+                ...commandRecordsFromKnownBucket(record.commandsFailed, 'failed'),
+                ...commandRecordsFromKnownBucket(record.failedCommands, 'failed')
+            ]
+        });
+        for (const key of ['verification', 'commands', 'checks', 'testResults', 'results']) {
+            const classified = classifyCommandRecords(recordArray(record[key]));
+            out = mergeCommandEvidence(out, classified);
+        }
+    }
+    return out;
+}
+function commandRecordsFromKnownBucket(value, fallbackStatus) {
+    return recordArray(value)
+        .map((record) => normalizedCommandRecord(record, fallbackStatus))
+        .filter((record) => Boolean(record));
+}
+function classifyCommandRecords(records) {
+    const out = emptyCommandEvidence();
+    for (const record of records) {
+        const classified = classifyCommandRecord(record);
+        if (classified.status === 'passed')
+            out.passed.push(classified.record);
+        else if (classified.status === 'failed')
+            out.failed.push(classified.record);
+    }
+    return normalizeCommandEvidence(out);
+}
+function classifyCommandRecord(record) {
+    const statusText = normalized(record.status ?? record.result ?? record.outcome ?? record.state);
+    const exitCode = hasOwnKey(record, 'exitCode') ? numberValue(record.exitCode) : undefined;
+    const status = commandStatus(statusText, exitCode);
+    return { status, record: normalizedCommandRecord(record, status || undefined) ?? record };
+}
+function commandStatus(statusText, exitCode) {
+    if (['passed', 'pass', 'ok', 'success', 'succeeded', 'completed', 'green'].includes(statusText))
+        return 'passed';
+    if (['failed', 'fail', 'failure', 'error', 'errored', 'red', 'timeout', 'timed-out', 'blocked', 'nonzero'].includes(statusText))
+        return 'failed';
+    if (exitCode !== undefined)
+        return exitCode === 0 ? 'passed' : 'failed';
+    return '';
+}
+function normalizedCommandRecord(record, fallbackStatus) {
+    const command = textValue(record.command ?? record.cmd ?? record.name ?? record.label, '');
+    const cwd = textValue(record.cwd ?? record.dir, '');
+    const status = textValue(record.status ?? record.result ?? record.outcome ?? record.state, fallbackStatus ?? '');
+    if (!command && !cwd && !status)
+        return undefined;
+    return {
+        ...record,
+        ...(command && !record.command ? { command } : {}),
+        ...(cwd && !record.cwd ? { cwd } : {}),
+        ...(status && !record.status ? { status } : {})
+    };
+}
+function mergeCommandEvidence(...entries) {
+    return normalizeCommandEvidence({
+        passed: entries.flatMap((entry) => entry.passed),
+        failed: entries.flatMap((entry) => entry.failed)
+    });
+}
+function normalizeCommandEvidence(evidence) {
+    return {
+        passed: uniqueCommandRecords(evidence.passed),
+        failed: uniqueCommandRecords(evidence.failed)
+    };
+}
+function uniqueCommandRecords(records) {
+    const seen = new Set();
+    const out = [];
+    for (const record of records) {
+        const key = [
+            textValue(record.command ?? record.name, ''),
+            textValue(record.cwd, ''),
+            normalized(record.status ?? record.result ?? record.outcome)
+        ].join('\0');
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        out.push(record);
+    }
+    return out;
+}
+function emptyCommandEvidence() {
+    return { passed: [], failed: [] };
+}
+function hasOwnKey(record, key) {
+    return Object.prototype.hasOwnProperty.call(record, key);
+}
 function isProcessLive(pid, entry) {
     if (!pid)
         return false;
@@ -1164,28 +3063,116 @@ function processCommandMatchesPidManifest(command, entry) {
         return false;
     return true;
 }
-function optionsSafeCwd(runDir) {
-    return path.dirname(path.dirname(runDir));
-}
-async function readTaskDetails(options, jobId) {
+async function readTaskDetails(options, jobId, sourceRun = '') {
     if (!jobId)
         return { ok: false, jobId, files: [], commandsPassed: [], commandsFailed: [], evidenceArtifacts: [], error: 'missing job id' };
-    const entry = await findCollectionBundle(options, jobId);
+    const entry = await findCollectionBundle(options, jobId) ?? await findRawRunTaskBundle(options, jobId, sourceRun);
     if (!entry)
         return { ok: false, jobId, files: [], commandsPassed: [], commandsFailed: [], evidenceArtifacts: [], error: 'task not found in collection' };
     const { bundle, outputDir } = entry;
     const patchPath = textValue(bundle.patchPath, '');
     const evidencePaths = stringArray(bundle.evidencePaths).slice(0, 40);
+    const evidenceCommands = await commandEvidenceFromArtifactPaths(options.cwd, evidencePaths, outputDir);
+    const commandEvidence = mergeCommandEvidence(commandEvidenceFromRecords(bundle), evidenceCommands);
     return {
         ok: true,
         jobId,
         ...(patchPath ? { patchArtifact: artifactRecord(patchPath) } : {}),
         files: patchPath ? await readPatchFiles(options, patchPath) : [],
-        commandsPassed: recordArray(bundle.commandsPassed).slice(0, 20),
-        commandsFailed: recordArray(bundle.commandsFailed).slice(0, 20),
+        commandsPassed: commandEvidence.passed.slice(0, 20),
+        commandsFailed: commandEvidence.failed.slice(0, 20),
         evidenceArtifacts: evidencePaths.map((evidencePath) => artifactRecord(resolveRelativeArtifactPath(outputDir, evidencePath), evidencePath))
     };
 }
+async function findRawRunTaskBundle(options, jobId, sourceRun = '') {
+    const sourceRunRoot = sourceRun ? safeCwdRelativeDirectory(options.cwd, sourceRun) : undefined;
+    const hintedRoot = sourceRunRoot ?? rawRunSourceHint(options.cwd, jobId);
+    const root = hintedRoot ?? path.join(options.cwd, 'agent-runs');
+    const stat = await fs.stat(root).catch(() => undefined);
+    if (!stat?.isDirectory())
+        return undefined;
+    const matches = await findRawRunJobDirs(root, jobId, 0);
+    if (!matches.length)
+        return undefined;
+    const scoredMatches = await Promise.all(matches.map(async (match) => {
+        const patchPath = await firstExistingRelativePath(options.cwd, rawRunPatchCandidates(match));
+        const matchStat = await fs.stat(match).catch(() => undefined);
+        return { match, patchPath, mtimeMs: matchStat?.mtimeMs ?? 0 };
+    }));
+    scoredMatches.sort((left, right) => {
+        const patchScore = Number(Boolean(right.patchPath)) - Number(Boolean(left.patchPath));
+        if (patchScore)
+            return patchScore;
+        const timeScore = right.mtimeMs - left.mtimeMs;
+        if (timeScore)
+            return timeScore;
+        return right.match.localeCompare(left.match);
+    });
+    const { match, patchPath } = scoredMatches[0];
+    const evidencePaths = await existingRelativePaths(options.cwd, [
+        path.join(match, 'last-message.md'),
+        path.join(match, 'codex-events.jsonl'),
+        path.join(match, 'evidence', 'last-message.md'),
+        path.join(match, 'evidence', 'handoff.md'),
+        path.join(match, 'evidence', 'evidence.json'),
+        path.join(match, 'evidence', 'resource-allocation.json'),
+        ...rawRunPatchCandidates(match)
+    ]);
+    const evidenceCommands = await commandEvidenceFromArtifactPaths(options.cwd, evidencePaths);
+    return {
+        bundle: {
+            jobId: path.basename(match),
+            patchPath,
+            changedPaths: await readPatchChangedPathList(options.cwd, patchPath),
+            evidencePaths,
+            commandsPassed: evidenceCommands.passed,
+            commandsFailed: evidenceCommands.failed
+        }
+    };
+}
+function rawRunSourceHint(cwd, jobId) {
+    const match = /(?:^|:)(agent-runs\/[^:]+)/.exec(jobId);
+    if (!match)
+        return undefined;
+    const absolute = path.resolve(cwd, match[1]);
+    return isPathInside(cwd, absolute) ? absolute : undefined;
+}
+function safeCwdRelativeDirectory(cwd, input) {
+    const absolute = path.resolve(cwd, input);
+    if (!isPathInside(cwd, absolute))
+        return undefined;
+    return absolute;
+}
+async function findRawRunJobDirs(root, jobId, depth) {
+    if (depth > 5)
+        return [];
+    const entries = await fs.readdir(root, { withFileTypes: true }).catch(() => []);
+    const matches = [];
+    for (const entry of entries) {
+        if (!entry.isDirectory() || entry.name === 'streams' || entry.name === 'artifact-store' || entry.name.startsWith('.'))
+            continue;
+        const absolute = path.join(root, entry.name);
+        if (rawRunJobIdMatches(jobId, entry.name) && await rawRunJobHasArtifacts(absolute))
+            matches.push(absolute);
+        matches.push(...await findRawRunJobDirs(absolute, jobId, depth + 1));
+    }
+    return matches;
+}
+async function rawRunJobHasArtifacts(jobDir) {
+    for (const file of [
+        path.join(jobDir, 'last-message.md'),
+        path.join(jobDir, 'codex-events.jsonl'),
+        ...rawRunPatchCandidates(jobDir)
+    ]) {
+        const stat = await fs.stat(file).catch(() => undefined);
+        if (stat?.isFile())
+            return true;
+    }
+    return false;
+}
+function rawRunJobIdMatches(requestedId, jobId) {
+    return requestedId === jobId || requestedId.endsWith(`:${jobId}`) || requestedId.endsWith(`-${jobId}`);
+}
 async function findCollectionBundle(options, jobId) {
     const collectionFile = await resolveArtifactFile(options.cwd, options.collection, ['collection.json', 'coordinator-query.json']);
     if (!collectionFile)
@@ -1253,6 +3240,7 @@ async function writeHumanActionAnswer(options, body) {
     return { ok: true, code, answerPath };
 }
 function notifyDashboardStreams() {
+    invalidateDashboardSnapshotCache();
     for (const listener of dashboardStreamListeners)
         listener();
 }
@@ -1321,7 +3309,7 @@ async function readPatchFiles(options, patchPath) {
     return parseUnifiedPatchFiles(patch).slice(0, 40);
 }
 function parseUnifiedPatchFiles(patch) {
-    const sections = patch.split(/\n(?=diff --git )/g).filter((section) => section.trim().length > 0);
+    const sections = splitUnifiedPatchSections(patch);
     return sections.flatMap((section) => {
         const lines = section.split('\n');
         const pathLine = lines.find((line) => line.startsWith('+++ ')) ?? lines.find((line) => line.startsWith('diff --git '));
@@ -1343,6 +3331,27 @@ function parseUnifiedPatchFiles(patch) {
             }];
     });
 }
+function splitUnifiedPatchSections(patch) {
+    if (/^diff --git /m.test(patch)) {
+        return patch.split(/\n(?=diff --git )/g).filter((section) => section.trim().length > 0);
+    }
+    const lines = patch.split('\n');
+    const sections = [];
+    let current = [];
+    for (let index = 0; index < lines.length; index += 1) {
+        const line = lines[index];
+        const next = lines[index + 1] ?? '';
+        const startsPlainFile = line.startsWith('--- ') && next.startsWith('+++ ');
+        if (startsPlainFile && current.length) {
+            sections.push(current.join('\n'));
+            current = [];
+        }
+        current.push(line);
+    }
+    if (current.some((line) => line.trim().length > 0))
+        sections.push(current.join('\n'));
+    return sections;
+}
 function parseUnifiedPatchHunks(section) {
     const hunks = [];
     let current = { header: 'File header', lines: [] };
@@ -1384,9 +3393,20 @@ function parseUnifiedPatchHunks(section) {
 function patchFilePath(line) {
     const plus = /^\+\+\+\s+(?:b\/)?(.+)$/.exec(line);
     if (plus && plus[1] !== '/dev/null')
-        return plus[1];
+        return normalizePatchDisplayPath(plus[1]);
     const diff = /^diff --git\s+a\/(.+?)\s+b\/(.+)$/.exec(line);
-    return diff?.[2] ?? '';
+    return normalizePatchDisplayPath(diff?.[2] ?? '');
+}
+function normalizePatchDisplayPath(value) {
+    let clean = value.trim().split(/\t/g)[0]?.trim() ?? '';
+    clean = clean.replace(/^(?:a|b)\//, '');
+    const packageIndex = clean.indexOf('/packages/');
+    if (packageIndex >= 0)
+        clean = clean.slice(packageIndex + 1);
+    const repoPackageIndex = clean.indexOf('packages/');
+    if (repoPackageIndex > 0)
+        clean = clean.slice(repoPackageIndex);
+    return clean === '/dev/null' ? '' : clean;
 }
 function artifactRecord(pathValue, label = pathValue) {
     return {