@shapeshift-labs/frontier-swarm-codex 0.5.119 → 0.5.120

package/dist/run-graph-live.js

@@ -0,0 +1,799 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { stableCodexRunGraphPart } from './run-graph-utils.js';
+export const FRONTIER_SWARM_CODEX_LIVE_RUN_GRAPH_EVENTS_FILE = 'live-run-graph-events.jsonl';
+const liveRunGraphWriteQueues = new Map();
+export function resolveCodexLiveRunGraphEventsPath(input) {
+    if (input.liveRunGraphEventsPath === false)
+        return undefined;
+    const base = input.cwd ?? process.cwd();
+    return path.resolve(base, input.liveRunGraphEventsPath ?? path.join(input.outDir, FRONTIER_SWARM_CODEX_LIVE_RUN_GRAPH_EVENTS_FILE));
+}
+export async function initCodexLiveRunGraphEvents(file) {
+    if (!file)
+        return;
+    const absolute = path.resolve(file);
+    await fs.mkdir(path.dirname(absolute), { recursive: true });
+    await writeTextFileAtomic(absolute, '');
+}
+export function createCodexLiveRunGraphDashboardMetadata(input) {
+    if (!input.liveRunGraphEventsPath) {
+        return {
+            artifactPaths: {},
+            runSource: { mode: 'disabled' }
+        };
+    }
+    return {
+        artifactPaths: { liveRunGraphEvents: input.liveRunGraphEventsPath },
+        runSource: {
+            mode: 'live-run-graph-events',
+            format: 'jsonl',
+            liveRunGraphEventsPath: input.liveRunGraphEventsPath
+        }
+    };
+}
+export async function appendCodexLiveRunGraphEvent(file, event) {
+    if (!file)
+        return;
+    const absolute = path.resolve(file);
+    const previous = liveRunGraphWriteQueues.get(absolute) ?? Promise.resolve();
+    let next;
+    next = previous
+        .catch(() => { })
+        .then(async () => {
+        await fs.mkdir(path.dirname(absolute), { recursive: true });
+        await fs.appendFile(absolute, JSON.stringify(event) + '\n');
+    })
+        .finally(() => {
+        if (liveRunGraphWriteQueues.get(absolute) === next)
+            liveRunGraphWriteQueues.delete(absolute);
+    });
+    liveRunGraphWriteQueues.set(absolute, next);
+    return next;
+}
+export function createCodexLiveRunStartedEvent(input) {
+    const generatedAt = input.generatedAt ?? Date.now();
+    const runId = runGraphRunNodeId(input.runId, input.outDir);
+    return {
+        kind: 'frontier.swarm-codex.live-run-graph-event',
+        version: 1,
+        type: 'run.started',
+        runId: input.runId,
+        generatedAt,
+        nodes: [{
+                id: runId,
+                kind: 'run',
+                label: input.runId,
+                path: input.outDir,
+                status: 'running',
+                generatedAt,
+                data: { jobCount: input.jobCount }
+            }],
+        data: { outDir: input.outDir, jobCount: input.jobCount }
+    };
+}
+export function createCodexLiveRunFinishedEvent(input) {
+    const generatedAt = input.generatedAt ?? Date.now();
+    const runId = runGraphRunNodeId(input.runId, input.outDir);
+    return {
+        kind: 'frontier.swarm-codex.live-run-graph-event',
+        version: 1,
+        type: 'run.finished',
+        runId: input.runId,
+        generatedAt,
+        nodes: [{
+                id: runId,
+                kind: 'run',
+                label: input.runId,
+                path: input.outDir,
+                status: input.ok ? 'completed' : 'failed',
+                outcome: input.ok ? 'ok' : 'failed',
+                generatedAt,
+                data: { ok: input.ok, summary: input.summary }
+            }],
+        data: { ok: input.ok, summary: input.summary }
+    };
+}
+export function createCodexLiveJobStartedEvent(input) {
+    const generatedAt = input.generatedAt ?? Date.now();
+    const { nodes, edges } = jobGraphFrame(input.job, {
+        runId: input.runId,
+        outDir: input.outDir,
+        status: 'running',
+        generatedAt
+    });
+    return {
+        kind: 'frontier.swarm-codex.live-run-graph-event',
+        version: 1,
+        type: 'job.started',
+        runId: input.runId,
+        jobId: input.job.id,
+        taskId: input.job.taskId,
+        lane: input.job.lane,
+        generatedAt,
+        nodes,
+        edges,
+        data: input.data
+    };
+}
+export function createCodexLiveJobResultEvents(input) {
+    const generatedAt = input.generatedAt ?? input.result.finishedAt ?? Date.now();
+    const events = [];
+    const jobNodeId = runGraphJobNodeId(input.job.id);
+    const candidateNodeId = `candidate:${input.job.id}`;
+    const evidencePaths = uniqueStrings([
+        ...(input.result.evidencePaths ?? []),
+        ...(input.mergeBundle.evidencePaths ?? [])
+    ]);
+    if (evidencePaths.length > 0) {
+        const nodes = evidencePaths.map((evidencePath) => ({
+            id: runGraphEvidenceNodeId(input.job.id, evidencePath),
+            kind: 'evidence',
+            label: path.basename(evidencePath),
+            jobId: input.job.id,
+            taskId: input.job.taskId,
+            lane: input.job.lane,
+            path: evidencePath,
+            generatedAt
+        }));
+        events.push(liveEvent(input, {
+            type: 'evidence.discovered',
+            generatedAt,
+            nodes,
+            edges: nodes.map((node) => ({
+                id: `produces:${jobNodeId}->${node.id}`,
+                kind: 'produces',
+                from: jobNodeId,
+                to: node.id
+            })),
+            data: { evidenceCount: evidencePaths.length, evidencePaths }
+        }));
+    }
+    const gates = [
+        ...input.mergeBundle.commandsPassed.map((command) => ({ command, status: 'passed' })),
+        ...input.mergeBundle.commandsFailed.map((command) => ({ command, status: 'failed' }))
+    ];
+    for (const gate of gates) {
+        const label = gate.command.name ?? gate.command.commandLine ?? gate.command.command.join(' ') ?? 'command';
+        const gateNodeId = `gate:${input.job.id}:${stableCodexRunGraphPart(label)}`;
+        events.push(liveEvent(input, {
+            type: 'gate.result',
+            generatedAt,
+            nodes: [{
+                    id: gateNodeId,
+                    kind: 'gate',
+                    label,
+                    jobId: input.job.id,
+                    taskId: input.job.taskId,
+                    lane: input.job.lane,
+                    status: gate.status,
+                    generatedAt,
+                    data: { command: gate.command }
+                }],
+            edges: [{
+                    id: `verifies:${gateNodeId}->${jobNodeId}`,
+                    kind: 'verifies',
+                    from: gateNodeId,
+                    to: jobNodeId,
+                    label: gate.status
+                }],
+            data: { status: gate.status, command: gate.command }
+        }));
+    }
+    const terminalNodeId = `decision:terminal:${input.job.id}`;
+    events.push(liveEvent(input, {
+        type: 'terminal.outcome',
+        generatedAt,
+        nodes: [{
+                id: terminalNodeId,
+                kind: 'decision',
+                label: input.result.status ?? input.mergeBundle.status,
+                jobId: input.job.id,
+                taskId: input.job.taskId,
+                lane: input.job.lane,
+                status: input.result.status ?? input.mergeBundle.status,
+                outcome: input.result.mergeDisposition ?? input.mergeBundle.disposition,
+                generatedAt,
+                data: {
+                    exitCode: input.result.exitCode,
+                    signal: input.result.signal,
+                    mergeReadiness: input.result.mergeReadiness ?? input.mergeBundle.mergeReadiness,
+                    changedPathCount: input.result.changedPaths?.length ?? input.mergeBundle.changedPaths.length,
+                    ownershipViolationCount: input.result.ownershipViolations?.length ?? input.mergeBundle.ownershipViolations.length,
+                    error: errorString(input.result.error)
+                }
+            }],
+        edges: [{
+                id: `decides:${terminalNodeId}->${jobNodeId}`,
+                kind: 'decides',
+                from: terminalNodeId,
+                to: jobNodeId,
+                label: input.result.status ?? input.mergeBundle.status
+            }]
+    }));
+    const frame = jobGraphFrame(input.job, {
+        runId: input.runId,
+        outDir: input.outDir,
+        status: input.result.status ?? input.mergeBundle.status,
+        outcome: input.result.mergeDisposition ?? input.mergeBundle.disposition,
+        generatedAt
+    });
+    const semanticAdmission = createLiveSemanticAdmissionGraph(input, {
+        generatedAt,
+        jobNodeId,
+        candidateNodeId
+    });
+    frame.nodes.push({
+        id: candidateNodeId,
+        kind: 'candidate',
+        label: input.job.title ?? input.job.id,
+        jobId: input.job.id,
+        taskId: input.job.taskId,
+        lane: input.job.lane,
+        status: input.mergeBundle.status,
+        outcome: input.mergeBundle.disposition,
+        generatedAt,
+        data: {
+            mergeReadiness: input.mergeBundle.mergeReadiness,
+            riskLevel: input.mergeBundle.riskLevel,
+            autoMergeable: input.mergeBundle.autoMergeable,
+            changedPaths: input.mergeBundle.changedPaths,
+            ownershipViolations: input.mergeBundle.ownershipViolations,
+            semanticAdmission: semanticAdmission?.summary
+        }
+    });
+    frame.edges.push({
+        id: `produces:${jobNodeId}->${candidateNodeId}`,
+        kind: 'produces',
+        from: jobNodeId,
+        to: candidateNodeId
+    });
+    if (semanticAdmission) {
+        events.push(liveEvent(input, {
+            type: 'semantic-admission.result',
+            generatedAt,
+            nodes: semanticAdmission.nodes,
+            edges: semanticAdmission.edges,
+            data: semanticAdmission.summary
+        }));
+    }
+    events.push(liveEvent(input, {
+        type: 'job.finished',
+        generatedAt,
+        nodes: frame.nodes,
+        edges: frame.edges,
+        data: {
+            status: input.result.status ?? input.mergeBundle.status,
+            mergeReadiness: input.result.mergeReadiness ?? input.mergeBundle.mergeReadiness,
+            mergeDisposition: input.result.mergeDisposition ?? input.mergeBundle.disposition,
+            changedPathCount: input.result.changedPaths?.length ?? input.mergeBundle.changedPaths.length,
+            evidenceCount: evidencePaths.length,
+            gateCount: gates.length
+        }
+    }));
+    return events;
+}
+function createLiveSemanticAdmissionGraph(input, graph) {
+    const decisions = createLiveSemanticAdmissionDecisions(input.result, input.mergeBundle);
+    if (decisions.length === 0)
+        return undefined;
+    const nodes = decisions.map((decision) => ({
+        id: `semantic-admission:${input.job.id}:${stableCodexRunGraphPart(decision.key)}`,
+        kind: 'semantic-admission',
+        label: decision.label,
+        jobId: input.job.id,
+        taskId: input.job.taskId,
+        lane: input.job.lane,
+        status: decision.status,
+        outcome: decision.action,
+        generatedAt: graph.generatedAt,
+        refs: { job: graph.jobNodeId, candidate: graph.candidateNodeId },
+        data: decision.data
+    }));
+    const edges = nodes.flatMap((node, index) => {
+        const decision = decisions[index];
+        return [
+            {
+                id: `produces:${graph.jobNodeId}->${node.id}`,
+                kind: 'produces',
+                from: graph.jobNodeId,
+                to: node.id,
+                label: decision.source
+            },
+            {
+                id: `decides:${node.id}->${graph.candidateNodeId}`,
+                kind: 'decides',
+                from: node.id,
+                to: graph.candidateNodeId,
+                label: decision.status
+            }
+        ];
+    });
+    return {
+        nodes,
+        edges,
+        summary: {
+            decisionCount: decisions.length,
+            statuses: countStrings(decisions.map((decision) => decision.status)),
+            sources: countStrings(decisions.map((decision) => decision.source)),
+            reasonCodes: uniqueStrings(decisions.flatMap((decision) => decision.reasonCodes)),
+            reasons: uniqueStrings(decisions.flatMap((decision) => decision.reasons))
+        }
+    };
+}
+function createLiveSemanticAdmissionDecisions(result, mergeBundle) {
+    const metadata = recordValue(mergeBundle.metadata);
+    const resultMetadata = recordValue(result.metadata);
+    const semanticImport = semanticImportSummaryForLiveEvent(result, mergeBundle);
+    const decisions = [];
+    const aggregateReasonCodes = uniqueStrings([
+        ...semanticImportReasonCodes(semanticImport),
+        ...semanticAdmissionReasonCodesFromMetadata(metadata),
+        ...semanticAdmissionReasonCodesFromMetadata(resultMetadata)
+    ]);
+    const aggregateReasons = uniqueStrings([
+        ...mergeBundle.reasons,
+        ...stringValues(recordValue(metadata?.semanticEditAdmission)?.reasons),
+        ...stringValues(recordValue(resultMetadata?.semanticEditAdmission)?.reasons)
+    ]);
+    if (semanticImport || aggregateReasonCodes.length > 0 || aggregateReasons.some(isSemanticAdmissionReason)) {
+        const status = classifyLiveSemanticAdmissionStatus({
+            staleAgainstHead: mergeBundle.staleAgainstHead || mergeBundle.disposition === 'stale-against-head' || result.mergeDisposition === 'stale-against-head',
+            autoMergeable: mergeBundle.autoMergeable || mergeBundle.disposition === 'auto-mergeable' || result.mergeDisposition === 'auto-mergeable',
+            signals: [
+                mergeBundle.status,
+                mergeBundle.mergeReadiness,
+                mergeBundle.disposition,
+                result.status,
+                result.mergeReadiness,
+                result.mergeDisposition,
+                ...aggregateReasonCodes,
+                ...aggregateReasons,
+                ...semanticImportStatusSignals(semanticImport)
+            ]
+        });
+        decisions.push({
+            key: 'merge-admission',
+            source: 'merge-admission',
+            label: `semantic admission: ${status}`,
+            status,
+            action: status === 'safe' ? 'apply' : status === 'no-op' ? 'record' : status === 'stale' ? 'rerun' : status === 'block' ? 'block' : 'review',
+            reasonCodes: aggregateReasonCodes,
+            reasons: aggregateReasons,
+            data: {
+                source: 'merge-admission',
+                status,
+                mergeReadiness: result.mergeReadiness ?? mergeBundle.mergeReadiness,
+                disposition: result.mergeDisposition ?? mergeBundle.disposition,
+                autoMergeable: mergeBundle.autoMergeable,
+                staleAgainstHead: mergeBundle.staleAgainstHead,
+                semanticImportPresent: Boolean(semanticImport),
+                reasonCodes: aggregateReasonCodes,
+                reasons: aggregateReasons
+            }
+        });
+    }
+    for (const decision of semanticMetadataDecisions(metadata, 'metadata'))
+        decisions.push(decision);
+    for (const decision of semanticMetadataDecisions(resultMetadata, 'result-metadata'))
+        decisions.push(decision);
+    for (const decision of semanticEditSummaryDecisions(semanticImport))
+        decisions.push(decision);
+    const seen = new Set();
+    return decisions.filter((decision) => {
+        const dedupeKey = `${decision.source}:${decision.key}`;
+        if (seen.has(dedupeKey))
+            return false;
+        seen.add(dedupeKey);
+        return true;
+    });
+}
+function semanticMetadataDecisions(metadata, sourcePrefix) {
+    if (!metadata)
+        return [];
+    const out = [];
+    for (const [key, label] of [
+        ['semanticAdmission', 'semantic admission'],
+        ['semanticMergeAdmission', 'semantic merge admission'],
+        ['semanticEditAdmission', 'semantic edit admission'],
+        ['safeMerge', 'safe merge'],
+        ['safeMergeDecision', 'safe merge decision'],
+        ['semanticSafeMerge', 'semantic safe merge']
+    ]) {
+        const record = recordValue(metadata[key]);
+        if (!record)
+            continue;
+        const reasonCodes = semanticReasonCodesFromRecord(record);
+        const reasons = stringValues(record.reasons);
+        const status = classifyLiveSemanticAdmissionStatus({
+            signals: [
+                stringValue(record.status),
+                stringValue(record.decision),
+                stringValue(record.outcome),
+                stringValue(record.action),
+                ...reasonCodes,
+                ...reasons
+            ],
+            autoMergeable: record.autoMergeCandidate === true || record.cleanEligible === true || record.safe === true
+        });
+        out.push({
+            key,
+            source: `${sourcePrefix}:${key}`,
+            label: `${label}: ${status}`,
+            status,
+            action: stringValue(record.action) ?? stringValue(record.decision),
+            reasonCodes,
+            reasons,
+            data: {
+                source: `${sourcePrefix}:${key}`,
+                status,
+                action: stringValue(record.action),
+                decision: stringValue(record.decision),
+                outcome: stringValue(record.outcome),
+                reasonCodes,
+                reasons,
+                record
+            }
+        });
+    }
+    return out;
+}
+function semanticEditSummaryDecisions(semanticImport) {
+    if (!semanticImport)
+        return [];
+    const sections = [
+        ['semantic-edit-script', 'semantic edit script', recordValue(semanticImport.semanticEditScripts)],
+        ['semantic-edit-projection', 'semantic edit projection', recordValue(semanticImport.semanticEditProjections) ?? recordValue(semanticImport.semanticEditProjection)],
+        ['semantic-edit-replay', 'semantic edit replay', recordValue(semanticImport.semanticEditReplays) ?? recordValue(semanticImport.semanticEditReplay)]
+    ];
+    return sections.flatMap(([key, label, section]) => {
+        if (!section || !semanticEditSectionHasAdmissionData(section))
+            return [];
+        const reasonCodes = semanticReasonCodesFromRecord(section);
+        const reasons = stringValues(section.reasons);
+        const admissionStatuses = semanticAdmissionStatuses(section);
+        const status = classifyLiveSemanticAdmissionStatus({
+            signals: [
+                stringValue(section.status),
+                ...stringValues(section.actions),
+                ...admissionStatuses,
+                ...reasonCodes,
+                ...reasons
+            ]
+        });
+        return [{
+                key,
+                source: key,
+                label: `${label}: ${status}`,
+                status,
+                action: firstString(stringValues(section.actions)) ?? actionForSemanticAdmissionStatus(status),
+                reasonCodes,
+                reasons,
+                data: {
+                    source: key,
+                    status,
+                    action: firstString(stringValues(section.actions)) ?? actionForSemanticAdmissionStatus(status),
+                    admissionStatuses,
+                    reasonCodes,
+                    reasons,
+                    summary: section
+                }
+            }];
+    });
+}
+function semanticImportSummaryForLiveEvent(result, mergeBundle) {
+    const metadata = recordValue(mergeBundle.metadata);
+    const resultMetadata = recordValue(result.metadata);
+    const candidates = [
+        recordValue(result.semanticImport),
+        recordValue(mergeBundle.semanticImport),
+        recordValue(resultMetadata?.semanticImport),
+        recordValue(resultMetadata?.semanticImportSummary),
+        recordValue(metadata?.semanticImport),
+        recordValue(metadata?.semanticImportSummary)
+    ].filter((entry) => Boolean(entry));
+    return candidates.sort((left, right) => semanticImportRichness(right) - semanticImportRichness(left))[0];
+}
+function semanticImportRichness(summary) {
+    const semanticIndex = recordValue(summary.semanticIndex);
+    const semanticSidecars = recordValue(summary.semanticSidecars);
+    const values = [
+        summary.total,
+        summary.selected,
+        summary.eligible,
+        summary.imported,
+        summary.sourceMapMappingCount,
+        semanticIndex?.symbols,
+        semanticSidecars?.ownershipRegions,
+        semanticSidecars?.patchHints
+    ];
+    return values.reduce((sum, value) => sum + nonNegativeNumber(value), 0);
+}
+function semanticImportReasonCodes(summary) {
+    if (!summary)
+        return [];
+    return uniqueStrings([
+        ...semanticReasonCodesFromRecord(summary),
+        ...semanticReasonCodesFromRecord(recordValue(summary.semanticEditScripts)),
+        ...semanticReasonCodesFromRecord(recordValue(summary.semanticEditProjections)),
+        ...semanticReasonCodesFromRecord(recordValue(summary.semanticEditProjection)),
+        ...semanticReasonCodesFromRecord(recordValue(summary.semanticEditReplays)),
+        ...semanticReasonCodesFromRecord(recordValue(summary.semanticEditReplay)),
+        ...semanticReasonCodesFromRecord(recordValue(summary.semanticLineage)),
+        ...semanticReasonCodesFromRecord(recordValue(summary.semanticSliceAdmissions))
+    ]);
+}
+function semanticAdmissionReasonCodesFromMetadata(metadata) {
+    if (!metadata)
+        return [];
+    return uniqueStrings([
+        ...semanticReasonCodesFromRecord(recordValue(metadata.semanticAdmission)),
+        ...semanticReasonCodesFromRecord(recordValue(metadata.semanticMergeAdmission)),
+        ...semanticReasonCodesFromRecord(recordValue(metadata.semanticEditAdmission)),
+        ...semanticReasonCodesFromRecord(recordValue(metadata.safeMerge)),
+        ...semanticReasonCodesFromRecord(recordValue(metadata.safeMergeDecision)),
+        ...semanticReasonCodesFromRecord(recordValue(metadata.semanticSafeMerge))
+    ]);
+}
+function semanticImportStatusSignals(summary) {
+    if (!summary)
+        return [];
+    return uniqueStrings([
+        ...semanticAdmissionStatuses(recordValue(summary.semanticEditScripts)),
+        ...semanticAdmissionStatuses(recordValue(summary.semanticEditProjections)),
+        ...semanticAdmissionStatuses(recordValue(summary.semanticEditProjection)),
+        ...semanticAdmissionStatuses(recordValue(summary.semanticEditReplays)),
+        ...semanticAdmissionStatuses(recordValue(summary.semanticEditReplay)),
+        ...Object.keys(countRecord(summary.readiness)).filter((key) => countRecord(summary.readiness)[key] > 0)
+    ]);
+}
+function semanticEditSectionHasAdmissionData(section) {
+    return nonNegativeNumber(section.total) > 0 ||
+        nonNegativeNumber(section.operations) > 0 ||
+        nonNegativeNumber(section.acceptedClean) > 0 ||
+        semanticAdmissionStatuses(section).length > 0 ||
+        semanticReasonCodesFromRecord(section).length > 0;
+}
+function semanticAdmissionStatuses(section) {
+    if (!section)
+        return [];
+    const counters = [
+        countRecord(section.admission),
+        countRecord(section.statusCounts),
+        countRecord(section.byStatus)
+    ];
+    return uniqueStrings([
+        ...counters.flatMap((record) => Object.entries(record).filter(([, count]) => count > 0).map(([key]) => key)),
+        ...[
+            ['accepted-clean', section.acceptedClean],
+            ['already-applied', section.alreadyApplied],
+            ['auto-merge-candidate', section.autoMergeCandidates],
+            ['auto-apply-candidate', section.autoApplyCandidates],
+            ['portable', section.portable],
+            ['projected', section.projected],
+            ['conflict', section.conflicts],
+            ['stale', section.stale],
+            ['blocked', section.blocked],
+            ['needs-port', section.needsPort],
+            ['needs-review', section.reviewRequired],
+            ['evidence-only', section.evidenceOnly]
+        ].filter(([, value]) => nonNegativeNumber(value) > 0).map(([status]) => String(status))
+    ]);
+}
+function classifyLiveSemanticAdmissionStatus(input) {
+    const signals = uniqueStrings(input.signals.filter((signal) => Boolean(signal))).map(normalizedAdmissionSignal);
+    if (input.staleAgainstHead || signals.some((signal) => signal === 'stale' || signal === 'stale-against-head'))
+        return 'stale';
+    if (signals.some((signal) => signal.includes('conflict') ||
+        signal === 'block' ||
+        signal === 'blocked' ||
+        signal === 'reject' ||
+        signal === 'rejected' ||
+        signal === 'failed' ||
+        signal === 'fail'))
+        return 'block';
+    if (signals.some((signal) => signal === 'already-applied' ||
+        signal === 'alreadyapplied' ||
+        signal === 'no-op' ||
+        signal === 'noop' ||
+        signal === 'no-source-changes' ||
+        signal === 'discovery-only' ||
+        signal === 'record-only' ||
+        signal === 'record'))
+        return 'no-op';
+    if (signals.some((signal) => signal === 'review' ||
+        signal === 'needs-review' ||
+        signal === 'needsreview' ||
+        signal === 'review-required' ||
+        signal === 'reviewrequired' ||
+        signal === 'needs-port' ||
+        signal === 'needsport' ||
+        signal === 'manual-review' ||
+        signal === 'human-review' ||
+        signal === 'prioritize' ||
+        signal === 'ambiguous' ||
+        signal === 'evidence-only'))
+        return 'review';
+    if (input.autoMergeable || signals.some((signal) => signal === 'safe' ||
+        signal === 'ready' ||
+        signal === 'admit' ||
+        signal === 'apply' ||
+        signal === 'accepted-clean' ||
+        signal === 'auto-merge-candidate' ||
+        signal === 'auto-apply-candidate' ||
+        signal === 'portable' ||
+        signal === 'projected' ||
+        signal === 'verified-patch' ||
+        signal === 'auto-mergeable'))
+        return 'safe';
+    return 'review';
+}
+function actionForSemanticAdmissionStatus(status) {
+    if (status === 'safe')
+        return 'apply';
+    if (status === 'no-op')
+        return 'record';
+    if (status === 'stale')
+        return 'rerun';
+    if (status === 'block')
+        return 'block';
+    return 'review';
+}
+function semanticReasonCodesFromRecord(record) {
+    if (!record)
+        return [];
+    return uniqueStrings([
+        ...stringValues(record.reasonCodes),
+        ...stringValues(record.reasonCode),
+        ...stringValues(record.semanticImportExpectedMissingReasonCodes),
+        ...stringValues(record.expectedMissingReasonCodes)
+    ]);
+}
+function isSemanticAdmissionReason(reason) {
+    return normalizedAdmissionSignal(reason).startsWith('semantic-') ||
+        normalizedAdmissionSignal(reason).startsWith('auto-merge-candidate-');
+}
+function normalizedAdmissionSignal(value) {
+    return value.trim().replace(/_/g, '-').toLowerCase();
+}
+function liveEvent(input, event) {
+    return {
+        kind: 'frontier.swarm-codex.live-run-graph-event',
+        version: 1,
+        type: event.type,
+        runId: input.runId,
+        jobId: input.job.id,
+        taskId: input.job.taskId,
+        lane: input.job.lane,
+        generatedAt: event.generatedAt,
+        ...(event.nodes ? { nodes: event.nodes } : {}),
+        ...(event.edges ? { edges: event.edges } : {}),
+        ...(event.data ? { data: event.data } : {})
+    };
+}
+function jobGraphFrame(job, input) {
+    const runNodeId = runGraphRunNodeId(input.runId, input.outDir);
+    const taskNodeId = runGraphTaskNodeId(job.taskId);
+    const jobNodeId = runGraphJobNodeId(job.id);
+    return {
+        nodes: [
+            {
+                id: runNodeId,
+                kind: 'run',
+                label: input.runId ?? path.basename(input.outDir),
+                path: input.outDir,
+                status: 'running',
+                generatedAt: input.generatedAt
+            },
+            {
+                id: taskNodeId,
+                kind: 'task',
+                label: job.taskId,
+                taskId: job.taskId,
+                lane: job.lane,
+                generatedAt: input.generatedAt,
+                data: { title: job.task.title, workKind: job.task.workKind }
+            },
+            {
+                id: jobNodeId,
+                kind: 'job',
+                label: job.id,
+                jobId: job.id,
+                taskId: job.taskId,
+                lane: job.lane,
+                model: job.compute.model ?? stringRecordValue(job.compute.metadata, 'model'),
+                computeId: job.compute.id,
+                modelTier: job.compute.serviceTier,
+                status: input.status,
+                outcome: input.outcome,
+                generatedAt: input.generatedAt,
+                data: { title: job.title, capabilities: job.capabilities, allowedWrites: job.allowedWrites }
+            }
+        ],
+        edges: [
+            { id: `contains:${runNodeId}->${taskNodeId}`, kind: 'contains', from: runNodeId, to: taskNodeId },
+            { id: `contains:${runNodeId}->${jobNodeId}`, kind: 'contains', from: runNodeId, to: jobNodeId },
+            { id: `produces:${taskNodeId}->${jobNodeId}`, kind: 'produces', from: taskNodeId, to: jobNodeId }
+        ]
+    };
+}
+function runGraphRunNodeId(runId, outDir) {
+    return `run:${stableCodexRunGraphPart(runId ?? (path.basename(outDir) || 'run'))}`;
+}
+function runGraphTaskNodeId(taskId) {
+    return `task:${stableCodexRunGraphPart(taskId)}`;
+}
+function runGraphJobNodeId(jobId) {
+    return `job:${stableCodexRunGraphPart(jobId)}`;
+}
+function runGraphEvidenceNodeId(jobId, evidencePath) {
+    return `evidence:${stableCodexRunGraphPart(`${jobId}:${evidencePath}`)}`;
+}
+function countStrings(values) {
+    const counts = {};
+    for (const value of values)
+        counts[value] = (counts[value] ?? 0) + 1;
+    return counts;
+}
+function uniqueStrings(values) {
+    return Array.from(new Set(values.filter((value) => value.length > 0)));
+}
+function recordValue(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return undefined;
+    return value;
+}
+function countRecord(value) {
+    const record = recordValue(value);
+    if (!record)
+        return {};
+    const out = {};
+    for (const [key, entry] of Object.entries(record)) {
+        const count = nonNegativeNumber(entry);
+        if (count > 0)
+            out[key] = count;
+    }
+    return out;
+}
+function stringValue(value) {
+    return typeof value === 'string' && value.length > 0 ? value : undefined;
+}
+function stringValues(value) {
+    if (typeof value === 'string' && value.length > 0)
+        return [value];
+    if (!Array.isArray(value))
+        return [];
+    return value.filter((entry) => typeof entry === 'string' && entry.length > 0);
+}
+function firstString(values) {
+    return values.find((value) => value.length > 0);
+}
+function nonNegativeNumber(value) {
+    const number = Number(value);
+    return Number.isFinite(number) && number > 0 ? number : 0;
+}
+function stringRecordValue(record, key) {
+    if (!record || typeof record !== 'object')
+        return undefined;
+    const value = record[key];
+    return typeof value === 'string' && value ? value : undefined;
+}
+function errorString(value) {
+    if (value === undefined || value === null)
+        return undefined;
+    if (value instanceof Error)
+        return value.message;
+    return typeof value === 'string' ? value : JSON.stringify(value);
+}
+async function writeTextFileAtomic(file, text) {
+    const tmp = `${file}.${process.pid}.${Date.now()}.${Math.random().toString(16).slice(2)}.tmp`;
+    try {
+        await fs.writeFile(tmp, text);
+        await fs.rename(tmp, file);
+    }
+    catch (error) {
+        await fs.rm(tmp, { force: true }).catch(() => { });
+        throw error;
+    }
+}
+//# sourceMappingURL=run-graph-live.js.map