@shapeshift-labs/frontier-swarm-codex 0.5.122 → 0.5.124

package/dist/collect-run-graph.js

@@ -1,1246 +0,0 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import { classifyCodexSemanticCollectAdmission } from './collect-semantic-admission.js';
-import { countCodexRunGraphValues, createCodexRunGraphIndexes, hashCodexRunGraphString, mergeCodexRunGraphNode, stableCodexRunGraphPart, stringFromUnknown } from './run-graph-utils.js';
-export function createCodexCollectRunGraph(input) {
-    const result = input.result;
-    const generatedAt = input.generatedAt ?? result.generatedAt ?? Date.now();
-    const nodes = new Map();
-    const edges = new Map();
-    const runNodeId = `run:${path.basename(result.runDir) || 'run'}`;
-    const addNode = (node) => {
-        const existing = nodes.get(node.id);
-        nodes.set(node.id, existing ? mergeCodexRunGraphNode(existing, node) : node);
-        return node.id;
-    };
-    const addEdge = (kind, from, to, label, data) => {
-        if (!from || !to || from === to)
-            return;
-        const id = `${kind}:${from}->${to}`;
-        if (!edges.has(id))
-            edges.set(id, { id, kind, from, to, ...(label ? { label } : {}), ...(data ? { data } : {}) });
-    };
-    addNode({
-        id: runNodeId,
-        kind: 'run',
-        label: path.basename(result.runDir) || result.runDir,
-        path: result.runDir,
-        generatedAt,
-        data: { outDir: result.outDir, ok: result.ok, summary: result.summary }
-    });
-    const graphRefs = createRunGraphReferenceIndex(result);
-    for (const bucket of Object.keys(result.buckets)) {
-        const bucketNodeId = `bucket:${bucket}`;
-        addNode({ id: bucketNodeId, kind: 'bucket', label: bucket, bucket, generatedAt });
-        addEdge('contains', runNodeId, bucketNodeId);
-        for (const entry of result.buckets[bucket]) {
-            addCollectedBundleNodes(bucket, entry, result.semanticImport?.expected === true, runNodeId, bucketNodeId, addNode, addEdge);
-        }
-    }
-    addQueueOutcomeNodes(result, runNodeId, addNode, addEdge);
-    addTerminalStateNodes(result, runNodeId, addNode, addEdge);
-    addTournamentNodes(result, runNodeId, graphRefs, addNode, addEdge);
-    addAdaptiveFeedbackNodes(result, runNodeId, graphRefs, addNode, addEdge);
-    const nodeList = Array.from(nodes.values()).sort((left, right) => left.id.localeCompare(right.id));
-    const edgeList = Array.from(edges.values()).sort((left, right) => left.id.localeCompare(right.id));
-    const indexes = createCodexRunGraphIndexes(nodeList);
-    const nodeKinds = countCodexRunGraphValues(nodeList.map((node) => node.kind));
-    const edgeKinds = countCodexRunGraphValues(edgeList.map((edge) => edge.kind));
-    return {
-        kind: 'frontier.swarm-codex.run-graph',
-        version: 1,
-        id: `frontier-swarm-codex.run-graph:${path.basename(result.runDir) || 'run'}`,
-        generatedAt,
-        runDir: result.runDir,
-        outDir: result.outDir,
-        nodes: nodeList,
-        edges: edgeList,
-        indexes,
-        summary: {
-            nodeCount: nodeList.length,
-            edgeCount: edgeList.length,
-            nodeKinds,
-            edgeKinds,
-            taskCount: nodeKinds.task ?? 0,
-            jobCount: nodeKinds.job ?? 0,
-            candidateCount: nodeKinds.candidate ?? 0,
-            evidenceCount: nodeKinds.evidence ?? 0,
-            decisionCount: (nodeKinds.decision ?? 0) + (nodeKinds['queue-outcome'] ?? 0) + (nodeKinds['terminal-outcome'] ?? 0),
-            gateCount: nodeKinds.gate ?? 0,
-            semanticAdmissionCount: nodeKinds['semantic-admission'] ?? 0,
-            semanticCandidateCount: nodeKinds['semantic-candidate'] ?? 0,
-            semanticOwnershipRegionCount: nodeKinds['semantic-ownership-region'] ?? 0
-        }
-    };
-}
-function addCollectedBundleNodes(bucket, entry, semanticImportExpected, runNodeId, bucketNodeId, addNode, addEdge) {
-    const bundle = entry.bundle;
-    const semanticAdmission = classifyCodexSemanticCollectAdmission(bundle, {
-        hasActionablePatch: Boolean(entry.patchPath ?? bundle.patchPath),
-        semanticImportExpected
-    });
-    const jobNodeId = `job:${bundle.jobId}`;
-    const candidateNodeId = `candidate:${bundle.jobId}`;
-    const mergeNodeId = `merge:${bundle.id || bundle.jobId}`;
-    const taskNodeId = bundle.taskId ? `task:${bundle.taskId}` : undefined;
-    const bundleRefs = graphRefsFromUnknown(bundle);
-    const semanticSidecarProjection = createSemanticSidecarGraphProjection(entry);
-    if (taskNodeId) {
-        addNode({
-            id: taskNodeId,
-            kind: 'task',
-            label: bundle.taskId,
-            taskId: bundle.taskId,
-            lane: bundle.lane,
-            generatedAt: bundle.generatedAt,
-            data: { lane: bundle.lane, queueItemIds: bundle.queueItemIds, title: bundle.title }
-        });
-        addEdge('contains', runNodeId, taskNodeId);
-        addEdge('produces', taskNodeId, jobNodeId);
-    }
-    addNode({
-        id: jobNodeId,
-        kind: 'job',
-        label: bundle.jobId,
-        jobId: bundle.jobId,
-        taskId: bundle.taskId,
-        lane: bundle.lane,
-        model: bundleRefs.model,
-        computeId: bundleRefs.computeId,
-        modelTier: bundleRefs.modelTier,
-        bucket,
-        status: bundle.status,
-        generatedAt: bundle.generatedAt,
-        data: { lane: bundle.lane, changedPaths: bundle.changedPaths, ownershipViolations: bundle.ownershipViolations }
-    });
-    addEdge('contains', runNodeId, jobNodeId);
-    addNode({
-        id: candidateNodeId,
-        kind: 'candidate',
-        label: bundle.title ?? bundle.jobId,
-        jobId: bundle.jobId,
-        taskId: bundle.taskId,
-        lane: bundle.lane,
-        model: bundleRefs.model,
-        computeId: bundleRefs.computeId,
-        modelTier: bundleRefs.modelTier,
-        bucket,
-        status: bundle.status,
-        outcome: bundle.disposition,
-        generatedAt: bundle.generatedAt,
-        refs: graphNodeRefs(bundleRefs, { merge: mergeNodeId, bucket: bucketNodeId }),
-        data: {
-            mergeReadiness: bundle.mergeReadiness,
-            riskLevel: bundle.riskLevel,
-            autoMergeable: bundle.autoMergeable,
-            staleAgainstHead: bundle.staleAgainstHead,
-            semanticAdmission,
-            semanticSidecarAdmission: semanticSidecarProjection.summary,
-            reasons: bundle.reasons,
-            changedPaths: bundle.changedPaths,
-            patchPath: entry.patchPath ?? bundle.patchPath,
-            outputDir: entry.outputDir
-        }
-    });
-    addEdge('produces', jobNodeId, candidateNodeId);
-    addEdge('classifiedAs', bucketNodeId, candidateNodeId);
-    addSemanticSidecarAdmissionNodes(semanticSidecarProjection, bundle, candidateNodeId, addNode, addEdge);
-    addNode({
-        id: mergeNodeId,
-        kind: 'merge',
-        label: bundle.id || bundle.jobId,
-        jobId: bundle.jobId,
-        taskId: bundle.taskId,
-        lane: bundle.lane,
-        model: bundleRefs.model,
-        computeId: bundleRefs.computeId,
-        modelTier: bundleRefs.modelTier,
-        bucket,
-        status: bundle.status,
-        path: entry.mergePath,
-        generatedAt: bundle.generatedAt,
-        data: { patchHash: bundle.patchHash, branchName: bundle.branchName, commit: bundle.commit }
-    });
-    addEdge('produces', candidateNodeId, mergeNodeId);
-    for (const evidencePath of bundle.evidencePaths ?? []) {
-        const evidenceNodeId = `evidence:${stableCodexRunGraphPart(evidencePath)}`;
-        addNode({
-            id: evidenceNodeId,
-            kind: 'evidence',
-            label: path.basename(evidencePath),
-            jobId: bundle.jobId,
-            taskId: bundle.taskId,
-            lane: bundle.lane,
-            bucket,
-            path: evidencePath,
-            generatedAt: bundle.generatedAt
-        });
-        addEdge('produces', candidateNodeId, evidenceNodeId);
-    }
-    for (const command of bundle.commandsPassed ?? [])
-        addGateNode(command, 'passed', candidateNodeId, bundle.jobId, bundle.taskId, bucket, addNode, addEdge);
-    for (const command of bundle.commandsFailed ?? [])
-        addGateNode(command, 'failed', candidateNodeId, bundle.jobId, bundle.taskId, bucket, addNode, addEdge);
-    addBundleRoutingDecisionNodes(bundle, jobNodeId, candidateNodeId, addNode, addEdge);
-}
-function addSemanticSidecarAdmissionNodes(projection, bundle, candidateNodeId, addNode, addEdge) {
-    if (projection.candidates.length === 0)
-        return;
-    const refs = graphRefsFromUnknown(bundle);
-    const regionNodeIds = new Map();
-    for (const region of projection.ownershipRegions) {
-        const regionNodeId = `semantic-region:${bundle.jobId}:${stableCodexRunGraphPart(region.key)}`;
-        regionNodeIds.set(region.id ?? region.key, regionNodeId);
-        addNode({
-            id: regionNodeId,
-            kind: 'semantic-ownership-region',
-            label: region.label,
-            jobId: bundle.jobId,
-            taskId: bundle.taskId,
-            lane: bundle.lane,
-            status: region.status,
-            path: region.path,
-            generatedAt: bundle.generatedAt,
-            refs: graphNodeRefs(refs),
-            data: region.data
-        });
-        addEdge('produces', candidateNodeId, regionNodeId, 'semantic-ownership-region');
-    }
-    for (const candidate of projection.candidates) {
-        const semanticCandidateNodeId = `semantic-candidate:${bundle.jobId}:${stableCodexRunGraphPart(candidate.key)}`;
-        const admissionNodeId = `semantic-admission:${bundle.jobId}:${stableCodexRunGraphPart(candidate.key)}`;
-        addNode({
-            id: semanticCandidateNodeId,
-            kind: 'semantic-candidate',
-            label: candidate.label,
-            jobId: bundle.jobId,
-            taskId: bundle.taskId,
-            lane: bundle.lane,
-            status: candidate.status,
-            outcome: candidate.action,
-            path: candidate.path,
-            generatedAt: bundle.generatedAt,
-            refs: graphNodeRefs(refs, { candidate: candidateNodeId, admission: admissionNodeId }),
-            data: candidate.data
-        });
-        addEdge('produces', candidateNodeId, semanticCandidateNodeId, candidate.status);
-        addNode({
-            id: admissionNodeId,
-            kind: 'semantic-admission',
-            label: candidate.status,
-            jobId: bundle.jobId,
-            taskId: bundle.taskId,
-            lane: bundle.lane,
-            status: candidate.status,
-            outcome: candidate.action,
-            generatedAt: bundle.generatedAt,
-            refs: graphNodeRefs(refs, { candidate: semanticCandidateNodeId, bundleCandidate: candidateNodeId }),
-            data: compactRecord({
-                status: candidate.status,
-                action: candidate.action,
-                readiness: candidate.readiness,
-                risk: candidate.risk,
-                reasonCodes: candidate.reasonCodes,
-                reasons: candidate.reasons,
-                conflictKeys: candidate.conflictKeys,
-                ownershipRegionIds: candidate.ownershipRegionIds
-            })
-        });
-        addEdge('decides', admissionNodeId, semanticCandidateNodeId, candidate.status);
-        addEdge('decides', admissionNodeId, candidateNodeId, candidate.status);
-        for (const regionId of candidate.ownershipRegionIds) {
-            const regionNodeId = regionNodeIds.get(regionId);
-            if (regionNodeId)
-                addEdge('touches', semanticCandidateNodeId, regionNodeId, candidate.status);
-        }
-    }
-}
-function createSemanticSidecarGraphProjection(entry) {
-    const candidates = new Map();
-    const ownershipRegions = new Map();
-    const addRegion = (region) => {
-        const existing = ownershipRegions.get(region.key);
-        ownershipRegions.set(region.key, existing ? {
-            ...existing,
-            ...region,
-            data: compactRecord({ ...(existing.data ?? {}), ...(region.data ?? {}) })
-        } : region);
-    };
-    const addCandidate = (candidate) => {
-        const existing = candidates.get(candidate.key);
-        candidates.set(candidate.key, existing ? {
-            ...existing,
-            ...candidate,
-            reasonCodes: uniqueRunGraphStrings([...existing.reasonCodes, ...candidate.reasonCodes]),
-            reasons: uniqueRunGraphStrings([...existing.reasons, ...candidate.reasons]),
-            conflictKeys: uniqueRunGraphStrings([...existing.conflictKeys, ...candidate.conflictKeys]),
-            ownershipRegionIds: uniqueRunGraphStrings([...existing.ownershipRegionIds, ...candidate.ownershipRegionIds]),
-            data: compactRecord({ ...(existing.data ?? {}), ...(candidate.data ?? {}) })
-        } : candidate);
-    };
-    for (const source of semanticSidecarProjectionSources(entry)) {
-        addSemanticSidecarSourceProjection(source, addCandidate, addRegion);
-    }
-    const candidateList = Array.from(candidates.values()).sort((left, right) => left.key.localeCompare(right.key));
-    const regionList = Array.from(ownershipRegions.values()).sort((left, right) => left.key.localeCompare(right.key));
-    if (candidateList.length === 0)
-        return { candidates: candidateList, ownershipRegions: regionList };
-    const reasonCodes = uniqueRunGraphStrings(candidateList.flatMap((candidate) => candidate.reasonCodes));
-    const ownershipRegionIds = uniqueRunGraphStrings(candidateList.flatMap((candidate) => candidate.ownershipRegionIds));
-    return {
-        candidates: candidateList,
-        ownershipRegions: regionList,
-        summary: {
-            candidateCount: candidateList.length,
-            safeCount: candidateList.filter((candidate) => candidate.status === 'safe').length,
-            reviewCount: candidateList.filter((candidate) => candidate.status === 'review').length,
-            conflictCount: candidateList.filter((candidate) => candidate.status === 'conflict').length,
-            reasonCodes,
-            ownershipRegionIds
-        }
-    };
-}
-function semanticSidecarProjectionSources(entry) {
-    const bundle = entry.bundle;
-    const metadata = recordValue(bundle.metadata);
-    const sources = [];
-    pushSemanticSidecarSources(sources, bundle.semanticImport);
-    pushSemanticSidecarSources(sources, metadata?.semanticImport);
-    pushSemanticSidecarSources(sources, metadata?.semanticImports);
-    pushSemanticSidecarSources(sources, metadata?.semanticImportSidecar);
-    pushSemanticSidecarSources(sources, metadata?.semanticSidecar);
-    pushSemanticSidecarSources(sources, metadata?.semanticSidecars);
-    for (const sidecar of readSemanticSidecarEvidenceFiles(entry))
-        pushSemanticSidecarSources(sources, sidecar);
-    return uniqueRecords(sources);
-}
-function pushSemanticSidecarSources(out, value) {
-    if (Array.isArray(value)) {
-        for (const entry of value)
-            pushSemanticSidecarSources(out, entry);
-        return;
-    }
-    const record = recordValue(value);
-    if (record)
-        out.push(record);
-}
-function readSemanticSidecarEvidenceFiles(entry) {
-    const files = semanticSidecarEvidenceFileCandidates(entry);
-    const records = [];
-    const seen = new Set();
-    for (const file of files) {
-        if (seen.has(file))
-            continue;
-        seen.add(file);
-        try {
-            if (!fs.existsSync(file))
-                continue;
-            const parsed = JSON.parse(fs.readFileSync(file, 'utf8'));
-            const record = recordValue(parsed);
-            if (record)
-                records.push(record);
-        }
-        catch {
-            // Sidecar evidence is advisory for graph projection; collection should not fail on a malformed optional sidecar.
-        }
-    }
-    return records;
-}
-function semanticSidecarEvidenceFileCandidates(entry) {
-    const dirs = uniqueRunGraphStrings([entry.outputDir, path.dirname(entry.mergePath)]);
-    const files = [];
-    for (const evidencePath of entry.bundle.evidencePaths ?? []) {
-        if (path.basename(evidencePath) !== 'semantic-imports.json')
-            continue;
-        if (path.isAbsolute(evidencePath))
-            files.push(evidencePath);
-        else {
-            for (const dir of dirs)
-                files.push(path.resolve(dir, evidencePath));
-            for (const dir of dirs)
-                files.push(path.resolve(dir, path.basename(evidencePath)));
-        }
-    }
-    return uniqueRunGraphStrings(files);
-}
-function addSemanticSidecarSourceProjection(source, addCandidate, addRegion) {
-    const sourceRegions = semanticOwnershipRegionProjections(source);
-    for (const region of sourceRegions)
-        addRegion(region);
-    const records = recordsFromUnknown(source.records);
-    if (records.length > 0) {
-        records.forEach((record, index) => {
-            const recordRegions = uniqueSemanticRegionProjections([
-                ...sourceRegions,
-                ...semanticOwnershipRegionProjections(record)
-            ]);
-            for (const region of recordRegions)
-                addRegion(region);
-            const candidate = semanticCandidateProjectionFromRecord(record, recordRegions, index);
-            if (candidate)
-                addCandidate(candidate);
-        });
-        return;
-    }
-    const mergeCandidates = recordsFromUnknown(source.mergeCandidates);
-    mergeCandidates.forEach((candidate, index) => {
-        const projection = semanticCandidateProjectionFromCandidate(source, candidate, sourceRegions, index);
-        if (projection)
-            addCandidate(projection);
-    });
-    if (mergeCandidates.length === 0) {
-        const candidate = semanticCandidateProjectionFromRecord(source, sourceRegions, 0);
-        if (candidate)
-            addCandidate(candidate);
-    }
-}
-function semanticCandidateProjectionFromRecord(record, regions, index) {
-    const mergeCandidate = recordValue(record.mergeCandidate) ?? firstRecordAtPaths(record, [['semanticSidecar', 'mergeCandidate']]);
-    const semanticSliceAdmission = recordValue(record.semanticSliceAdmission);
-    const semanticSidecar = recordValue(record.semanticSidecar);
-    const semanticSlice = recordValue(record.semanticSlice);
-    const hasCandidate = Boolean(mergeCandidate || semanticSliceAdmission || semanticSidecar || semanticSlice);
-    if (!hasCandidate)
-        return undefined;
-    return semanticCandidateProjectionFromParts({
-        record,
-        candidate: mergeCandidate ?? {},
-        semanticSliceAdmission,
-        semanticSidecar,
-        semanticSlice,
-        regions,
-        index
-    });
-}
-function semanticCandidateProjectionFromCandidate(source, candidate, regions, index) {
-    return semanticCandidateProjectionFromParts({
-        record: source,
-        candidate,
-        semanticSidecar: source,
-        regions,
-        index
-    });
-}
-function semanticCandidateProjectionFromParts(input) {
-    const candidate = input.candidate;
-    const admission = input.semanticSliceAdmission;
-    const sidecar = input.semanticSidecar;
-    const semanticSlice = input.semanticSlice;
-    const sourcePath = firstString([input.record.path, candidate.path, sidecar?.sourcePath, recordValue(sidecar?.summary)?.sourcePath]);
-    const readiness = firstString([
-        candidate.readiness,
-        admission?.readiness,
-        semanticSlice?.readiness,
-        sidecar?.readiness,
-        recordValue(sidecar?.summary)?.readiness,
-        recordValue(input.record.nativeDiff)?.readiness
-    ]);
-    const action = firstString([
-        admission?.action,
-        candidate.action,
-        recordValue(sidecar?.admission)?.action,
-        sidecar?.semanticImportRecordAction,
-        recordValue(sidecar?.summary)?.semanticImportRecordAction
-    ]);
-    const risk = firstString([candidate.risk, admission?.risk, recordValue(admission?.mergeScore)?.risk]);
-    const reasonCodes = uniqueRunGraphStrings([
-        ...stringValues(candidate.reasonCodes),
-        ...stringValues(candidate.reasons),
-        ...stringValues(admission?.reasonCodes),
-        ...stringValues(admission?.reasons),
-        ...stringValues(recordValue(sidecar?.admission)?.reasonCodes),
-        ...stringValues(recordValue(sidecar?.quality)?.reasonCodes),
-        ...stringValues(sidecar?.semanticImportExpectedMissingReasonCodes),
-        ...stringValues(recordValue(sidecar?.summary)?.semanticImportExpectedMissingReasonCodes),
-        ...stringValues(recordValue(sidecar?.summary)?.semanticImportRecordReasonCode),
-        ...stringValues(input.record.reasonCodes),
-        ...stringValues(input.record.reasons)
-    ]);
-    const reasons = uniqueRunGraphStrings([
-        ...stringValues(candidate.reasons),
-        ...stringValues(admission?.reasons),
-        ...stringValues(recordValue(sidecar?.admission)?.reasons),
-        ...stringValues(input.record.reasons)
-    ]);
-    const conflictKeys = uniqueRunGraphStrings([
-        ...stringValues(candidate.conflictKeys),
-        ...stringValues(admission?.conflictKeys),
-        ...stringValues(semanticSlice?.conflictKeys),
-        ...stringValues(recordValue(candidate.conflictSummary)?.conflictKeys)
-    ]);
-    const ownershipRegionIds = uniqueRunGraphStrings([
-        ...input.regions.map((region) => region.id ?? region.key),
-        ...stringValues(candidate.ownershipRegionIds),
-        ...stringValues(admission?.ownershipRegionIds)
-    ]);
-    const status = semanticSidecarAdmissionStatus({
-        candidate,
-        admission,
-        sidecar,
-        semanticSlice,
-        readiness,
-        risk,
-        action,
-        reasonCodes,
-        reasons,
-        conflictKeys
-    });
-    const key = firstString([
-        candidate.id,
-        admission?.id,
-        input.record.importId,
-        sidecar?.id,
-        semanticSlice?.id,
-        sourcePath ? `${sourcePath}:${input.index}` : undefined
-    ]) ?? `semantic-candidate:${input.index}`;
-    return {
-        key,
-        label: sourcePath ? `${path.basename(sourcePath)}:${status}` : `${key}:${status}`,
-        status,
-        action,
-        path: sourcePath,
-        readiness,
-        risk,
-        reasonCodes,
-        reasons,
-        conflictKeys,
-        ownershipRegionIds,
-        data: compactRecord({
-            path: sourcePath,
-            readiness,
-            risk,
-            action,
-            reasonCodes,
-            reasons,
-            conflictKeys,
-            ownershipRegionIds,
-            mergeCandidate: Object.keys(candidate).length ? candidate : undefined,
-            semanticSliceAdmission: admission,
-            semanticSlice,
-            semanticSidecar: sidecar ? compactRecord({
-                kind: sidecar.kind,
-                id: sidecar.id,
-                readiness: sidecar.readiness,
-                symbols: sidecar.symbols,
-                ownershipRegions: sidecar.ownershipRegions,
-                patchHints: sidecar.patchHints,
-                semanticImportExpectedSatisfied: sidecar.semanticImportExpectedSatisfied,
-                semanticImportExpectedMissingReasonCodes: sidecar.semanticImportExpectedMissingReasonCodes,
-                sampleOwnershipRegions: sidecar.sampleOwnershipRegions
-            }) : undefined
-        })
-    };
-}
-function semanticSidecarAdmissionStatus(input) {
-    const statusSignals = uniqueRunGraphStrings([
-        input.readiness,
-        input.action,
-        input.risk,
-        stringFromUnknown(input.candidate.status),
-        stringFromUnknown(input.admission?.status),
-        stringFromUnknown(input.sidecar?.status),
-        stringFromUnknown(input.semanticSlice?.status),
-        ...input.reasonCodes,
-        ...input.reasons
-    ].filter((entry) => typeof entry === 'string')).map(normalizedSemanticSidecarSignal);
-    if (input.conflictKeys.length > 0 ||
-        statusSignals.some((signal) => signal.includes('conflict') || signal === 'blocked' || signal === 'block' || signal === 'reject' || signal === 'rejected')) {
-        return 'conflict';
-    }
-    if (booleanFromUnknown(input.admission?.reviewRequired) === true ||
-        statusSignals.some((signal) => signal === 'needs-review' ||
-            signal === 'ready-with-losses' ||
-            signal === 'manual-review' ||
-            signal === 'human-review' ||
-            signal === 'review' ||
-            signal === 'prioritize' ||
-            signal === 'medium' ||
-            signal === 'high')) {
-        return 'review';
-    }
-    if (booleanFromUnknown(input.candidate.mergeable) === true ||
-        booleanFromUnknown(input.admission?.autoMergeClaim) === true ||
-        statusSignals.some((signal) => signal === 'ready' || signal === 'admit' || signal === 'apply' || signal === 'auto-merge')) {
-        return 'safe';
-    }
-    return 'review';
-}
-function normalizedSemanticSidecarSignal(value) {
-    return value.trim().replace(/_/g, '-').toLowerCase();
-}
-function semanticOwnershipRegionProjections(record) {
-    const sidecar = recordValue(record.semanticSidecar);
-    return uniqueSemanticRegionProjections([
-        ...recordsFromUnknown(record.ownershipRegions).map(semanticOwnershipRegionProjection),
-        ...recordsFromUnknown(record.sampleOwnershipRegions).map(semanticOwnershipRegionProjection),
-        ...recordsFromUnknown(sidecar?.ownershipRegions).map(semanticOwnershipRegionProjection),
-        ...recordsFromUnknown(sidecar?.sampleOwnershipRegions).map(semanticOwnershipRegionProjection),
-        ...recordsFromUnknown(recordValue(record.semanticSlice)?.ownershipRegions).map(semanticOwnershipRegionProjection)
-    ].filter((entry) => Boolean(entry)));
-}
-function semanticOwnershipRegionProjection(region) {
-    const id = firstString([region.id, region.key, region.conflictKey]);
-    const sourcePath = firstString([region.sourcePath, region.path]);
-    const symbolName = stringFromUnknown(region.symbolName);
-    const key = id ?? firstString([sourcePath && symbolName ? `${sourcePath}:${symbolName}` : undefined, sourcePath]);
-    if (!key)
-        return undefined;
-    return {
-        key,
-        id,
-        label: symbolName ?? id ?? sourcePath ?? key,
-        path: sourcePath,
-        status: firstString([region.readiness, region.mergePolicy, region.precision]),
-        data: compactRecord({
-            id: region.id,
-            key: region.key,
-            conflictKey: region.conflictKey,
-            sourcePath,
-            symbolName,
-            symbolKind: region.symbolKind,
-            regionKind: region.regionKind,
-            granularity: region.granularity,
-            precision: region.precision,
-            mergePolicy: region.mergePolicy,
-            sourceSpan: region.sourceSpan
-        })
-    };
-}
-function uniqueSemanticRegionProjections(regions) {
-    const out = new Map();
-    for (const region of regions) {
-        if (!region)
-            continue;
-        const existing = out.get(region.key);
-        out.set(region.key, existing ? {
-            ...existing,
-            ...region,
-            data: compactRecord({ ...(existing.data ?? {}), ...(region.data ?? {}) })
-        } : region);
-    }
-    return Array.from(out.values());
-}
-function addGateNode(command, status, candidateNodeId, jobId, taskId, bucket, addNode, addEdge) {
-    const label = command.name ?? command.commandLine ?? command.command?.join(' ') ?? 'command';
-    const id = `gate:${jobId}:${stableCodexRunGraphPart(label)}`;
-    addNode({ id, kind: 'gate', label, jobId, taskId, bucket, status, data: { command } });
-    addEdge('verifies', id, candidateNodeId, status);
-}
-function addQueueOutcomeNodes(result, runNodeId, addNode, addEdge) {
-    for (const decision of result.queueOutcomeModel?.latestDecisions ?? []) {
-        const id = `decision:queue:${decision.id}`;
-        addNode({
-            id,
-            kind: 'decision',
-            label: decision.subjectId || decision.outcome,
-            jobId: decision.jobId,
-            taskId: decision.taskId,
-            lane: stringFromUnknown(decision.lane),
-            status: decision.category,
-            outcome: decision.outcome,
-            generatedAt: decision.generatedAt,
-            refs: graphNodeRefs(graphRefsFromUnknown(decision)),
-            data: { reasons: decision.reasons, queueItemIds: decision.queueItemIds }
-        });
-        addEdge('contains', runNodeId, id);
-        if (decision.jobId)
-            addEdge('decides', id, `candidate:${decision.jobId}`);
-    }
-}
-function addTerminalStateNodes(result, runNodeId, addNode, addEdge) {
-    for (const item of result.terminalState?.items ?? []) {
-        const id = `decision:terminal:${item.id}`;
-        addNode({
-            id,
-            kind: 'decision',
-            label: item.subjectId,
-            jobId: item.jobId,
-            taskId: stringFromUnknown(item.taskId),
-            lane: stringFromUnknown(item.lane),
-            status: item.bucket,
-            outcome: item.status,
-            generatedAt: item.generatedAt,
-            refs: graphNodeRefs(graphRefsFromUnknown(item)),
-            data: { queueItemIds: item.queueItemIds, subjectAliases: item.subjectAliases }
-        });
-        addEdge('contains', runNodeId, id);
-        if (item.jobId)
-            addEdge('decides', id, `candidate:${item.jobId}`);
-    }
-}
-function addTournamentNodes(result, runNodeId, graphRefs, addNode, addEdge) {
-    const tournament = result.strategyTournament;
-    if (!tournament)
-        return;
-    const tournamentRecord = tournament;
-    const tournamentSummary = recordValue(tournamentRecord.summary) ?? {};
-    const tournamentWinnerId = stringFromUnknown(tournamentRecord.winnerId);
-    const tournamentNodeId = `rsi:tournament:${tournament.id}`;
-    addNode({
-        id: tournamentNodeId,
-        kind: 'rsi',
-        label: tournament.title ?? tournament.id,
-        generatedAt: tournament.generatedAt,
-        data: { summary: tournament.summary, winnerId: tournamentWinnerId }
-    });
-    addEdge('contains', runNodeId, tournamentNodeId);
-    const projectedCandidates = [];
-    const candidates = Array.isArray(tournamentRecord.candidates) ? tournamentRecord.candidates : [];
-    for (const candidate of candidates) {
-        const record = recordValue(candidate) ?? {};
-        const refs = graphRefsFromUnknown(record);
-        const candidateId = tournamentCandidateGraphId(record, refs);
-        const outcome = tournamentCandidateOutcome(record);
-        const selected = isSelectedTournamentCandidate(record, tournamentWinnerId ?? stringFromUnknown(tournamentSummary.topStrategyId), refs);
-        const rejected = isRejectedTournamentCandidate(record);
-        const status = stringFromUnknown(record.status) ?? (selected ? 'selected' : outcome);
-        const id = `candidate:strategy:${candidateId}`;
-        const label = stringFromUnknown(record.title) ?? stringFromUnknown(record.strategyId) ?? refs.jobId ?? candidateId;
-        addNode({
-            id,
-            kind: 'candidate',
-            label,
-            jobId: refs.jobId,
-            taskId: refs.taskId,
-            lane: refs.lane,
-            model: refs.model,
-            computeId: refs.computeId,
-            modelTier: refs.modelTier,
-            status,
-            outcome,
-            generatedAt: tournament.generatedAt,
-            refs: graphNodeRefs(refs, { tournament: tournamentNodeId }),
-            data: compactRecord({
-                score: record.score,
-                reasons: record.reasons,
-                strategyId: record.strategyId,
-                disposition: record.disposition,
-                selected,
-                rejected,
-                taskKind: refs.taskKind,
-                workKind: refs.workKind
-            })
-        });
-        addEdge('contains', tournamentNodeId, id);
-        addEdge('decides', tournamentNodeId, id, status ?? outcome);
-        if (refs.jobId) {
-            addEdge('produces', `job:${refs.jobId}`, id, refs.lane);
-            addEdge(selected ? 'mergesInto' : 'supersedes', id, `candidate:${refs.jobId}`, status ?? outcome);
-        }
-        if (refs.taskId)
-            addEdge('produces', `task:${refs.taskId}`, id, refs.lane);
-        linkGraphNodeToAffectedRefs('decides', id, refs, graphRefs, addEdge, status ?? outcome);
-        projectedCandidates.push({ id, refs, selected, rejected, label });
-    }
-    const selectedCandidates = projectedCandidates.filter((candidate) => candidate.selected);
-    if (selectedCandidates.length > 0) {
-        for (const rejected of projectedCandidates.filter((candidate) => candidate.rejected || !candidate.selected)) {
-            for (const selected of selectedCandidates) {
-                if (selected.id !== rejected.id)
-                    addEdge('supersedes', selected.id, rejected.id, 'selected-over-rejected');
-            }
-        }
-    }
-}
-function addAdaptiveFeedbackNodes(result, runNodeId, graphRefs, addNode, addEdge) {
-    const feedback = result.tournamentAdaptiveFeedback;
-    if (!feedback)
-        return;
-    const id = `rsi:adaptive:${feedback.id}`;
-    addNode({
-        id,
-        kind: 'rsi',
-        label: feedback.id,
-        generatedAt: feedback.generatedAt,
-        refs: graphNodeRefs({}, {
-            ...(feedback.tournamentId ? { tournament: `rsi:tournament:${feedback.tournamentId}` } : {}),
-            ...(feedback.historyId ? { history: `rsi:history:${feedback.historyId}` } : {})
-        }),
-        data: { summary: feedback.summary, tournamentId: feedback.tournamentId, historyId: feedback.historyId }
-    });
-    addEdge('contains', runNodeId, id);
-    if (feedback.tournamentId)
-        addEdge('mergesInto', id, `rsi:tournament:${feedback.tournamentId}`);
-    feedback.observations.forEach((observation, index) => {
-        const refs = graphRefsFromUnknown(observation);
-        const observationRecord = recordValue(observation) ?? {};
-        const observationId = `feedback:adaptive-observation:${stableCodexRunGraphPart(`${feedback.id}:${stringFromUnknown(observationRecord.id) ?? index}:${JSON.stringify(observation)}`)}`;
-        addNode({
-            id: observationId,
-            kind: 'feedback',
-            label: stringFromUnknown(observation.reason) ?? stringFromUnknown(observation.kind) ?? `observation-${index + 1}`,
-            jobId: refs.jobId,
-            taskId: refs.taskId,
-            lane: refs.lane,
-            model: refs.model,
-            computeId: refs.computeId,
-            modelTier: refs.modelTier,
-            status: stringFromUnknown(observation.severity),
-            outcome: stringFromUnknown(observation.kind),
-            generatedAt: observation.at ?? feedback.generatedAt,
-            refs: graphNodeRefs(refs, { adaptive: id }),
-            data: compactRecord({ observation, taskKind: refs.taskKind, workKind: refs.workKind })
-        });
-        addEdge('produces', id, observationId, stringFromUnknown(observation.kind));
-        linkGraphNodeToAffectedRefs('verifies', observationId, refs, graphRefs, addEdge, stringFromUnknown(observation.kind));
-    });
-    feedback.recommendations.forEach((recommendation, index) => {
-        const recommendationRecord = recordValue(recommendation) ?? {};
-        const refs = graphRefsFromAdaptiveRecommendation(recommendationRecord);
-        const recommendationKey = stringFromUnknown(recommendationRecord.id) ?? `${recommendation.action ?? 'recommendation'}:${recommendation.target ?? ''}:${recommendation.key ?? ''}:${index}`;
-        const recommendationId = `decision:adaptive-recommendation:${stableCodexRunGraphPart(`${feedback.id}:${recommendationKey}`)}`;
-        addNode({
-            id: recommendationId,
-            kind: 'decision',
-            label: recommendation.reason ?? stringFromUnknown(recommendationRecord.id) ?? `recommendation-${index + 1}`,
-            jobId: refs.jobId,
-            taskId: refs.taskId,
-            lane: refs.lane,
-            model: refs.model,
-            computeId: refs.computeId,
-            modelTier: refs.modelTier,
-            status: recommendation.action,
-            outcome: recommendation.target,
-            generatedAt: feedback.generatedAt,
-            refs: graphNodeRefs(refs, { adaptive: id }),
-            data: compactRecord({
-                recommendation,
-                key: recommendation.key,
-                score: recommendation.score,
-                taskKind: refs.taskKind,
-                workKind: refs.workKind
-            })
-        });
-        addEdge('produces', id, recommendationId, recommendation.action);
-        linkGraphNodeToAffectedRefs('decides', recommendationId, refs, graphRefs, addEdge, recommendation.action);
-    });
-}
-function addBundleRoutingDecisionNodes(bundle, jobNodeId, candidateNodeId, addNode, addEdge) {
-    const metadata = recordValue(bundle.metadata);
-    if (!metadata)
-        return;
-    const bundleRefs = graphRefsFromUnknown(bundle);
-    const modelRoute = firstRecordAtPaths(metadata, [
-        ['modelRoute'],
-        ['routing', 'modelRoute'],
-        ['modelRouting', 'route'],
-        ['route']
-    ]);
-    const routeNodeId = modelRoute
-        ? addModelRouteDecisionNode(modelRoute, bundleRefs, jobNodeId, candidateNodeId, bundle.generatedAt, addNode, addEdge)
-        : undefined;
-    const panel = firstRecord([
-        modelRoute ? recordValue(modelRoute.panel) : undefined,
-        firstRecordAtPaths(metadata, [['panel'], ['panelEvaluation'], ['modelRouting', 'panel'], ['routing', 'panel']])
-    ]);
-    const panelNodeId = panel
-        ? addPanelDecisionNode(panel, bundleRefs, routeNodeId ?? jobNodeId, candidateNodeId, bundle.generatedAt, addNode, addEdge)
-        : undefined;
-    const fuserComputeId = stringValueAtPaths(modelRoute ?? {}, [['fuserComputeId'], ['fuser', 'computeId']])
-        ?? stringValueAtPaths(panel ?? {}, [['fuserComputeId'], ['fuser', 'computeId']])
-        ?? stringValueAtPaths(metadata, [['fusionDecision', 'fuserComputeId'], ['fusion', 'fuserComputeId']]);
-    if (fuserComputeId) {
-        addFusionDecisionNode({ fuserComputeId, route: stringFromUnknown(modelRoute?.route), panelId: stringFromUnknown(panel?.id) }, bundleRefs, panelNodeId ?? routeNodeId ?? jobNodeId, routeNodeId ?? panelNodeId, candidateNodeId, bundle.generatedAt, addNode, addEdge);
-    }
-    for (const feedback of modelRoutingFeedbackRecords(metadata)) {
-        const refs = { ...bundleRefs, ...graphRefsFromUnknown(feedback) };
-        const feedbackId = `feedback:model-routing:${stableCodexRunGraphPart(stringFromUnknown(feedback.id) ?? `${bundle.jobId}:${JSON.stringify(feedback)}`)}`;
-        addNode({
-            id: feedbackId,
-            kind: 'feedback',
-            label: stringFromUnknown(feedback.resultStatus) ?? stringFromUnknown(feedback.id) ?? 'model-routing-feedback',
-            jobId: refs.jobId,
-            taskId: refs.taskId,
-            lane: refs.lane,
-            model: refs.model,
-            computeId: refs.computeId,
-            modelTier: refs.modelTier,
-            status: stringFromUnknown(feedback.resultStatus),
-            outcome: stringFromUnknown(feedback.mergeDisposition),
-            generatedAt: numberFromUnknown(feedback.generatedAt) ?? bundle.generatedAt,
-            refs: graphNodeRefs(refs, { ...(routeNodeId ? { route: routeNodeId } : {}) }),
-            data: compactRecord({ feedback, taskKind: refs.taskKind, workKind: refs.workKind })
-        });
-        addEdge('produces', jobNodeId, feedbackId);
-        addEdge('verifies', feedbackId, candidateNodeId, stringFromUnknown(feedback.resultStatus));
-        if (routeNodeId)
-            addEdge('mergesInto', feedbackId, routeNodeId);
-    }
-}
-function addModelRouteDecisionNode(route, fallbackRefs, jobNodeId, candidateNodeId, generatedAt, addNode, addEdge) {
-    const refs = {
-        ...fallbackRefs,
-        computeId: stringFromUnknown(route.selectedComputeId)
-            ?? stringFromUnknown(route.recommendedComputeId)
-            ?? stringArray(route.recommendedComputeIds)[0]
-            ?? fallbackRefs.computeId
-    };
-    const routeId = `decision:model-route:${fallbackRefs.jobId ?? 'job'}:${stableCodexRunGraphPart(stringFromUnknown(route.id) ?? JSON.stringify(route))}`;
-    addNode({
-        id: routeId,
-        kind: 'decision',
-        label: stringFromUnknown(route.route) ?? stringFromUnknown(route.id) ?? 'model-route',
-        jobId: refs.jobId,
-        taskId: refs.taskId,
-        lane: refs.lane,
-        model: refs.model,
-        computeId: refs.computeId,
-        modelTier: refs.modelTier,
-        status: stringFromUnknown(route.mode),
-        outcome: stringFromUnknown(route.route),
-        generatedAt,
-        refs: graphNodeRefs(refs),
-        data: compactRecord({
-            route: route.route,
-            mode: route.mode,
-            fallbackComputeId: route.fallbackComputeId,
-            selectedComputeId: route.selectedComputeId,
-            recommendedComputeIds: route.recommendedComputeIds,
-            summary: route.summary,
-            reasons: route.reasons
-        })
-    });
-    addEdge('produces', jobNodeId, routeId, stringFromUnknown(route.route));
-    addEdge('decides', routeId, candidateNodeId, stringFromUnknown(route.route));
-    return routeId;
-}
-function addPanelDecisionNode(panel, fallbackRefs, parentNodeId, candidateNodeId, generatedAt, addNode, addEdge) {
-    const panelId = `decision:panel:${fallbackRefs.jobId ?? 'job'}:${stableCodexRunGraphPart(stringFromUnknown(panel.id) ?? JSON.stringify(panel))}`;
-    const refs = {
-        ...fallbackRefs,
-        computeId: stringFromUnknown(panel.fuserComputeId) ?? fallbackRefs.computeId
-    };
-    addNode({
-        id: panelId,
-        kind: 'decision',
-        label: stringFromUnknown(panel.strategy) ?? stringFromUnknown(panel.id) ?? 'panel',
-        jobId: refs.jobId,
-        taskId: refs.taskId,
-        lane: refs.lane,
-        model: refs.model,
-        computeId: refs.computeId,
-        modelTier: refs.modelTier,
-        status: booleanFromUnknown(panel.recommended) === false ? 'observed' : 'recommended',
-        outcome: stringFromUnknown(panel.strategy),
-        generatedAt,
-        refs: graphNodeRefs(refs),
-        data: compactRecord({
-            strategy: panel.strategy,
-            memberComputeIds: panel.memberComputeIds,
-            fuserComputeId: panel.fuserComputeId,
-            summary: panel.summary,
-            reasons: panel.reasons
-        })
-    });
-    addEdge('produces', parentNodeId, panelId, stringFromUnknown(panel.strategy));
-    addEdge('decides', panelId, candidateNodeId, stringFromUnknown(panel.strategy));
-    addEdge('mergesInto', panelId, parentNodeId);
-    return panelId;
-}
-function addFusionDecisionNode(fusion, fallbackRefs, parentNodeId, routeNodeId, candidateNodeId, generatedAt, addNode, addEdge) {
-    const fusionNodeId = `decision:fusion:${fallbackRefs.jobId ?? 'job'}:${stableCodexRunGraphPart(fusion.fuserComputeId)}`;
-    const refs = { ...fallbackRefs, computeId: fusion.fuserComputeId };
-    addNode({
-        id: fusionNodeId,
-        kind: 'decision',
-        label: fusion.fuserComputeId,
-        jobId: refs.jobId,
-        taskId: refs.taskId,
-        lane: refs.lane,
-        model: refs.model,
-        computeId: refs.computeId,
-        modelTier: refs.modelTier,
-        status: 'fusion',
-        outcome: fusion.route,
-        generatedAt,
-        refs: graphNodeRefs(refs, { ...(fusion.panelId ? { panel: fusion.panelId } : {}) }),
-        data: compactRecord({ fuserComputeId: fusion.fuserComputeId, route: fusion.route })
-    });
-    addEdge('produces', parentNodeId, fusionNodeId, 'fusion');
-    addEdge('decides', fusionNodeId, candidateNodeId, 'fusion');
-    if (routeNodeId)
-        addEdge('mergesInto', fusionNodeId, routeNodeId);
-    return fusionNodeId;
-}
-function createRunGraphReferenceIndex(result) {
-    const jobIds = new Set();
-    const taskIds = new Set();
-    const jobIdsByLane = new Map();
-    const taskIdsByLane = new Map();
-    for (const entries of Object.values(result.buckets)) {
-        for (const entry of entries) {
-            const { bundle } = entry;
-            jobIds.add(bundle.jobId);
-            if (bundle.taskId)
-                taskIds.add(bundle.taskId);
-            if (bundle.lane) {
-                pushUniqueMapValue(jobIdsByLane, bundle.lane, bundle.jobId);
-                if (bundle.taskId)
-                    pushUniqueMapValue(taskIdsByLane, bundle.lane, bundle.taskId);
-            }
-        }
-    }
-    return { jobIds, taskIds, jobIdsByLane, taskIdsByLane };
-}
-function pushUniqueMapValue(map, key, value) {
-    const next = map.get(key) ?? [];
-    if (!next.includes(value))
-        next.push(value);
-    map.set(key, next);
-}
-function linkGraphNodeToAffectedRefs(kind, from, refs, graphRefs, addEdge, label) {
-    const targets = new Set();
-    if (refs.jobId && graphRefs.jobIds.has(refs.jobId)) {
-        targets.add(`job:${refs.jobId}`);
-        targets.add(`candidate:${refs.jobId}`);
-    }
-    if (refs.taskId && graphRefs.taskIds.has(refs.taskId))
-        targets.add(`task:${refs.taskId}`);
-    if (targets.size === 0 && refs.lane) {
-        for (const jobId of graphRefs.jobIdsByLane.get(refs.lane) ?? []) {
-            targets.add(`job:${jobId}`);
-            targets.add(`candidate:${jobId}`);
-        }
-        for (const taskId of graphRefs.taskIdsByLane.get(refs.lane) ?? [])
-            targets.add(`task:${taskId}`);
-    }
-    for (const target of targets)
-        addEdge(kind, from, target, label);
-}
-function graphRefsFromAdaptiveRecommendation(recommendation) {
-    const metadata = recordValue(recommendation.metadata);
-    const refs = graphRefsFromUnknown({ ...recommendation, ...(metadata ? { metadata } : {}) });
-    const target = recommendation.target?.trim().toLowerCase();
-    return {
-        ...refs,
-        lane: refs.lane ?? (target && ['lane', 'max-ready-jobs', 'concurrency'].includes(target) ? recommendation.key : undefined),
-        model: refs.model ?? recommendation.model,
-        computeId: refs.computeId ?? recommendation.computeId
-    };
-}
-function graphRefsFromUnknown(value) {
-    const record = recordValue(value) ?? {};
-    const metadata = recordValue(record.metadata) ?? {};
-    const bundle = recordValue(record.bundle) ?? {};
-    const routing = firstRecord([recordValue(record.routing), recordValue(metadata.routing)]);
-    const routingKey = firstRecord([recordValue(record.routingKey), recordValue(metadata.routingKey)]);
-    const task = firstRecord([recordValue(record.task), recordValue(metadata.task), recordValue(bundle.task)]);
-    const compute = firstRecord([recordValue(record.compute), recordValue(metadata.compute), recordValue(recordValue(record.job)?.compute), recordValue(recordValue(metadata.job)?.compute)]);
-    const tournamentStrategy = firstRecord([recordValue(record.tournamentStrategy), recordValue(metadata.tournamentStrategy), recordValue(recordValue(bundle.metadata)?.tournamentStrategy)]);
-    const tournamentRoutingKey = recordValue(tournamentStrategy?.routingKey);
-    return {
-        jobId: firstString([
-            record.jobId,
-            bundle.jobId,
-            metadata.jobId,
-            recordValue(metadata.job)?.id,
-            recordValue(metadata.source)?.jobId
-        ]),
-        taskId: firstString([
-            record.taskId,
-            bundle.taskId,
-            metadata.taskId,
-            task?.id,
-            recordValue(metadata.source)?.taskId
-        ]),
-        lane: firstString([
-            record.lane,
-            bundle.lane,
-            metadata.lane,
-            routingKey?.lane,
-            routing?.lane,
-            task?.lane,
-            tournamentStrategy?.lane,
-            tournamentRoutingKey?.lane
-        ]),
-        model: firstString([
-            record.model,
-            metadata.model,
-            compute?.model,
-            tournamentStrategy?.model
-        ]),
-        computeId: firstString([
-            record.computeId,
-            metadata.computeId,
-            compute?.id,
-            recordValue(metadata.resourceAllocation)?.env && recordValue(recordValue(metadata.resourceAllocation)?.env)?.FRONTIER_SWARM_COMPUTE_ID
-        ]),
-        modelTier: firstString([
-            record.modelTier,
-            metadata.modelTier,
-            metadata.tier,
-            routingKey?.modelTier,
-            routing?.modelTier,
-            compute?.modelTier,
-            compute?.tier,
-            tournamentStrategy?.modelTier,
-            tournamentRoutingKey?.modelTier
-        ]),
-        taskKind: firstString([
-            record.taskKind,
-            metadata.taskKind,
-            routingKey?.taskKind,
-            routing?.taskKind,
-            task?.kind,
-            tournamentStrategy?.taskKind,
-            tournamentRoutingKey?.taskKind
-        ]),
-        workKind: firstString([
-            record.workKind,
-            metadata.workKind,
-            routingKey?.workKind,
-            routing?.workKind,
-            task?.workKind,
-            tournamentStrategy?.workKind,
-            tournamentRoutingKey?.workKind
-        ])
-    };
-}
-function graphNodeRefs(refs, extra = {}) {
-    const out = {};
-    if (refs.jobId) {
-        out.job = `job:${refs.jobId}`;
-        out.candidate = `candidate:${refs.jobId}`;
-    }
-    if (refs.taskId)
-        out.task = `task:${refs.taskId}`;
-    if (refs.lane)
-        out.lane = refs.lane;
-    if (refs.model)
-        out.model = refs.model;
-    if (refs.computeId)
-        out.compute = refs.computeId;
-    if (refs.modelTier)
-        out.modelTier = refs.modelTier;
-    for (const [key, value] of Object.entries(extra)) {
-        if (value)
-            out[key] = value;
-    }
-    return Object.keys(out).length > 0 ? out : undefined;
-}
-function tournamentCandidateGraphId(record, refs) {
-    return stringFromUnknown(record.id)
-        ?? stringFromUnknown(record.candidateId)
-        ?? stringFromUnknown(record.strategyId)
-        ?? refs.jobId
-        ?? String(hashCodexRunGraphString(JSON.stringify(record)));
-}
-function tournamentCandidateOutcome(record) {
-    return firstString([record.outcome, record.disposition, record.status]);
-}
-function isSelectedTournamentCandidate(record, winnerId, refs) {
-    const status = tournamentCandidateOutcome(record)?.toLowerCase();
-    if (booleanFromUnknown(record.selected) === true || status === 'selected' || status === 'winner')
-        return true;
-    if (!winnerId)
-        return false;
-    return [
-        stringFromUnknown(record.id),
-        stringFromUnknown(record.strategyId),
-        stringFromUnknown(record.candidateId),
-        refs.jobId,
-        refs.lane
-    ].includes(winnerId);
-}
-function isRejectedTournamentCandidate(record) {
-    const outcome = tournamentCandidateOutcome(record)?.toLowerCase();
-    return ['rejected', 'blocked', 'failed', 'declined', 'superseded'].includes(outcome ?? '');
-}
-function modelRoutingFeedbackRecords(metadata) {
-    return uniqueRecords([
-        ...recordsFromUnknown(metadata.modelRoutingFeedback),
-        ...recordsFromUnknown(metadata.routingFeedback),
-        ...recordsFromUnknown(recordValue(metadata.routingPolicy)?.feedback),
-        ...recordsFromUnknown(recordValue(metadata.modelRoutingPolicy)?.feedback)
-    ]);
-}
-function uniqueRecords(records) {
-    const seen = new Set();
-    const out = [];
-    for (const record of records) {
-        const key = stringFromUnknown(record.id) ?? JSON.stringify(record);
-        if (seen.has(key))
-            continue;
-        seen.add(key);
-        out.push(record);
-    }
-    return out;
-}
-function recordsFromUnknown(value) {
-    if (Array.isArray(value))
-        return value.map(recordValue).filter((entry) => Boolean(entry));
-    const record = recordValue(value);
-    return record ? [record] : [];
-}
-function firstRecordAtPaths(record, paths) {
-    for (const pathParts of paths) {
-        let cursor = record;
-        for (const part of pathParts)
-            cursor = recordValue(cursor)?.[part];
-        const found = recordValue(cursor);
-        if (found)
-            return found;
-    }
-    return undefined;
-}
-function stringValueAtPaths(record, paths) {
-    for (const pathParts of paths) {
-        let cursor = record;
-        for (const part of pathParts)
-            cursor = recordValue(cursor)?.[part];
-        const found = stringFromUnknown(cursor);
-        if (found)
-            return found;
-    }
-    return undefined;
-}
-function firstRecord(records) {
-    return records.find((entry) => Boolean(entry));
-}
-function firstString(values) {
-    for (const value of values) {
-        const found = stringFromUnknown(value);
-        if (found)
-            return found;
-    }
-    return undefined;
-}
-function stringArray(value) {
-    return Array.isArray(value) ? value.filter((entry) => typeof entry === 'string' && entry.length > 0) : [];
-}
-function stringValues(value) {
-    const single = stringFromUnknown(value);
-    if (single)
-        return [single];
-    return stringArray(value);
-}
-function uniqueRunGraphStrings(values) {
-    const out = [];
-    const seen = new Set();
-    for (const value of values) {
-        const normalized = stringFromUnknown(value);
-        if (!normalized || seen.has(normalized))
-            continue;
-        seen.add(normalized);
-        out.push(normalized);
-    }
-    return out;
-}
-function recordValue(value) {
-    return value && typeof value === 'object' && !Array.isArray(value) ? value : undefined;
-}
-function numberFromUnknown(value) {
-    return typeof value === 'number' && Number.isFinite(value) ? value : undefined;
-}
-function booleanFromUnknown(value) {
-    return typeof value === 'boolean' ? value : undefined;
-}
-function compactRecord(record) {
-    const out = {};
-    for (const [key, value] of Object.entries(record)) {
-        if (value !== undefined)
-            out[key] = value;
-    }
-    return out;
-}
-//# sourceMappingURL=collect-run-graph.js.map