@shapeshift-labs/frontier-loom-ui 0.1.0

package/dist/server.js

@@ -0,0 +1,1731 @@
+import { watch } from 'node:fs';
+import { spawn, spawnSync } from 'node:child_process';
+import fs from 'node:fs/promises';
+import http from 'node:http';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { 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;
+const TASK_DETAIL_FILE_DIFF_MAX_CHARS = 24_000;
+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 LIFETIME_DASHBOARD_MAX_JOBS = 800;
+const LIFETIME_DASHBOARD_SCAN_MAX_FILES = 600;
+const LIFETIME_DASHBOARD_SCAN_MAX_DEPTH = 5;
+const LIFETIME_DASHBOARD_RESET_FILE = '.loom-ui-reset.json';
+const REVIEW_DECISIONS_FILE = '.loom-ui-review-decisions.json';
+const dashboardStreamListeners = new Set();
+export function createLoomUiServer(options = {}) {
+    const normalized = normalizeServerOptions(options);
+    const server = http.createServer(async (request, response) => {
+        try {
+            await handleRequest(request, response, normalized);
+        }
+        catch (error) {
+            writeJson(response, 500, { ok: false, error: error instanceof Error ? error.message : String(error) });
+        }
+    });
+    return {
+        server,
+        close: () => new Promise((resolve, reject) => server.close((error) => error ? reject(error) : resolve()))
+    };
+}
+export async function startLoomUiServer(options = {}) {
+    const normalized = normalizeServerOptions(options);
+    const created = createLoomUiServer(normalized);
+    await new Promise((resolve, reject) => {
+        const onError = (error) => {
+            created.server.off('listening', onListening);
+            reject(error);
+        };
+        const onListening = () => {
+            created.server.off('error', onError);
+            resolve();
+        };
+        created.server.once('error', onError);
+        created.server.once('listening', onListening);
+        created.server.listen(normalized.port, normalized.host);
+    });
+    const address = created.server.address();
+    const actualPort = typeof address === 'object' && address ? address.port : normalized.port;
+    return { ...created, url: `http://${formatUrlHost(normalized.host)}:${actualPort}/` };
+}
+async function handleRequest(request, response, options) {
+    const url = new URL(request.url ?? '/', 'http://localhost');
+    if (request.method === 'GET' && url.pathname === '/api/health') {
+        writeJson(response, 200, await readHealth(options));
+    }
+    else if (request.method === 'GET' && url.pathname === '/api/dashboard/stream') {
+        await streamDashboard(request, response, options);
+    }
+    else if (request.method === 'GET' && url.pathname === '/api/dashboard') {
+        writeJson(response, 200, await readDashboardSnapshot(options));
+    }
+    else if (request.method === 'GET' && url.pathname === '/api/task-details') {
+        writeJson(response, 200, await readTaskDetails(options, textValue(url.searchParams.get('id'), '')));
+    }
+    else if (request.method === 'GET' && url.pathname === '/api/artifact') {
+        writeJson(response, 200, await readArtifact(options, textValue(url.searchParams.get('path'), '')));
+    }
+    else if (request.method === 'GET' && url.pathname === '/api/artifact/raw') {
+        await serveArtifactRaw(response, options, textValue(url.searchParams.get('path'), ''));
+    }
+    else if (request.method === 'POST' && url.pathname === '/api/artifact/reveal') {
+        const body = recordValue(await readJsonBody(request, 8 * 1024));
+        writeJson(response, 200, await revealArtifactInFileManager(options, textValue(body.path, ''), Boolean(body.dryRun)));
+    }
+    else if (request.method === 'POST' && url.pathname === '/api/human-actions/answer') {
+        const body = recordValue(await readJsonBody(request, HUMAN_ACTION_ANSWER_MAX_BYTES));
+        writeJson(response, 200, await writeHumanActionAnswer(options, body));
+    }
+    else if (request.method === 'GET' && url.pathname === '/client.js') {
+        await serveFile(response, path.join(packageDir, 'client.js'), 'application/javascript; charset=utf-8');
+    }
+    else if (request.method === 'GET' && url.pathname === '/vendor/frontier-dom/jsx-runtime.js') {
+        await serveFile(response, resolveFrontierDomRuntime(), 'application/javascript; charset=utf-8');
+    }
+    else if (request.method === 'GET') {
+        const file = staticFile(options.staticDir, url.pathname);
+        await serveFile(response, file, contentType(file));
+    }
+    else {
+        writeJson(response, 405, { ok: false, error: 'method not allowed' });
+    }
+}
+async function streamDashboard(request, response, options) {
+    response.writeHead(200, {
+        'content-type': 'text/event-stream; charset=utf-8',
+        'cache-control': 'no-store, max-age=0',
+        connection: 'keep-alive',
+        pragma: 'no-cache',
+        'x-accel-buffering': 'no'
+    });
+    response.write(': connected\n\n');
+    let closed = false;
+    let pending = false;
+    let lastSignature = '';
+    const send = async () => {
+        if (closed || pending)
+            return;
+        pending = true;
+        try {
+            const snapshot = await readDashboardSnapshot(options);
+            const signature = dashboardStreamSignature(snapshot);
+            const body = JSON.stringify(snapshot);
+            if (signature !== lastSignature) {
+                lastSignature = signature;
+                response.write(`data: ${body}\n\n`);
+            }
+        }
+        catch (error) {
+            response.write(`event: error\ndata: ${JSON.stringify({ ok: false, error: errorMessage(error) })}\n\n`);
+        }
+        finally {
+            pending = false;
+        }
+    };
+    const trigger = debounce(send, 120);
+    const directTrigger = () => {
+        void send();
+    };
+    const watchers = await createDashboardWatchers(options, trigger);
+    dashboardStreamListeners.add(directTrigger);
+    const tick = setInterval(trigger, 2000);
+    const heartbeat = setInterval(() => {
+        if (!closed)
+            response.write(': heartbeat\n\n');
+    }, 15000);
+    const close = () => {
+        if (closed)
+            return;
+        closed = true;
+        clearInterval(tick);
+        clearInterval(heartbeat);
+        dashboardStreamListeners.delete(directTrigger);
+        for (const watcher of watchers)
+            watcher.close();
+        response.end();
+    };
+    request.on('close', close);
+    response.on('close', close);
+    await send();
+}
+function dashboardStreamSignature(snapshot) {
+    if (!snapshot || typeof snapshot !== 'object' || Array.isArray(snapshot))
+        return JSON.stringify(snapshot);
+    const { generatedAt: _generatedAt, ...stableSnapshot } = snapshot;
+    return JSON.stringify(stableSnapshot);
+}
+function debounce(fn, delayMs) {
+    let timer;
+    return () => {
+        if (timer)
+            clearTimeout(timer);
+        timer = setTimeout(() => {
+            timer = undefined;
+            void fn();
+        }, delayMs);
+    };
+}
+async function createDashboardWatchers(options, onChange) {
+    const roots = await dashboardWatchRoots(options);
+    const watchers = [];
+    for (const root of roots) {
+        const recursive = watchDirectory(root, true, onChange);
+        if (recursive) {
+            watchers.push(recursive);
+            continue;
+        }
+        const shallow = watchDirectory(root, false, onChange);
+        if (shallow)
+            watchers.push(shallow);
+    }
+    return watchers;
+}
+function watchDirectory(root, recursive, onChange) {
+    try {
+        return watch(root, { recursive }, onChange);
+    }
+    catch {
+        return undefined;
+    }
+}
+async function dashboardWatchRoots(options) {
+    const inputs = [options.run, options.collection, options.continuation].filter((value) => Boolean(value));
+    const roots = [];
+    for (const input of inputs) {
+        const absolute = path.resolve(options.cwd, input);
+        const stat = await fs.lstat(absolute).catch(() => undefined);
+        if (!stat)
+            continue;
+        roots.push(stat.isDirectory() ? absolute : path.dirname(absolute));
+    }
+    if (!inputs.length) {
+        const agentRuns = path.join(options.cwd, 'agent-runs');
+        if (await fileExists(agentRuns))
+            roots.push(agentRuns);
+    }
+    return uniquePaths(roots);
+}
+function uniquePaths(values) {
+    return Array.from(new Set(values));
+}
+function normalizeServerOptions(options) {
+    return {
+        ...options,
+        cwd: path.resolve(options.cwd ?? process.cwd()),
+        host: options.host ?? '127.0.0.1',
+        port: normalizePort(options.port),
+        staticDir: path.resolve(options.staticDir ?? path.join(packageDir, 'public'))
+    };
+}
+function normalizePort(port) {
+    if (port === undefined)
+        return 0;
+    if (!Number.isInteger(port) || port < 0 || port > 65_535)
+        throw new Error(`invalid port: ${port}`);
+    return port;
+}
+function formatUrlHost(host) {
+    return host.includes(':') && !host.startsWith('[') ? `[${host}]` : host;
+}
+function dashboardInput(options) {
+    return {
+        cwd: options.cwd,
+        run: options.run,
+        collection: options.collection,
+        continuation: options.continuation
+    };
+}
+async function readDashboardSnapshot(options) {
+    if (!options.run && !options.collection && !options.continuation)
+        return readLifetimeDashboardSnapshot(options);
+    return readScopedDashboardSnapshot(options);
+}
+async function readScopedDashboardSnapshot(options) {
+    const snapshot = await readCodexDashboardSnapshot(dashboardInput(options));
+    const activeRunSnapshot = await readActiveRunSnapshot(options);
+    const reviewDecisions = await readCoordinatorReviewDecisions(options.cwd);
+    if (!snapshot || typeof snapshot !== 'object' || Array.isArray(snapshot))
+        return activeRunSnapshot ?? snapshot;
+    const answers = await readHumanActionAnswers(options);
+    const record = snapshot;
+    const jobs = Array.isArray(record.jobs) ? record.jobs : [];
+    const activeJobs = recordArray(activeRunSnapshot?.jobs);
+    if (shouldPreferActiveRunSnapshot(jobs, activeJobs)) {
+        return {
+            ...activeRunSnapshot,
+            collectionJobs: jobs,
+            humanActions: recordArray(record.humanActions),
+            humanActionAnswers: answers,
+            sources: {
+                ...recordValue(record.sources),
+                ...recordValue(activeRunSnapshot?.sources),
+                ...(reviewDecisions.length ? { coordinatorReviewDecisions: coordinatorReviewDecisionPath(options.cwd) } : {}),
+                ...(answers.length ? { humanActionAnswers: await humanActionAnswerLogPath(options) } : {})
+            },
+            raw: {
+                ...recordValue(activeRunSnapshot?.raw),
+                collectionSnapshot: {
+                    jobCount: jobs.length,
+                    humanActionCount: recordArray(record.humanActions).length,
+                    sourceCount: Object.keys(recordValue(record.sources)).length
+                }
+            }
+        };
+    }
+    const mergedJobs = applyCoordinatorReviewDecisions(mergeActiveRunJobTelemetry(jobs, activeJobs), reviewDecisions);
+    return {
+        ...normalizeCoordinatorFacingSnapshot(record),
+        jobs: mergedJobs,
+        humanActionAnswers: answers,
+        sources: {
+            ...recordValue(record.sources),
+            ...(reviewDecisions.length ? { coordinatorReviewDecisions: coordinatorReviewDecisionPath(options.cwd) } : {}),
+            ...(answers.length ? { humanActionAnswers: await humanActionAnswerLogPath(options) } : {})
+        }
+    };
+}
+async function readLifetimeDashboardSnapshot(options) {
+    const sources = await discoverLifetimeDashboardSources(options.cwd);
+    const snapshots = [];
+    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
+            }));
+            if (Object.keys(snapshot).length)
+                snapshots.push({ source, snapshot });
+        }
+        catch {
+            continue;
+        }
+    }
+    return combineLifetimeDashboardSnapshots(options, sources, snapshots, await readCoordinatorReviewDecisions(options.cwd));
+}
+async function discoverLifetimeDashboardSources(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 findLifetimeDashboardArtifactFiles(root, {
+        maxDepth: LIFETIME_DASHBOARD_SCAN_MAX_DEPTH,
+        maxFiles: LIFETIME_DASHBOARD_SCAN_MAX_FILES,
+        resetAt
+    });
+    const byDir = new Map();
+    for (const file of files) {
+        const dir = path.dirname(file);
+        const name = path.basename(file);
+        const fileStat = await fs.stat(file).catch(() => undefined);
+        const entry = byDir.get(dir) ?? { files: new Set(), mtimeMs: 0 };
+        entry.files.add(name);
+        entry.mtimeMs = Math.max(entry.mtimeMs, fileStat?.mtimeMs ?? 0);
+        byDir.set(dir, entry);
+    }
+    const out = [];
+    for (const [dir, entry] of byDir) {
+        if (entry.mtimeMs <= resetAt)
+            continue;
+        const relative = path.relative(cwd, dir);
+        if (!relative || relative.startsWith('..') || path.isAbsolute(relative))
+            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');
+        if (hasCollection) {
+            out.push({
+                id: `collection:${relative}`,
+                label: lifetimeSourceLabel(relative),
+                path: relative,
+                kind: 'collection',
+                mtimeMs: entry.mtimeMs,
+                collection: relative
+            });
+            continue;
+        }
+        if (hasContinuation) {
+            out.push({
+                id: `continuation:${relative}`,
+                label: lifetimeSourceLabel(relative),
+                path: relative,
+                kind: 'continuation',
+                mtimeMs: entry.mtimeMs,
+                continuation: relative
+            });
+            continue;
+        }
+        if (hasRun) {
+            out.push({
+                id: `run:${relative}`,
+                label: lifetimeSourceLabel(relative),
+                path: relative,
+                kind: 'run',
+                mtimeMs: entry.mtimeMs,
+                run: relative
+            });
+        }
+    }
+    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 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))
+            return false;
+        if (source.kind === 'collection' && source.path.endsWith('/collected-missing') && runs.has(family))
+            return false;
+        return true;
+    });
+}
+function lifetimeRunFamilyKey(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;
+    return parts[start] ?? source.path;
+}
+async function readLifetimeDashboardResetCutoff(root) {
+    const reset = recordValue(await readJsonFile(path.join(root, LIFETIME_DASHBOARD_RESET_FILE)));
+    return numberValue(reset.resetAt ?? reset.generatedAt);
+}
+async function findLifetimeDashboardArtifactFiles(root, input) {
+    const names = new Set(['swarm-results.json', 'pids.json', 'coordinator-dashboard.json', 'collection.json', 'coordinator-query.json', 'continuation.json']);
+    const skipDirs = new Set(['.git', 'node_modules', 'dist', 'coverage', 'evidence', 'streams', 'patch-scores', 'apply-ledger', 'artifact-index']);
+    const out = [];
+    async function walk(current, depth) {
+        if (out.length >= input.maxFiles || depth > input.maxDepth)
+            return;
+        const entries = await fs.readdir(current, { withFileTypes: true }).catch(() => []);
+        for (const entry of entries) {
+            if (out.length >= input.maxFiles)
+                return;
+            const absolute = path.join(current, entry.name);
+            if (entry.isDirectory()) {
+                if (skipDirs.has(entry.name) || entry.name.startsWith('.'))
+                    continue;
+                if (input.resetAt && depth === 0) {
+                    const dirStat = await fs.stat(absolute).catch(() => undefined);
+                    if ((dirStat?.mtimeMs ?? 0) <= input.resetAt)
+                        continue;
+                }
+                await walk(absolute, depth + 1);
+            }
+            else if (entry.isFile() && names.has(entry.name)) {
+                out.push(absolute);
+            }
+        }
+    }
+    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) => ({
+        ...event,
+        sourceLabel: source.label,
+        message: textValue(event.message, textValue(event.type, 'event')),
+        at: numberValue(event.at) || source.mtimeMs
+    }))).sort((left, right) => numberValue(left.at) - numberValue(right.at)).slice(-160);
+    return {
+        kind: 'frontier.loom-ui.lifetime-dashboard',
+        version: 1,
+        ok: snapshots.some(({ snapshot }) => Boolean(snapshot.ok)),
+        generatedAt: latestGeneratedAt,
+        cwd: options.cwd,
+        sources: {
+            workspace: options.cwd,
+            lifetimeRoot: path.join(options.cwd, 'agent-runs'),
+            sourceCount: discoveredSources.length,
+            loadedSourceCount: snapshots.length,
+            ...(reviewDecisions.length ? { coordinatorReviewDecisions: coordinatorReviewDecisionPath(options.cwd) } : {})
+        },
+        summary,
+        semantic: lifetimeSemanticSummary(jobs),
+        health: lifetimeHealthSummary(jobs),
+        quality: {},
+        timeSeries: lifetimeTimeSeries(jobs, events),
+        lanes: lifetimeLaneRows(jobs),
+        jobs,
+        humanActions: snapshots.flatMap(({ snapshot }) => recordArray(snapshot.humanActions)).slice(-100),
+        humanActionAnswers,
+        events,
+        routing: lifetimeRoutingSummary(snapshots.map((entry) => entry.snapshot)),
+        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)
+        },
+        raw: {
+            lifetime: {
+                mode: 'workspace',
+                sourceCount: discoveredSources.length,
+                loadedSourceCount: snapshots.length,
+                sources: discoveredSources.slice(0, LIFETIME_DASHBOARD_MAX_SOURCES)
+            }
+        }
+    };
+}
+function lifetimeScopedId(source, id) {
+    return `${source.id}:${id}`.replaceAll(/[^\w:.-]+/g, '-');
+}
+async function readCoordinatorReviewDecisions(cwd) {
+    const file = coordinatorReviewDecisionPath(cwd);
+    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.decisions ?? record.entries);
+}
+function coordinatorReviewDecisionPath(cwd) {
+    return path.join(cwd, 'agent-runs', REVIEW_DECISIONS_FILE);
+}
+function applyCoordinatorReviewDecisions(jobs, decisions) {
+    const records = jobs
+        .map(recordValue)
+        .filter((job) => Object.keys(job).length)
+        .map(normalizeCoordinatorFacingJob);
+    if (!decisions.length)
+        return records;
+    return records.map((record) => {
+        const decision = decisions.find((entry) => coordinatorReviewDecisionMatches(record, entry));
+        if (!decision)
+            return record;
+        const status = textValue(decision.status ?? decision.decision, 'resolved');
+        const resolved = isResolvedCoordinatorDecision(status);
+        return {
+            ...record,
+            coordinatorDecision: decision,
+            coordinatorDecisionStatus: status,
+            coordinatorDecisionAt: textValue(decision.decidedAt, ''),
+            reviewResolved: resolved,
+            ...(resolved && isCoordinatorPortBucket(record.bucket) ? { bucket: 'review-resolved' } : {}),
+            ...(resolved ? { disposition: status } : {})
+        };
+    });
+}
+function normalizeCoordinatorFacingJob(record) {
+    return {
+        ...record,
+        bucket: coordinatorFacingMachineLabel(record.bucket),
+        status: coordinatorFacingMachineLabel(record.status),
+        disposition: coordinatorFacingMachineLabel(record.disposition),
+        mergeReadiness: coordinatorFacingMachineLabel(record.mergeReadiness)
+    };
+}
+function normalizeCoordinatorFacingSnapshot(record) {
+    return {
+        ...record,
+        summary: normalizeCoordinatorFacingSummary(recordValue(record.summary))
+    };
+}
+function normalizeCoordinatorFacingSummary(summary) {
+    const out = {};
+    for (const [key, value] of Object.entries(summary)) {
+        if (key === 'bucketCounts') {
+            out.bucketCounts = normalizeCoordinatorFacingCountMap(recordValue(value));
+            continue;
+        }
+        const nextKey = coordinatorFacingMachineKey(key);
+        if (typeof value === 'number' && typeof out[nextKey] === 'number')
+            out[nextKey] = out[nextKey] + value;
+        else
+            out[nextKey] = value;
+    }
+    const coordinatorReview = numberValue(out['needs-coordinator-review']);
+    if (coordinatorReview && out.needsCoordinatorReviewCount === undefined)
+        out.needsCoordinatorReviewCount = coordinatorReview;
+    return out;
+}
+function normalizeCoordinatorFacingCountMap(input) {
+    const out = {};
+    for (const [key, value] of Object.entries(input)) {
+        const nextKey = coordinatorFacingMachineKey(key);
+        if (typeof value === 'number' && typeof out[nextKey] === 'number')
+            out[nextKey] = out[nextKey] + value;
+        else
+            out[nextKey] = value;
+    }
+    return out;
+}
+function isCoordinatorPortBucket(value) {
+    const bucket = normalized(value);
+    return bucket === 'needs-human-port'
+        || bucket === 'needs-human-review'
+        || bucket === 'needs-human-decision'
+        || bucket === 'needs-coordinator-port'
+        || bucket === 'needs-coordinator-review'
+        || bucket === 'needs-coordinator-decision';
+}
+function coordinatorFacingMachineKey(value) {
+    return textValue(coordinatorFacingMachineLabel(value), value);
+}
+function coordinatorFacingMachineLabel(value) {
+    const raw = textValue(value, '');
+    const current = normalized(raw);
+    if (current === 'needs-human-port')
+        return 'needs-coordinator-review';
+    if (current === 'needs-coordinator-port')
+        return 'needs-coordinator-review';
+    if (current === 'needs-human-review')
+        return 'needs-coordinator-review';
+    if (current === 'needs-human-decision')
+        return 'needs-coordinator-decision';
+    if (current === 'needshumancount')
+        return 'needsCoordinatorReviewCount';
+    if (current === 'needshumanportcount')
+        return 'needsCoordinatorReviewCount';
+    if (current === 'needscoordinatorportcount')
+        return 'needsCoordinatorReviewCount';
+    return value;
+}
+function coordinatorReviewDecisionMatches(job, decision) {
+    const decisionIds = coordinatorDecisionIds(decision);
+    if (!decisionIds.length)
+        return false;
+    const jobIds = coordinatorDecisionIds(job);
+    const idMatches = decisionIds.some((id) => jobIds.includes(id) || jobIds.includes(sanitizeDecisionId(id)));
+    if (!idMatches)
+        return false;
+    const decisionSource = textValue(decision.source ?? decision.sourceCollection ?? decision.sourceRun ?? decision.sourceLabel, '');
+    if (!decisionSource)
+        return true;
+    const jobSources = [
+        textValue(job.sourceLabel, ''),
+        textValue(job.sourceCollection, ''),
+        textValue(job.sourceRun, ''),
+        textValue(job.sourceContinuation, '')
+    ].filter(Boolean);
+    return jobSources.some((source) => source === decisionSource || source.endsWith(decisionSource) || decisionSource.endsWith(source));
+}
+function coordinatorDecisionIds(record) {
+    return Array.from(new Set([
+        textValue(record.id, ''),
+        textValue(record.originalJobId, ''),
+        textValue(record.jobId, ''),
+        textValue(record.taskId, ''),
+        ...stringArray(record.matchIds)
+    ].filter(Boolean).flatMap((id) => [id, sanitizeDecisionId(id)])));
+}
+function sanitizeDecisionId(value) {
+    return value.replaceAll(/[^\w:.-]+/g, '-');
+}
+function isResolvedCoordinatorDecision(status) {
+    const value = normalized(status);
+    return Boolean(value) && !['open', 'pending', 'deferred', 'needs-review'].includes(value);
+}
+function lifetimeSourceLabel(relative) {
+    const parts = relative.split(/[\\/]/g).filter(Boolean);
+    return parts.slice(-3).join('/');
+}
+function lifetimeDashboardSummary(jobs) {
+    const completedCount = jobs.filter((job) => textValue(job.status, '').toLowerCase() === 'completed').length;
+    const failedCount = jobs.filter((job) => isLifetimeFailedJob(job)).length;
+    const blockedCount = jobs.filter((job) => textValue(job.status, '').toLowerCase() === 'blocked').length;
+    const runningCount = jobs.filter((job) => textValue(job.status, '').toLowerCase() === 'running').length;
+    const terminalCount = jobs.filter((job) => ['completed', 'failed', 'blocked'].includes(textValue(job.status, '').toLowerCase())).length;
+    const durationMs = jobs.reduce((sum, job) => sum + numberValue(job.durationMs), 0);
+    return {
+        jobCount: jobs.length,
+        completedCount,
+        failedCount,
+        runningCount,
+        blockedCount,
+        changedPathCount: jobs.reduce((sum, job) => sum + numberValue(job.changedPathCount), 0),
+        ownershipViolationCount: jobs.reduce((sum, job) => sum + numberValue(job.ownershipViolationCount), 0),
+        sourceOwnershipViolationCount: jobs.reduce((sum, job) => sum + numberValue(job.sourceOwnershipViolationCount), 0),
+        ignoredOwnershipViolationCount: jobs.reduce((sum, job) => sum + numberValue(job.ignoredOwnershipViolationCount), 0),
+        quarantinedChangedPathCount: jobs.reduce((sum, job) => sum + numberValue(job.quarantinedChangedPathCount), 0),
+        ignoredChangedPathCount: jobs.reduce((sum, job) => sum + numberValue(job.ignoredChangedPathCount), 0),
+        terminalCount,
+        failureCount: failedCount + blockedCount,
+        warningCount: jobs.filter((job) => textValue(job.health, '') === 'warning').length,
+        contextWarningCount: jobs.filter((job) => numberValue(job.contextBudgetWarningCount) > 0).length,
+        contextFailedCount: jobs.filter((job) => numberValue(job.contextBudgetErrorCount) > 0).length,
+        semanticCleanCount: jobs.filter((job) => textValue(job.semanticReadiness, '') === 'clean').length,
+        semanticCandidateCount: jobs.filter((job) => textValue(job.semanticReadiness, '') === 'candidate').length,
+        semanticBlockedCount: jobs.filter((job) => textValue(job.semanticReadiness, '') === 'blocked').length,
+        durationMs,
+        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),
+        cachedInputTokens: jobs.reduce((sum, job) => sum + numberValue(job.cachedInputTokens), 0),
+        uncachedInputTokens: jobs.reduce((sum, job) => sum + numberValue(job.uncachedInputTokens), 0)
+    };
+}
+function lifetimeHealthSummary(jobs) {
+    const summary = lifetimeDashboardSummary(jobs);
+    const failedJobCount = numberValue(summary.failedCount);
+    const blockedJobCount = numberValue(summary.blockedCount);
+    const runningJobCount = numberValue(summary.runningCount);
+    const warningJobCount = jobs.filter((job) => textValue(job.health, '') === 'warning').length;
+    const status = failedJobCount || blockedJobCount ? 'failed' : runningJobCount ? 'running' : warningJobCount ? 'warning' : jobs.length ? 'healthy' : 'unknown';
+    return {
+        status,
+        summary: {
+            jobCount: jobs.length,
+            healthyJobCount: Math.max(0, jobs.length - failedJobCount - blockedJobCount - warningJobCount),
+            warningJobCount,
+            failedJobCount,
+            blockedJobCount,
+            runningJobCount,
+            terminalJobCount: numberValue(summary.terminalCount),
+            readyToApplyJobCount: jobs.filter((job) => textValue(job.bucket, '') === 'ready-to-apply').length,
+            contextWarningJobCount: numberValue(summary.contextWarningCount),
+            semanticCleanJobCount: numberValue(summary.semanticCleanCount),
+            semanticCandidateJobCount: numberValue(summary.semanticCandidateCount),
+            completionRatio: jobs.length ? numberValue(summary.terminalCount) / jobs.length : 0,
+            failureRatio: jobs.length ? (failedJobCount + blockedJobCount) / jobs.length : 0
+        }
+    };
+}
+function lifetimeLaneRows(jobs) {
+    const byLane = new Map();
+    for (const job of jobs) {
+        const lane = textValue(job.lane, 'workspace');
+        byLane.set(lane, [...(byLane.get(lane) ?? []), job]);
+    }
+    return Array.from(byLane.entries()).map(([id, entries]) => ({
+        id,
+        jobCount: entries.length,
+        completedCount: entries.filter((job) => textValue(job.status, '') === 'completed').length,
+        failedCount: entries.filter(isLifetimeFailedJob).length,
+        runningCount: entries.filter((job) => textValue(job.status, '') === 'running').length
+    }));
+}
+function lifetimeTimeSeries(jobs, events) {
+    const bucketMs = 24 * 60 * 60 * 1000;
+    const buckets = new Map();
+    for (const job of jobs) {
+        const at = numberValue(job.finishedAt) || numberValue(job.generatedAt) || numberValue(job.startedAt);
+        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 };
+        if (['completed', 'failed', 'blocked'].includes(textValue(job.status, '').toLowerCase()))
+            bucket.terminalJobCount += 1;
+        if (textValue(job.health, '') === 'warning')
+            bucket.warningJobCount += 1;
+        if (isLifetimeFailedJob(job))
+            bucket.failureJobCount += 1;
+        bucket.durationMs += numberValue(job.durationMs);
+        bucket.actualInputTokens += numberValue(job.actualInputTokens);
+        bucket.uncachedInputTokens += numberValue(job.uncachedInputTokens);
+        buckets.set(bucketAt, bucket);
+    }
+    for (const event of events) {
+        const at = numberValue(event.at);
+        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 };
+        bucket.eventCount += 1;
+        buckets.set(bucketAt, bucket);
+    }
+    const points = Array.from(buckets.values()).sort((left, right) => left.at - right.at);
+    return {
+        bucketMs,
+        points,
+        summary: {
+            pointCount: points.length,
+            terminalJobCount: points.reduce((sum, point) => sum + point.terminalJobCount, 0),
+            warningJobCount: points.reduce((sum, point) => sum + point.warningJobCount, 0),
+            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),
+            uncachedInputTokens: points.reduce((sum, point) => sum + point.uncachedInputTokens, 0),
+            missingTimestampJobCount: jobs.filter((job) => !numberValue(job.finishedAt) && !numberValue(job.generatedAt) && !numberValue(job.startedAt)).length
+        }
+    };
+}
+function startOfLocalDay(value) {
+    const date = new Date(value);
+    return new Date(date.getFullYear(), date.getMonth(), date.getDate()).getTime();
+}
+function lifetimeSemanticSummary(jobs) {
+    return {
+        expected: jobs.length,
+        satisfied: jobs.filter((job) => textValue(job.semanticReadiness, '') === 'clean').length,
+        autoMerge: jobs.filter((job) => Boolean(job.semanticAutoMergeCandidate)).length,
+        acceptedClean: jobs.filter((job) => textValue(job.semanticReadiness, '') === 'clean').length,
+        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)
+        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)
+    };
+}
+function isLifetimeFailedJob(job) {
+    const status = textValue(job.status, '').toLowerCase();
+    const health = textValue(job.health, '').toLowerCase();
+    const bucket = textValue(job.bucket, '').toLowerCase();
+    return status === 'failed' || health === 'failed' || bucket === 'failed-evidence';
+}
+function awaitNoop(value) {
+    return value;
+}
+function shouldPreferActiveRunSnapshot(jobs, activeJobs) {
+    if (!activeJobs.length)
+        return false;
+    const runningCount = activeJobs.filter((job) => textValue(job.status, '') === 'running').length;
+    if (runningCount > 0)
+        return true;
+    return activeJobs.length > jobs.length;
+}
+async function readActiveRunSnapshot(options) {
+    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');
+    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 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 cachedInputTokens = jobs.reduce((sum, job) => sum + numberValue(job.cachedInputTokens), 0);
+    return {
+        ok: true,
+        generatedAt: now,
+        cwd: options.cwd,
+        summary: {
+            jobCount: jobs.length,
+            completedCount,
+            failedCount,
+            runningCount,
+            blockedCount: 0,
+            actualInputTokens,
+            cachedInputTokens,
+            uncachedInputTokens: Math.max(0, actualInputTokens - cachedInputTokens),
+            durationMs: jobs.reduce((sum, job) => Math.max(sum, numberValue(job.durationMs)), 0),
+            bucketCounts: {
+                total: jobs.length,
+                running: runningCount,
+                completed: completedCount,
+                'failed-evidence': failedCount
+            }
+        },
+        lanes: activeRunLanes(jobs),
+        jobs,
+        events: activeRunEvents(jobs),
+        sources: {
+            run: runDir,
+            activeRun: pidPath,
+            plan: planPath
+        },
+        raw: {
+            activeRun: {
+                runId: textValue(pidManifest.runId, ''),
+                launchedCount: entries.length,
+                runningCount
+            }
+        }
+    };
+}
+async function activeRunJob(runDir, entry, planJob, now) {
+    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 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 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 task = recordValue(planJob?.task);
+    const compute = recordValue(planJob?.compute);
+    const changedPaths = stringArray(merge.changedPaths);
+    return {
+        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,
+        agentId: jobId,
+        workerId: jobId,
+        model: textValue(compute.model, ''),
+        computeId: textValue(compute.id, ''),
+        reasoningEffort: textValue(compute.reasoningEffort, ''),
+        startedAt: startedAt || undefined,
+        ...(finishedAt ? { finishedAt } : {}),
+        durationMs: startedAt ? Math.max(0, (finishedAt ?? now) - startedAt) : 0,
+        ...(usage.inputTokens ? { actualInputTokens: usage.inputTokens, inputTokens: usage.inputTokens } : {}),
+        ...(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: {
+                input_tokens: usage.inputTokens,
+                cached_input_tokens: usage.cachedInputTokens,
+                uncached_input_tokens: usage.uncachedInputTokens,
+                output_tokens: usage.outputTokens,
+                reasoning_output_tokens: usage.reasoningOutputTokens,
+                source: 'codex-events.jsonl',
+                event_count: usage.eventCount
+            }
+        } : {}),
+        changedPaths,
+        changedPathCount: changedPaths.length || numberValue(merge.changedPathCount),
+        evidencePaths,
+        evidencePathCount: evidencePaths.length,
+        commandsPassed: recordArray(merge.commandsPassed),
+        commandsFailed: recordArray(merge.commandsFailed),
+        collectReasonClasses: status === 'running' ? ['active worker'] : [],
+        mergeReadiness: textValue(merge.mergeReadiness, status)
+    };
+}
+function activeRunLanes(jobs) {
+    const byLane = new Map();
+    for (const job of jobs) {
+        const lane = textValue(job.lane, 'active-run');
+        byLane.set(lane, [...(byLane.get(lane) ?? []), job]);
+    }
+    return Array.from(byLane.entries()).map(([id, entries]) => ({
+        id,
+        jobCount: entries.length,
+        runningCount: entries.filter((job) => textValue(job.status, '') === 'running').length,
+        completedCount: entries.filter((job) => textValue(job.status, '') === 'completed').length,
+        failedCount: entries.filter((job) => textValue(job.status, '') === 'failed').length,
+        blockedCount: 0,
+        evidenceCount: entries.reduce((sum, job) => sum + numberValue(job.evidencePathCount), 0)
+    }));
+}
+function activeRunEvents(jobs) {
+    return jobs.map((job) => ({
+        at: numberValue(job.startedAt) || Date.now(),
+        type: textValue(job.status, '') === 'running' ? 'worker.started' : 'worker.finished',
+        lane: textValue(job.lane, ''),
+        jobId: textValue(job.id, ''),
+        message: `${textValue(job.title, 'worker')} ${textValue(job.status, 'running')}`
+    }));
+}
+function mergeActiveRunJobTelemetry(jobs, activeJobs) {
+    if (!activeJobs.length)
+        return jobs;
+    const byKey = new Map();
+    for (const activeJob of activeJobs) {
+        if (!hasTokenTelemetry(activeJob))
+            continue;
+        for (const key of jobTelemetryKeys(activeJob))
+            byKey.set(key, activeJob);
+    }
+    if (!byKey.size)
+        return jobs;
+    return jobs.map((job) => {
+        const record = recordValue(job);
+        if (!Object.keys(record).length)
+            return job;
+        const activeJob = jobTelemetryKeys(record).map((key) => byKey.get(key)).find(Boolean);
+        if (!activeJob)
+            return record;
+        return {
+            ...record,
+            ...(numberValue(activeJob.actualInputTokens) ? { actualInputTokens: numberValue(activeJob.actualInputTokens) } : {}),
+            ...(numberValue(activeJob.inputTokens) ? { inputTokens: numberValue(activeJob.inputTokens) } : {}),
+            ...(numberValue(activeJob.cachedInputTokens) ? { cachedInputTokens: numberValue(activeJob.cachedInputTokens) } : {}),
+            ...(numberValue(activeJob.uncachedInputTokens) ? { uncachedInputTokens: numberValue(activeJob.uncachedInputTokens) } : {}),
+            ...(numberValue(activeJob.actualOutputTokens) ? { actualOutputTokens: numberValue(activeJob.actualOutputTokens) } : {}),
+            ...(numberValue(activeJob.outputTokens) ? { outputTokens: numberValue(activeJob.outputTokens) } : {}),
+            ...(numberValue(activeJob.reasoningOutputTokens) ? { reasoningOutputTokens: numberValue(activeJob.reasoningOutputTokens) } : {}),
+            usage: {
+                ...recordValue(record.usage),
+                ...recordValue(activeJob.usage)
+            }
+        };
+    });
+}
+function jobTelemetryKeys(job) {
+    return Array.from(new Set([
+        textValue(job.id, ''),
+        textValue(job.jobId, ''),
+        textValue(job.taskId, ''),
+        textValue(job.workerId, ''),
+        textValue(job.agentId, '')
+    ].filter(Boolean)));
+}
+function hasTokenTelemetry(job) {
+    return numberValue(job.actualInputTokens)
+        + numberValue(job.inputTokens)
+        + numberValue(job.cachedInputTokens)
+        + numberValue(job.uncachedInputTokens)
+        + numberValue(job.outputTokens)
+        + numberValue(job.actualOutputTokens) > 0;
+}
+async function readCodexEventUsageSummary(file) {
+    const empty = emptyCodexEventUsageSummary();
+    const stat = await fs.stat(file).catch(() => undefined);
+    if (!stat?.isFile() || stat.size > CODEX_EVENTS_USAGE_MAX_BYTES)
+        return empty;
+    const text = await fs.readFile(file, 'utf8').catch(() => '');
+    if (!text)
+        return empty;
+    const summary = emptyCodexEventUsageSummary();
+    for (const line of text.split(/\r?\n/g)) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        let event;
+        try {
+            event = JSON.parse(trimmed);
+        }
+        catch {
+            continue;
+        }
+        const usages = collectCodexUsageRecords(event);
+        for (const usage of usages) {
+            const normalized = normalizeCodexUsageRecord(usage);
+            if (!hasCodexUsageValues(normalized))
+                continue;
+            summary.eventCount += 1;
+            summary.inputTokens = Math.max(summary.inputTokens, normalized.inputTokens);
+            summary.cachedInputTokens = Math.max(summary.cachedInputTokens, normalized.cachedInputTokens);
+            summary.uncachedInputTokens = Math.max(summary.uncachedInputTokens, normalized.uncachedInputTokens);
+            summary.outputTokens = Math.max(summary.outputTokens, normalized.outputTokens);
+            summary.reasoningOutputTokens = Math.max(summary.reasoningOutputTokens, normalized.reasoningOutputTokens);
+        }
+    }
+    if (summary.inputTokens && !summary.uncachedInputTokens) {
+        summary.uncachedInputTokens = Math.max(0, summary.inputTokens - summary.cachedInputTokens);
+    }
+    return summary;
+}
+function emptyCodexEventUsageSummary() {
+    return {
+        inputTokens: 0,
+        cachedInputTokens: 0,
+        uncachedInputTokens: 0,
+        outputTokens: 0,
+        reasoningOutputTokens: 0,
+        eventCount: 0
+    };
+}
+function collectCodexUsageRecords(value, depth = 0) {
+    if (depth > 5 || !value || typeof value !== 'object')
+        return [];
+    if (Array.isArray(value)) {
+        return value.flatMap((entry) => collectCodexUsageRecords(entry, depth + 1));
+    }
+    const record = value;
+    const records = [];
+    if (looksLikeCodexUsageRecord(record))
+        records.push(record);
+    for (const key of ['usage', 'tokenUsage', 'token_usage', 'openaiUsage', 'openAIUsage']) {
+        records.push(...collectCodexUsageRecords(record[key], depth + 1));
+    }
+    for (const [key, child] of Object.entries(record)) {
+        if (['usage', 'tokenUsage', 'token_usage', 'openaiUsage', 'openAIUsage'].includes(key))
+            continue;
+        if (child && typeof child === 'object')
+            records.push(...collectCodexUsageRecords(child, depth + 1));
+    }
+    return records;
+}
+function looksLikeCodexUsageRecord(record) {
+    return firstPositiveTokenNumber(record.input_tokens, record.prompt_tokens, record.cached_input_tokens, record.cached_prompt_tokens, record.output_tokens, record.completion_tokens, record.reasoning_output_tokens) > 0;
+}
+function normalizeCodexUsageRecord(record) {
+    const inputTokens = firstPositiveTokenNumber(record.input_tokens, record.prompt_tokens, record.inputTokens, record.promptTokens);
+    const cachedInputTokens = Math.min(inputTokens || Number.MAX_SAFE_INTEGER, firstPositiveTokenNumber(record.cached_input_tokens, record.cached_prompt_tokens, record.cached_tokens, record.cachedInputTokens, record.cachedPromptTokens));
+    const uncachedInputTokens = firstPositiveTokenNumber(record.uncached_input_tokens, record.uncachedInputTokens)
+        || (inputTokens ? Math.max(0, inputTokens - cachedInputTokens) : 0);
+    const outputTokens = firstPositiveTokenNumber(record.output_tokens, record.completion_tokens, record.response_tokens, record.generated_tokens, record.outputTokens, record.completionTokens);
+    const outputDetails = recordValue(record.output_tokens_details ?? record.completion_tokens_details ?? record.outputTokensDetails);
+    const reasoningOutputTokens = firstPositiveTokenNumber(record.reasoning_output_tokens, record.reasoning_tokens, record.reasoningOutputTokens, outputDetails.reasoning_tokens, outputDetails.reasoningTokens);
+    return {
+        inputTokens,
+        cachedInputTokens: cachedInputTokens === Number.MAX_SAFE_INTEGER ? 0 : cachedInputTokens,
+        uncachedInputTokens,
+        outputTokens,
+        reasoningOutputTokens,
+        eventCount: hasCodexUsageValues({ inputTokens, cachedInputTokens, uncachedInputTokens, outputTokens, reasoningOutputTokens, eventCount: 0 }) ? 1 : 0
+    };
+}
+function hasCodexUsageValues(usage) {
+    return usage.inputTokens + usage.cachedInputTokens + usage.uncachedInputTokens + usage.outputTokens + usage.reasoningOutputTokens > 0;
+}
+function firstPositiveTokenNumber(...values) {
+    for (const value of values) {
+        const number = numberValue(value);
+        if (number > 0)
+            return number;
+    }
+    return 0;
+}
+async function resolveRunDirectory(options) {
+    if (!options.run)
+        return undefined;
+    const absolute = path.resolve(options.cwd, options.run);
+    if (!isPathInside(options.cwd, absolute))
+        return undefined;
+    const stat = await fs.lstat(absolute).catch(() => undefined);
+    if (!stat)
+        return undefined;
+    return stat.isDirectory() ? absolute : path.dirname(absolute);
+}
+async function readJsonFile(file) {
+    try {
+        return JSON.parse(await fs.readFile(file, 'utf8'));
+    }
+    catch {
+        return undefined;
+    }
+}
+function isProcessLive(pid, entry) {
+    if (!pid)
+        return false;
+    try {
+        process.kill(pid, 0);
+        if (process.platform !== 'win32') {
+            const status = spawnSync('ps', ['-o', 'stat=', '-p', String(pid)], {
+                encoding: 'utf8',
+                stdio: ['ignore', 'pipe', 'ignore']
+            });
+            const stat = status.stdout.trim();
+            if (stat.startsWith('Z'))
+                return false;
+            const commandResult = spawnSync('ps', ['-o', 'command=', '-p', String(pid)], {
+                encoding: 'utf8',
+                stdio: ['ignore', 'pipe', 'ignore']
+            });
+            const command = commandResult.stdout.trim();
+            if (!processCommandMatchesPidManifest(command, entry))
+                return false;
+        }
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function processCommandMatchesPidManifest(command, entry) {
+    if (!entry)
+        return true;
+    const role = textValue(entry.role, '');
+    const jobId = textValue(entry.jobId, '');
+    const expected = stringArray(entry.command).join(' ');
+    if (role === 'codex' && !/\bcodex\b|Codex\.app/i.test(command))
+        return false;
+    if (jobId && !command.includes(jobId))
+        return false;
+    if (expected && expected.includes('codex') && !/\bcodex\b|Codex\.app/i.test(command))
+        return false;
+    return true;
+}
+function optionsSafeCwd(runDir) {
+    return path.dirname(path.dirname(runDir));
+}
+async function readTaskDetails(options, jobId) {
+    if (!jobId)
+        return { ok: false, jobId, files: [], commandsPassed: [], commandsFailed: [], evidenceArtifacts: [], error: 'missing job id' };
+    const entry = await findCollectionBundle(options, jobId);
+    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);
+    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),
+        evidenceArtifacts: evidencePaths.map((evidencePath) => artifactRecord(resolveRelativeArtifactPath(outputDir, evidencePath), evidencePath))
+    };
+}
+async function findCollectionBundle(options, jobId) {
+    const collectionFile = await resolveArtifactFile(options.cwd, options.collection, ['collection.json', 'coordinator-query.json']);
+    if (!collectionFile)
+        return undefined;
+    const collection = JSON.parse(await fs.readFile(collectionFile, 'utf8'));
+    const buckets = recordValue(collection.buckets);
+    for (const entries of Object.values(buckets)) {
+        if (!Array.isArray(entries))
+            continue;
+        for (const entry of entries) {
+            const row = recordValue(entry);
+            const bundle = recordValue(row.bundle);
+            if (textValue(row.jobId, '') === jobId || textValue(bundle.jobId, '') === jobId) {
+                return { bundle, outputDir: textValue(row.outputDir, '') };
+            }
+        }
+    }
+    const jobs = Array.isArray(collection.jobs) ? collection.jobs : [];
+    for (const job of jobs) {
+        const row = recordValue(job);
+        if (textValue(row.id ?? row.jobId, '') === jobId)
+            return { bundle: row, outputDir: textValue(row.outputDir, '') };
+    }
+    return undefined;
+}
+async function resolveArtifactFile(cwd, input, names) {
+    if (!input)
+        return undefined;
+    const absolute = path.resolve(cwd, input);
+    const stat = await fs.lstat(absolute).catch(() => undefined);
+    if (!stat)
+        return undefined;
+    if (!isPathInside(cwd, absolute))
+        return undefined;
+    if (!stat.isDirectory())
+        return absolute;
+    for (const name of names) {
+        const candidate = path.join(absolute, name);
+        const candidateStat = await fs.stat(candidate).catch(() => undefined);
+        if (candidateStat?.isFile())
+            return candidate;
+    }
+    return undefined;
+}
+async function writeHumanActionAnswer(options, body) {
+    const code = textValue(body.code, '').trim();
+    const answer = textValue(body.answer, '').trim();
+    if (!code)
+        return { ok: false, code, error: 'missing question code' };
+    if (!answer)
+        return { ok: false, code, error: 'missing answer' };
+    if (answer.length > HUMAN_ACTION_ANSWER_MAX_BYTES)
+        return { ok: false, code, error: 'answer is too large' };
+    const answerPath = await humanActionAnswerLogPath(options);
+    await fs.mkdir(path.dirname(answerPath), { recursive: true });
+    const record = {
+        type: 'human-action.answer',
+        at: Date.now(),
+        code,
+        answer,
+        source: 'frontier-loom-ui'
+    };
+    await fs.appendFile(answerPath, JSON.stringify(record) + '\n', 'utf8');
+    notifyDashboardStreams();
+    return { ok: true, code, answerPath };
+}
+function notifyDashboardStreams() {
+    for (const listener of dashboardStreamListeners)
+        listener();
+}
+async function readHumanActionAnswers(options) {
+    const answerPath = await humanActionAnswerLogPath(options);
+    const body = await fs.readFile(answerPath, 'utf8').catch(() => '');
+    if (!body.trim())
+        return [];
+    const rows = [];
+    for (const line of body.split(/\r?\n/)) {
+        if (!line.trim())
+            continue;
+        try {
+            const record = recordValue(JSON.parse(line));
+            const code = textValue(record.code, '').trim();
+            const answer = textValue(record.answer, '').trim();
+            const at = Number(record.at);
+            if (!code || !answer || !Number.isFinite(at))
+                continue;
+            rows.push({
+                type: 'human-action.answer',
+                at,
+                code,
+                answer,
+                source: 'frontier-loom-ui'
+            });
+        }
+        catch {
+            continue;
+        }
+    }
+    return rows
+        .sort((left, right) => left.at - right.at)
+        .slice(-200);
+}
+async function humanActionAnswerLogPath(options) {
+    return path.join(await humanActionAnswerDir(options), 'human-action-answers.jsonl');
+}
+async function humanActionAnswerDir(options) {
+    if (options.run) {
+        const absolute = path.resolve(options.cwd, options.run);
+        const stat = await fs.lstat(absolute).catch(() => undefined);
+        if (stat?.isDirectory())
+            return absolute;
+        if (stat)
+            return path.dirname(absolute);
+    }
+    if (options.collection) {
+        const absolute = path.resolve(options.cwd, options.collection);
+        const stat = await fs.lstat(absolute).catch(() => undefined);
+        if (stat?.isDirectory())
+            return absolute;
+        if (stat)
+            return path.dirname(absolute);
+    }
+    return path.join(options.cwd, 'agent-runs', 'loom-ui-human-actions');
+}
+async function readPatchFiles(options, patchPath) {
+    const absolute = path.resolve(options.cwd, patchPath);
+    if (!isPathInside(options.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 parseUnifiedPatchFiles(patch).slice(0, 40);
+}
+function parseUnifiedPatchFiles(patch) {
+    const sections = patch.split(/\n(?=diff --git )/g).filter((section) => section.trim().length > 0);
+    return sections.flatMap((section) => {
+        const lines = section.split('\n');
+        const pathLine = lines.find((line) => line.startsWith('+++ ')) ?? lines.find((line) => line.startsWith('diff --git '));
+        const filePath = patchFilePath(pathLine ?? '');
+        if (!filePath)
+            return [];
+        const additions = lines.filter((line) => line.startsWith('+') && !line.startsWith('+++')).length;
+        const deletions = lines.filter((line) => line.startsWith('-') && !line.startsWith('---')).length;
+        const truncated = section.length > TASK_DETAIL_FILE_DIFF_MAX_CHARS;
+        return [{
+                path: filePath,
+                additions,
+                deletions,
+                diff: truncated ? `${section.slice(0, TASK_DETAIL_FILE_DIFF_MAX_CHARS)}\n... truncated ...` : section,
+                language: languageForPath(filePath),
+                artifactPath: filePath,
+                hunks: parseUnifiedPatchHunks(truncated ? section.slice(0, TASK_DETAIL_FILE_DIFF_MAX_CHARS) : section),
+                truncated
+            }];
+    });
+}
+function parseUnifiedPatchHunks(section) {
+    const hunks = [];
+    let current = { header: 'File header', lines: [] };
+    let oldLine = 0;
+    let newLine = 0;
+    for (const line of section.split('\n')) {
+        const hunk = /^@@\s+-(\d+)(?:,\d+)?\s+\+(\d+)(?:,\d+)?\s+@@(.*)$/.exec(line);
+        if (hunk) {
+            if (current.lines.length)
+                hunks.push(current);
+            current = { header: line, lines: [{ kind: 'hunk', content: line }] };
+            oldLine = Number(hunk[1]);
+            newLine = Number(hunk[2]);
+            continue;
+        }
+        if (!current.lines.length && line.startsWith('diff --git '))
+            current.header = line;
+        if (line.startsWith('+') && !line.startsWith('+++')) {
+            current.lines.push({ kind: 'add', newLine, content: line.slice(1) });
+            newLine += 1;
+        }
+        else if (line.startsWith('-') && !line.startsWith('---')) {
+            current.lines.push({ kind: 'delete', oldLine, content: line.slice(1) });
+            oldLine += 1;
+        }
+        else if (line.startsWith(' ')) {
+            current.lines.push({ kind: 'context', oldLine, newLine, content: line.slice(1) });
+            oldLine += 1;
+            newLine += 1;
+        }
+        else {
+            current.lines.push({ kind: line.startsWith('@@') ? 'hunk' : 'meta', content: line });
+        }
+    }
+    if (current.lines.length)
+        hunks.push(current);
+    return hunks;
+}
+function patchFilePath(line) {
+    const plus = /^\+\+\+\s+(?:b\/)?(.+)$/.exec(line);
+    if (plus && plus[1] !== '/dev/null')
+        return plus[1];
+    const diff = /^diff --git\s+a\/(.+?)\s+b\/(.+)$/.exec(line);
+    return diff?.[2] ?? '';
+}
+function artifactRecord(pathValue, label = pathValue) {
+    return {
+        path: pathValue,
+        label: shortArtifactLabel(label)
+    };
+}
+function shortArtifactLabel(value) {
+    const clean = value.replace(/\/+$/g, '');
+    return clean.split(/[\\/]/g).filter(Boolean).pop() ?? clean;
+}
+function resolveRelativeArtifactPath(base, artifactPath) {
+    if (!artifactPath || path.isAbsolute(artifactPath) || !base)
+        return artifactPath;
+    return path.join(base, artifactPath);
+}
+function languageForPath(filePath) {
+    const extension = path.extname(filePath).toLowerCase();
+    if (['.ts', '.tsx', '.mts', '.cts'].includes(extension))
+        return 'typescript';
+    if (['.js', '.jsx', '.mjs', '.cjs'].includes(extension))
+        return 'javascript';
+    if (extension === '.json')
+        return 'json';
+    if (extension === '.css')
+        return 'css';
+    if (extension === '.html')
+        return 'html';
+    if (['.md', '.markdown'].includes(extension))
+        return 'markdown';
+    return 'text';
+}
+async function readArtifact(options, artifactPath) {
+    const resolved = await resolveViewableArtifact(options, artifactPath);
+    if (!resolved.ok)
+        return { ok: false, path: artifactPath, label: shortArtifactLabel(artifactPath), error: resolved.error };
+    const stat = await fs.stat(resolved.path).catch(() => undefined);
+    if (!stat)
+        return { ok: false, path: artifactPath, label: shortArtifactLabel(artifactPath), error: 'artifact not found' };
+    if (stat.isDirectory()) {
+        const entries = await artifactDirectoryEntries(resolved.path);
+        return {
+            ok: true,
+            path: artifactPath,
+            label: shortArtifactLabel(artifactPath),
+            kind: 'directory',
+            entries
+        };
+    }
+    if (!stat.isFile())
+        return { ok: false, path: artifactPath, label: shortArtifactLabel(artifactPath), error: 'artifact is not a file' };
+    const size = stat.size;
+    const readBytes = Math.min(size, ARTIFACT_VIEW_MAX_BYTES);
+    const handle = await fs.open(resolved.path, 'r');
+    try {
+        const buffer = Buffer.alloc(readBytes);
+        await handle.read(buffer, 0, readBytes, 0);
+        return {
+            ok: true,
+            path: artifactPath,
+            label: shortArtifactLabel(artifactPath),
+            kind: 'file',
+            size,
+            contentType: contentType(resolved.path),
+            content: buffer.toString('utf8'),
+            truncated: size > ARTIFACT_VIEW_MAX_BYTES
+        };
+    }
+    finally {
+        await handle.close();
+    }
+}
+async function serveArtifactRaw(response, options, artifactPath) {
+    const resolved = await resolveViewableArtifact(options, artifactPath);
+    if (!resolved.ok) {
+        writeJson(response, 404, { ok: false, error: resolved.error });
+        return;
+    }
+    const stat = await fs.stat(resolved.path).catch(() => undefined);
+    if (!stat) {
+        writeJson(response, 404, { ok: false, error: 'artifact not found' });
+        return;
+    }
+    if (stat.isDirectory()) {
+        writeJson(response, 200, {
+            ok: true,
+            path: artifactPath,
+            kind: 'directory',
+            entries: await artifactDirectoryEntries(resolved.path)
+        });
+        return;
+    }
+    await serveFile(response, resolved.path, contentType(resolved.path));
+}
+async function revealArtifactInFileManager(options, artifactPath, dryRun) {
+    const resolved = await resolveViewableArtifact(options, artifactPath);
+    if (!resolved.ok)
+        return { ok: false, path: artifactPath, error: resolved.error };
+    const stat = await fs.stat(resolved.path).catch(() => undefined);
+    if (!stat)
+        return { ok: false, path: artifactPath, error: 'artifact not found' };
+    const target = fileManagerTarget(resolved.path, stat.isDirectory());
+    if (!target)
+        return { ok: false, path: artifactPath, revealedPath: resolved.path, error: 'no supported file manager command for this platform' };
+    const result = {
+        ok: true,
+        path: artifactPath,
+        revealedPath: resolved.path,
+        command: target.command,
+        args: target.args,
+        dryRun
+    };
+    if (dryRun)
+        return result;
+    await spawnDetached(target.command, target.args);
+    return result;
+}
+function fileManagerTarget(filePath, isDirectory) {
+    if (process.platform === 'darwin') {
+        return isDirectory
+            ? { command: 'open', args: [filePath] }
+            : { command: 'open', args: ['-R', filePath] };
+    }
+    if (process.platform === 'win32') {
+        return isDirectory
+            ? { command: 'explorer.exe', args: [filePath] }
+            : { command: 'explorer.exe', args: [`/select,${filePath}`] };
+    }
+    if (process.platform === 'linux' || process.platform === 'freebsd' || process.platform === 'openbsd') {
+        return { command: 'xdg-open', args: [isDirectory ? filePath : path.dirname(filePath)] };
+    }
+    return undefined;
+}
+async function spawnDetached(command, args) {
+    await new Promise((resolve, reject) => {
+        const child = spawn(command, args, { detached: true, stdio: 'ignore' });
+        child.once('error', reject);
+        child.once('spawn', resolve);
+        child.unref();
+    });
+}
+async function artifactDirectoryEntries(root) {
+    const entries = await fs.readdir(root, { withFileTypes: true }).catch(() => []);
+    const rows = [];
+    for (const entry of entries.slice(0, ARTIFACT_DIRECTORY_MAX_ENTRIES)) {
+        if (entry.name.startsWith('.'))
+            continue;
+        const entryPath = path.join(root, entry.name);
+        const stat = await fs.stat(entryPath).catch(() => undefined);
+        rows.push({
+            name: entry.name,
+            path: entryPath,
+            kind: entry.isDirectory() ? 'directory' : 'file',
+            ...(stat?.isFile() ? { size: stat.size } : {})
+        });
+    }
+    return rows;
+}
+async function resolveViewableArtifact(options, artifactPath) {
+    if (!artifactPath)
+        return { ok: false, error: 'missing artifact path' };
+    if (hasHiddenPathSegment(artifactPath))
+        return { ok: false, error: 'hidden files are not viewable' };
+    const roots = await dashboardArtifactRoots(options);
+    const candidates = path.isAbsolute(artifactPath)
+        ? [path.resolve(artifactPath)]
+        : roots.map((root) => path.resolve(root, artifactPath));
+    for (const candidate of candidates) {
+        if (hasHiddenPathSegment(path.relative(path.dirname(candidate), candidate)))
+            continue;
+        if (!roots.some((root) => isPathInside(root, candidate)))
+            continue;
+        const stat = await fs.stat(candidate).catch(() => undefined);
+        if (stat)
+            return { ok: true, path: candidate };
+    }
+    return { ok: false, error: 'artifact not found or outside configured roots' };
+}
+async function dashboardArtifactRoots(options) {
+    const roots = [options.cwd];
+    for (const input of [options.run, options.collection, options.continuation]) {
+        if (!input)
+            continue;
+        const absolute = path.resolve(options.cwd, input);
+        const stat = await fs.lstat(absolute).catch(() => undefined);
+        if (!stat)
+            continue;
+        roots.push(stat.isDirectory() ? absolute : path.dirname(absolute));
+    }
+    return uniquePaths(roots.map((root) => path.resolve(root)));
+}
+function hasHiddenPathSegment(value) {
+    return value.split(/[\\/]/g).some((segment) => segment.startsWith('.') && segment.length > 1);
+}
+function recordArray(value) {
+    return Array.isArray(value) ? value.map(recordValue).filter((entry) => Object.keys(entry).length > 0) : [];
+}
+function recordValue(value) {
+    return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+}
+function stringArray(value) {
+    return Array.isArray(value) ? value.map(String).filter(Boolean) : [];
+}
+function textValue(value, fallback) {
+    if (value === undefined || value === null || value === '')
+        return fallback;
+    return String(value);
+}
+function numberValue(value) {
+    const number = Number(value ?? 0);
+    return Number.isFinite(number) ? number : 0;
+}
+function normalized(value) {
+    return textValue(value, '').trim().toLowerCase();
+}
+async function fileExists(file) {
+    try {
+        await fs.access(file);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function isPathInside(root, value) {
+    const relative = path.relative(path.resolve(root), path.resolve(value));
+    return relative === '' || Boolean(relative && !relative.startsWith('..') && !path.isAbsolute(relative));
+}
+async function readHealth(options) {
+    const sources = {
+        run: await inspectHealthSource(options.cwd, options.run, 'swarm-results.json'),
+        collection: await inspectHealthSource(options.cwd, options.collection, 'collection.json'),
+        continuation: await inspectHealthSource(options.cwd, options.continuation, 'continuation.json')
+    };
+    const configuredSources = Object.values(sources).filter((source) => source.configured);
+    return {
+        ok: configuredSources.every((source) => source.status === 'ready'),
+        service: 'frontier-loom-ui',
+        generatedAt: Date.now(),
+        cwd: options.cwd,
+        sources
+    };
+}
+async function inspectHealthSource(cwd, input, defaultFile) {
+    if (!input)
+        return { configured: false, status: 'not-configured' };
+    const absolute = path.resolve(cwd, input);
+    const stat = await fs.lstat(absolute).catch((error) => ({ error }));
+    if (!stat || 'error' in stat) {
+        return {
+            configured: true,
+            status: 'missing',
+            input,
+            file: absolute,
+            error: errorMessage(stat && 'error' in stat ? stat.error : undefined)
+        };
+    }
+    const file = stat.isDirectory() ? path.join(absolute, defaultFile) : absolute;
+    try {
+        const fileStat = await fs.stat(file);
+        if (fileStat.size <= HEALTH_JSON_PARSE_MAX_BYTES) {
+            const text = await fs.readFile(file, 'utf8');
+            JSON.parse(text);
+        }
+        return {
+            configured: true,
+            status: 'ready',
+            input,
+            file,
+            dir: stat.isDirectory() ? absolute : path.dirname(file)
+        };
+    }
+    catch (error) {
+        return {
+            configured: true,
+            status: error.code === 'ENOENT' ? 'missing' : 'invalid',
+            input,
+            file,
+            dir: stat.isDirectory() ? absolute : path.dirname(file),
+            error: errorMessage(error)
+        };
+    }
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : error === undefined ? undefined : String(error);
+}
+function staticFile(root, pathname) {
+    const clean = pathname === '/' ? 'index.html' : pathname.replace(/^\/+/, '');
+    const resolved = path.resolve(root, clean);
+    if (!resolved.startsWith(root + path.sep) && resolved !== root)
+        return path.join(root, 'index.html');
+    return resolved;
+}
+async function serveFile(response, file, type) {
+    try {
+        const body = await fs.readFile(file);
+        response.writeHead(200, responseHeaders(type));
+        response.end(body);
+    }
+    catch {
+        writeJson(response, 404, { ok: false, error: 'not found' });
+    }
+}
+function writeJson(response, status, value) {
+    response.writeHead(status, responseHeaders('application/json; charset=utf-8'));
+    response.end(JSON.stringify(value, null, 2));
+}
+async function readJsonBody(request, maxBytes) {
+    let bytes = 0;
+    const chunks = [];
+    for await (const chunk of request) {
+        const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+        bytes += buffer.byteLength;
+        if (bytes > maxBytes)
+            throw new Error('request body too large');
+        chunks.push(buffer);
+    }
+    const text = Buffer.concat(chunks).toString('utf8').trim();
+    if (!text)
+        return {};
+    return JSON.parse(text);
+}
+function responseHeaders(contentType) {
+    return {
+        'content-type': contentType,
+        'cache-control': 'no-store, max-age=0',
+        pragma: 'no-cache'
+    };
+}
+function resolveFrontierDomRuntime() {
+    return path.join(packageDir, '..', 'node_modules', '@shapeshift-labs', 'frontier-dom', 'dist', 'jsx-runtime.js');
+}
+function contentType(file) {
+    if (file.endsWith('.js'))
+        return 'application/javascript; charset=utf-8';
+    if (file.endsWith('.css'))
+        return 'text/css; charset=utf-8';
+    if (file.endsWith('.html'))
+        return 'text/html; charset=utf-8';
+    return 'application/octet-stream';
+}
+//# sourceMappingURL=server.js.map