@shapeshift-labs/frontier-swarm 0.3.0 → 0.5.0

package/dist/index.js

@@ -30,6 +30,64 @@ export const FRONTIER_SWARM_MERGE_PLAN_KIND = 'frontier.swarm.merge-plan';
 export const FRONTIER_SWARM_MERGE_PLAN_VERSION = 1;
 export const FRONTIER_SWARM_MERGE_BUNDLE_KIND = 'frontier.swarm.merge-bundle';
 export const FRONTIER_SWARM_MERGE_BUNDLE_VERSION = 1;
+export const FRONTIER_SWARM_QUEUE_OVERLAY_KIND = 'frontier.swarm.queue-overlay';
+export const FRONTIER_SWARM_QUEUE_OVERLAY_VERSION = 1;
+export const FRONTIER_SWARM_MERGE_INDEX_KIND = 'frontier.swarm.merge-index';
+export const FRONTIER_SWARM_MERGE_INDEX_VERSION = 1;
+export const FRONTIER_SWARM_HOTSPOT_REPORT_KIND = 'frontier.swarm.hotspot-report';
+export const FRONTIER_SWARM_HOTSPOT_REPORT_VERSION = 1;
+export const FRONTIER_SWARM_REVIEWER_LANE_PLAN_KIND = 'frontier.swarm.reviewer-lane-plan';
+export const FRONTIER_SWARM_REVIEWER_LANE_PLAN_VERSION = 1;
+export const FRONTIER_SWARM_RUN_STORE_SHARDS_KIND = 'frontier.swarm.run-store-shards';
+export const FRONTIER_SWARM_RUN_STORE_SHARDS_VERSION = 1;
+export const FRONTIER_SWARM_MERGE_ADMISSION_KIND = 'frontier.swarm.merge-admission';
+export const FRONTIER_SWARM_MERGE_ADMISSION_VERSION = 1;
+export const FRONTIER_SWARM_CONTEXT_PACK_KIND = 'frontier.swarm.context-pack';
+export const FRONTIER_SWARM_CONTEXT_PACK_VERSION = 1;
+export const FRONTIER_SWARM_ORACLE_CORPUS_KIND = 'frontier.swarm.oracle-corpus';
+export const FRONTIER_SWARM_ORACLE_CORPUS_VERSION = 1;
+export const FRONTIER_SWARM_REPLAY_BUNDLE_KIND = 'frontier.swarm.replay-bundle';
+export const FRONTIER_SWARM_REPLAY_BUNDLE_VERSION = 1;
+export const FRONTIER_SWARM_PARITY_ORACLE_KIND = 'frontier.swarm.parity-oracle';
+export const FRONTIER_SWARM_PARITY_ORACLE_VERSION = 1;
+export const FRONTIER_SWARM_DIVERGENCE_REPORT_KIND = 'frontier.swarm.divergence-report';
+export const FRONTIER_SWARM_DIVERGENCE_REPORT_VERSION = 1;
+export const FRONTIER_SWARM_OBSERVABILITY_POINT_KIND = 'frontier.swarm.observability-point';
+export const FRONTIER_SWARM_OBSERVABILITY_POINT_VERSION = 1;
+export const FRONTIER_SWARM_WATCHPOINT_PLAN_KIND = 'frontier.swarm.watchpoint-plan';
+export const FRONTIER_SWARM_WATCHPOINT_PLAN_VERSION = 1;
+export const FRONTIER_SWARM_DEBUG_HANDOFF_KIND = 'frontier.swarm.debug-handoff';
+export const FRONTIER_SWARM_DEBUG_HANDOFF_VERSION = 1;
+export const FRONTIER_SWARM_INSTRUMENTATION_BUDGET_KIND = 'frontier.swarm.instrumentation-budget';
+export const FRONTIER_SWARM_INSTRUMENTATION_BUDGET_VERSION = 1;
+export const FRONTIER_SWARM_BOTTLENECK_REPORT_KIND = 'frontier.swarm.bottleneck-report';
+export const FRONTIER_SWARM_BOTTLENECK_REPORT_VERSION = 1;
+export const FRONTIER_SWARM_EVIDENCE_INDEX_KIND = 'frontier.swarm.evidence-index';
+export const FRONTIER_SWARM_EVIDENCE_INDEX_VERSION = 1;
+export const FRONTIER_SWARM_BLACKBOARD_KIND = 'frontier.swarm.blackboard';
+export const FRONTIER_SWARM_BLACKBOARD_VERSION = 1;
+export const FRONTIER_SWARM_REFERENCE_ORACLE_PLAN_KIND = 'frontier.swarm.reference-oracle-plan';
+export const FRONTIER_SWARM_REFERENCE_ORACLE_PLAN_VERSION = 1;
+export const FRONTIER_SWARM_REFERENCE_ORACLE_RESPONSE_KIND = 'frontier.swarm.reference-oracle-response';
+export const FRONTIER_SWARM_REFERENCE_ORACLE_RESPONSE_VERSION = 1;
+export const FRONTIER_SWARM_ARTIFACT_ROUTING_PLAN_KIND = 'frontier.swarm.artifact-routing-plan';
+export const FRONTIER_SWARM_ARTIFACT_ROUTING_PLAN_VERSION = 1;
+export const FRONTIER_SWARM_SCHEDULER_RECOMMENDATIONS_KIND = 'frontier.swarm.scheduler-recommendations';
+export const FRONTIER_SWARM_SCHEDULER_RECOMMENDATIONS_VERSION = 1;
+export const FRONTIER_SWARM_FIXTURE_CATALOG_KIND = 'frontier.swarm.fixture-catalog';
+export const FRONTIER_SWARM_FIXTURE_CATALOG_VERSION = 1;
+export const FRONTIER_SWARM_PROGRESS_MODEL_KIND = 'frontier.swarm.progress-model';
+export const FRONTIER_SWARM_PROGRESS_MODEL_VERSION = 1;
+export const FRONTIER_SWARM_AUTO_REVIEW_REPORT_KIND = 'frontier.swarm.auto-review-report';
+export const FRONTIER_SWARM_AUTO_REVIEW_REPORT_VERSION = 1;
+export const FRONTIER_SWARM_REBASE_REPORT_KIND = 'frontier.swarm.rebase-report';
+export const FRONTIER_SWARM_REBASE_REPORT_VERSION = 1;
+export const FRONTIER_SWARM_USAGE_GOVERNOR_KIND = 'frontier.swarm.usage-governor';
+export const FRONTIER_SWARM_USAGE_GOVERNOR_VERSION = 1;
+export const FRONTIER_SWARM_LANE_PLAYBOOK_KIND = 'frontier.swarm.lane-playbook';
+export const FRONTIER_SWARM_LANE_PLAYBOOK_VERSION = 1;
+export const FRONTIER_SWARM_PATCH_STACK_PLAN_KIND = 'frontier.swarm.patch-stack-plan';
+export const FRONTIER_SWARM_PATCH_STACK_PLAN_VERSION = 1;
 export const FRONTIER_SWARM_DEFAULT_CODEX_COMPUTE_ID = 'codex.gpt-5.5.xhigh';
 export const FRONTIER_SWARM_DEFAULT_MODEL = 'gpt-5.5';
 export const FRONTIER_SWARM_DEFAULT_REASONING_EFFORT = 'xhigh';
@@ -426,6 +484,1121 @@ export function createSwarmMergeBundle(input) {
         ...(toJsonObject(input.metadata) ? { metadata: toJsonObject(input.metadata) } : {})
     };
 }
+export function createSwarmQueueOverlay(input = {}) {
+    const generatedAt = input.generatedAt ?? Date.now();
+    const entries = [];
+    for (const bundle of input.bundles ?? []) {
+        const status = queueOverlayStatusFromBundle(bundle);
+        const queueItemIds = bundle.queueItemIds.length ? bundle.queueItemIds : [bundle.taskId ?? bundle.jobId];
+        for (const queueItemId of queueItemIds) {
+            entries.push({
+                queueItemId,
+                jobId: bundle.jobId,
+                status,
+                mergeReadiness: bundle.mergeReadiness,
+                disposition: bundle.disposition,
+                riskLevel: bundle.riskLevel,
+                ...(bundle.patchPath ? { patchPath: bundle.patchPath } : {}),
+                evidencePaths: [...bundle.evidencePaths],
+                changedPaths: [...bundle.changedPaths],
+                changedRegions: [...bundle.changedRegions],
+                reasons: [...bundle.reasons],
+                generatedAt: bundle.generatedAt
+            });
+        }
+    }
+    for (const raw of input.results ?? []) {
+        const result = isSwarmJobResult(raw) ? cloneJsonValue(raw) : normalizeResult(raw);
+        const queueItemIds = result.queueItemIds.length ? result.queueItemIds : [result.jobId];
+        for (const queueItemId of queueItemIds) {
+            entries.push({
+                queueItemId,
+                jobId: result.jobId,
+                status: queueOverlayStatusFromResult(result),
+                mergeReadiness: result.mergeReadiness,
+                disposition: result.mergeDisposition,
+                riskLevel: result.riskLevel,
+                ...(result.patchPath ? { patchPath: result.patchPath } : {}),
+                evidencePaths: [...result.evidencePaths],
+                changedPaths: [...result.changedPaths],
+                changedRegions: [...result.changedRegions],
+                reasons: result.error ? [result.error] : [],
+                generatedAt
+            });
+        }
+    }
+    const byQueueItemId = groupOverlayEntries(entries);
+    return {
+        kind: FRONTIER_SWARM_QUEUE_OVERLAY_KIND,
+        version: FRONTIER_SWARM_QUEUE_OVERLAY_VERSION,
+        id: input.id ?? 'swarm-queue-overlay:' + stableHash([input.runId, entries, generatedAt]),
+        ...(input.runId ? { runId: input.runId } : {}),
+        generatedAt,
+        entries,
+        byQueueItemId,
+        summary: {
+            entryCount: entries.length,
+            queueItemCount: Object.keys(byQueueItemId).length,
+            readyToApplyCount: entries.filter((entry) => entry.status === 'ready-to-apply').length,
+            needsHumanPortCount: entries.filter((entry) => entry.status === 'needs-human-port').length,
+            failedEvidenceCount: entries.filter((entry) => entry.status === 'failed-evidence').length,
+            staleAgainstHeadCount: entries.filter((entry) => entry.status === 'stale-against-head').length,
+            discoveryOnlyCount: entries.filter((entry) => entry.status === 'discovery-only').length
+        },
+        ...(toJsonObject(input.metadata) ? { metadata: toJsonObject(input.metadata) } : {})
+    };
+}
+export function deriveSwarmQueueStatus(input) {
+    const generatedAt = input.generatedAt ?? Date.now();
+    const latestByQueueItem = new Map();
+    for (const overlay of input.overlays ?? []) {
+        for (const entry of overlay.entries) {
+            const existing = latestByQueueItem.get(entry.queueItemId);
+            if (!existing || entry.generatedAt >= existing.generatedAt)
+                latestByQueueItem.set(entry.queueItemId, entry);
+        }
+    }
+    const jobs = input.snapshot.jobs.map((job) => {
+        const overlay = latestByQueueItem.get(job.taskId ?? job.jobId) ?? latestByQueueItem.get(job.jobId);
+        if (!overlay)
+            return cloneJsonValue(job);
+        return {
+            ...cloneJsonValue(job),
+            status: queueJobStatusFromOverlay(overlay),
+            lastError: overlay.status === 'failed-evidence' || overlay.status === 'stale-against-head' ? overlay.reasons.join(', ') : job.lastError,
+            metadata: toJsonObject({
+                ...(job.metadata ?? {}),
+                overlayStatus: overlay.status,
+                mergeDisposition: overlay.disposition,
+                mergeReadiness: overlay.mergeReadiness,
+                evidencePaths: overlay.evidencePaths
+            })
+        };
+    });
+    const byStatus = groupIds(jobs, (job) => job.status);
+    return {
+        generatedAt,
+        jobs,
+        byStatus,
+        summary: {
+            jobCount: jobs.length,
+            leaseCount: input.snapshot.leases.length,
+            readyCount: byStatus.ready?.length ?? 0,
+            leasedCount: byStatus.leased?.length ?? 0,
+            completedCount: byStatus.completed?.length ?? 0,
+            failedCount: byStatus.failed?.length ?? 0,
+            deadLetterCount: byStatus['dead-letter']?.length ?? 0
+        }
+    };
+}
+export function createSwarmMergeIndex(input) {
+    const generatedAt = input.generatedAt ?? Date.now();
+    const entries = input.bundles.map((bundle) => {
+        const patchStatus = input.patchStatuses?.[bundle.jobId] ?? (bundle.staleAgainstHead ? 'stale' : bundle.patchPath ? 'unknown' : 'missing');
+        const staleAgainstHead = bundle.staleAgainstHead || patchStatus === 'stale' || patchStatus === 'failed-check';
+        return {
+            jobId: bundle.jobId,
+            ...(bundle.taskId ? { taskId: bundle.taskId } : {}),
+            ...(bundle.lane ? { lane: bundle.lane } : {}),
+            ...(bundle.title ? { title: bundle.title } : {}),
+            status: bundle.status,
+            mergeReadiness: bundle.mergeReadiness,
+            disposition: staleAgainstHead ? 'stale-against-head' : bundle.disposition,
+            riskLevel: bundle.riskLevel,
+            patchStatus,
+            staleAgainstHead,
+            autoMergeable: bundle.autoMergeable && !staleAgainstHead,
+            changedPaths: [...bundle.changedPaths],
+            changedRegions: [...bundle.changedRegions],
+            conflictKeys: mergeIndexConflictKeys(bundle),
+            conflictingJobIds: [],
+            ownedFilesTouched: [...bundle.ownedFilesTouched],
+            ownershipViolations: [...bundle.ownershipViolations],
+            ...(bundle.patchPath ? { patchPath: bundle.patchPath } : {}),
+            ...(bundle.patchHash ? { patchHash: bundle.patchHash } : {}),
+            evidencePaths: [...bundle.evidencePaths],
+            queueItemIds: [...bundle.queueItemIds],
+            reasons: uniqueStrings([...bundle.reasons, ...(staleAgainstHead ? ['stale-against-head'] : [])]),
+            generatedAt: bundle.generatedAt
+        };
+    });
+    const conflicts = createMergeIndexConflicts(entries);
+    const conflictsByJob = new Map();
+    for (const conflict of conflicts) {
+        for (const jobId of conflict.jobIds) {
+            const set = conflictsByJob.get(jobId) ?? new Set();
+            for (const other of conflict.jobIds)
+                if (other !== jobId)
+                    set.add(other);
+            conflictsByJob.set(jobId, set);
+        }
+    }
+    const indexed = entries.map((entry) => ({
+        ...entry,
+        conflictingJobIds: Array.from(conflictsByJob.get(entry.jobId) ?? []).sort()
+    }));
+    const byDisposition = groupJobIdsBy(indexed, (entry) => entry.disposition);
+    const byPath = groupJobIdsByMany(indexed, (entry) => entry.changedPaths);
+    const byRegion = groupJobIdsByMany(indexed, (entry) => entry.changedRegions);
+    return {
+        kind: FRONTIER_SWARM_MERGE_INDEX_KIND,
+        version: FRONTIER_SWARM_MERGE_INDEX_VERSION,
+        id: input.id ?? 'swarm-merge-index:' + stableHash([input.runId, input.planId, indexed, conflicts, generatedAt]),
+        ...(input.runId ? { runId: input.runId } : {}),
+        ...(input.planId ? { planId: input.planId } : {}),
+        generatedAt,
+        entries: indexed,
+        conflicts,
+        byDisposition,
+        byPath,
+        byRegion,
+        summary: {
+            entryCount: indexed.length,
+            readyToApplyCount: indexed.filter((entry) => entry.disposition === 'auto-mergeable' && entry.autoMergeable && !entry.conflictingJobIds.length).length,
+            needsHumanPortCount: indexed.filter((entry) => entry.disposition === 'needs-port').length,
+            failedEvidenceCount: indexed.filter((entry) => entry.disposition === 'rejected' || entry.disposition === 'blocked' || entry.ownershipViolations.length > 0).length,
+            staleAgainstHeadCount: indexed.filter((entry) => entry.staleAgainstHead || entry.disposition === 'stale-against-head').length,
+            discoveryOnlyCount: indexed.filter((entry) => entry.disposition === 'discovery-only').length,
+            conflictCount: conflicts.length,
+            conflictedJobCount: conflictsByJob.size
+        },
+        ...(toJsonObject(input.metadata) ? { metadata: toJsonObject(input.metadata) } : {})
+    };
+}
+export function checkSwarmRegionOwnership(job, input = {}) {
+    const changedPaths = uniqueStrings(input.changedPaths ?? []);
+    const resolvedRegions = resolveSwarmChangedRegions(job, changedPaths);
+    const changedRegions = uniqueStrings([...(input.changedRegions ?? []), ...resolvedRegions]);
+    const ownedRegions = new Set(job.ownedRegions);
+    const regionViolations = changedRegions.filter((region) => !ownedRegions.has(region));
+    const classifiedPaths = new Set();
+    for (const region of job.ownershipRegions) {
+        for (const file of changedPaths) {
+            if (region.globs.some((glob) => matchesGlob(file, glob)))
+                classifiedPaths.add(file);
+        }
+    }
+    const unclassifiedChangedPaths = changedPaths.filter((file) => !classifiedPaths.has(file));
+    return {
+        ok: regionViolations.length === 0 && (job.ownershipRegions.length === 0 || unclassifiedChangedPaths.length === 0),
+        jobId: job.id,
+        changedPaths,
+        changedRegions,
+        ownedRegions: [...job.ownedRegions],
+        regionViolations,
+        unclassifiedChangedPaths
+    };
+}
+export function createSwarmHotspotReport(input = {}) {
+    const generatedAt = input.generatedAt ?? Date.now();
+    const threshold = Math.max(2, Math.floor(input.threshold ?? 3));
+    const byPath = new Map();
+    for (const bundle of input.bundles ?? []) {
+        for (const file of bundle.changedPaths) {
+            const current = byPath.get(file) ?? {
+                path: file,
+                touchCount: 0,
+                jobIds: [],
+                regions: [],
+                dispositions: [],
+                riskLevels: []
+            };
+            current.touchCount += 1;
+            current.jobIds = uniqueStrings([...current.jobIds, bundle.jobId]);
+            current.regions = uniqueStrings([...current.regions, ...bundle.changedRegions]);
+            current.dispositions = uniqueStrings([...current.dispositions, bundle.disposition]);
+            current.riskLevels = uniqueStrings([...current.riskLevels, bundle.riskLevel]);
+            byPath.set(file, current);
+        }
+    }
+    for (const raw of input.results ?? []) {
+        const result = isSwarmJobResult(raw) ? raw : normalizeResult(raw);
+        for (const file of result.changedPaths) {
+            const current = byPath.get(file) ?? {
+                path: file,
+                touchCount: 0,
+                jobIds: [],
+                regions: [],
+                dispositions: [],
+                riskLevels: []
+            };
+            current.touchCount += 1;
+            current.jobIds = uniqueStrings([...current.jobIds, result.jobId]);
+            current.regions = uniqueStrings([...current.regions, ...result.changedRegions]);
+            current.dispositions = uniqueStrings([...current.dispositions, result.mergeDisposition]);
+            current.riskLevels = uniqueStrings([...current.riskLevels, result.riskLevel]);
+            byPath.set(file, current);
+        }
+    }
+    const entries = Array.from(byPath.values()).sort((left, right) => right.touchCount - left.touchCount || left.path.localeCompare(right.path));
+    const recommendations = entries
+        .filter((entry) => entry.touchCount >= threshold || entry.regions.length > 1)
+        .map((entry) => ({
+        path: entry.path,
+        reason: entry.regions.length > 1 ? 'region-overlap' : 'hot-file',
+        suggestedModuleId: suggestedModuleId(entry.path),
+        suggestedOwnershipRegions: entry.regions.length ? entry.regions : [`${suggestedModuleId(entry.path)}.*`],
+        jobIds: [...entry.jobIds]
+    }));
+    return {
+        kind: FRONTIER_SWARM_HOTSPOT_REPORT_KIND,
+        version: FRONTIER_SWARM_HOTSPOT_REPORT_VERSION,
+        id: input.id ?? 'swarm-hotspot-report:' + stableHash([entries, threshold, generatedAt]),
+        generatedAt,
+        threshold,
+        entries,
+        recommendations,
+        summary: {
+            pathCount: entries.length,
+            hotspotCount: entries.filter((entry) => entry.touchCount >= threshold).length,
+            recommendationCount: recommendations.length
+        },
+        ...(toJsonObject(input.metadata) ? { metadata: toJsonObject(input.metadata) } : {})
+    };
+}
+export function createSwarmReviewerLanePlan(input) {
+    const generatedAt = input.generatedAt ?? Date.now();
+    const reviewerLane = input.reviewerLane ?? 'review';
+    const reviewers = uniqueStrings(input.reviewers ?? []);
+    const deferralsByJob = new Map((input.admission?.deferred ?? []).map((entry) => [entry.jobId, entry.reasons]));
+    const candidates = input.index.entries.filter((entry) => input.includeAutoMergeable
+        || deferralsByJob.has(entry.jobId)
+        || entry.conflictingJobIds.length > 0
+        || entry.riskLevel === 'high'
+        || entry.disposition !== 'auto-mergeable'
+        || !entry.autoMergeable);
+    const assignments = candidates.map((entry) => ({
+        jobId: entry.jobId,
+        reviewers: selectReviewers(reviewers, reviewers.length ? 1 : 0, entry.jobId),
+        required: deferralsByJob.has(entry.jobId) || entry.conflictingJobIds.length > 0 || entry.riskLevel === 'high' || entry.disposition !== 'auto-mergeable',
+        reasons: uniqueStrings([...reviewerLaneReasons(entry), ...(deferralsByJob.get(entry.jobId) ?? [])])
+    }));
+    const tasks = candidates.map((entry) => ({
+        id: `review-${slug(entry.jobId)}`,
+        lane: reviewerLane,
+        kind: 'review',
+        title: `Review ${entry.title ?? entry.jobId}`,
+        objective: `Review swarm merge bundle ${entry.jobId}.`,
+        sourceRefs: entry.evidencePaths,
+        targetRefs: entry.changedPaths,
+        ownedRegions: entry.changedRegions,
+        acceptance: [
+            'Review evidence, patch applicability, ownership, conflicts, and risk.',
+            `Merge disposition: ${entry.disposition}.`
+        ],
+        metadata: {
+            mergeJobId: entry.jobId,
+            conflictingJobIds: entry.conflictingJobIds,
+            reasons: uniqueStrings([...reviewerLaneReasons(entry), ...(deferralsByJob.get(entry.jobId) ?? [])])
+        }
+    }));
+    return {
+        kind: FRONTIER_SWARM_REVIEWER_LANE_PLAN_KIND,
+        version: FRONTIER_SWARM_REVIEWER_LANE_PLAN_VERSION,
+        id: input.id ?? 'swarm-reviewer-lane-plan:' + stableHash([input.index.id, assignments, generatedAt]),
+        mergeIndexId: input.index.id,
+        generatedAt,
+        reviewerLane,
+        assignments,
+        tasks,
+        summary: {
+            assignmentCount: assignments.length,
+            taskCount: tasks.length
+        },
+        ...(toJsonObject(input.metadata) ? { metadata: toJsonObject(input.metadata) } : {})
+    };
+}
+export function createSwarmRunStoreShards(input = {}) {
+    const generatedAt = input.generatedAt ?? Date.now();
+    const root = input.root ?? 'agent-runs/shards';
+    const shardSize = Math.max(1, Math.floor(input.shardSize ?? 100));
+    const groupBy = input.groupBy ?? 'lane';
+    const jobs = input.run?.jobs ?? input.plan?.jobs ?? [];
+    const groups = new Map();
+    for (const job of jobs) {
+        const key = groupBy === 'none' ? 'all' : groupBy === 'hash' ? String(hashBucket(job.id, shardSize)) : job.lane;
+        groups.set(key, [...(groups.get(key) ?? []), job]);
+    }
+    const shards = [];
+    for (const [group, groupJobs] of Array.from(groups.entries()).sort((left, right) => left[0].localeCompare(right[0]))) {
+        for (let index = 0; index < groupJobs.length; index += shardSize) {
+            const slice = groupJobs.slice(index, index + shardSize);
+            const suffix = `${slug(group)}-${Math.floor(index / shardSize)}`;
+            const shardRoot = joinPathParts(root, suffix);
+            shards.push({
+                id: 'swarm-run-store-shard:' + stableHash([input.run?.id, input.plan?.id, group, index, slice.map((job) => job.id)]),
+                ...(groupBy === 'lane' ? { lane: group } : {}),
+                path: shardRoot,
+                eventPath: joinPathParts(shardRoot, 'events.jsonl'),
+                resultPath: joinPathParts(shardRoot, 'results.jsonl'),
+                checkpointPath: joinPathParts(shardRoot, 'checkpoint.json'),
+                jobIds: slice.map((job) => job.id)
+            });
+        }
+    }
+    return {
+        kind: FRONTIER_SWARM_RUN_STORE_SHARDS_KIND,
+        version: FRONTIER_SWARM_RUN_STORE_SHARDS_VERSION,
+        id: input.id ?? 'swarm-run-store-shards:' + stableHash([input.run?.id, input.plan?.id, root, shardSize, groupBy, shards, generatedAt]),
+        ...(input.run ? { runId: input.run.id } : {}),
+        ...(input.plan ? { planId: input.plan.id } : {}),
+        root,
+        generatedAt,
+        groupBy,
+        shardSize,
+        shards,
+        summary: {
+            shardCount: shards.length,
+            jobCount: jobs.length
+        },
+        ...(toJsonObject(input.metadata) ? { metadata: toJsonObject(input.metadata) } : {})
+    };
+}
+export function createSwarmMergeAdmission(input) {
+    const generatedAt = input.generatedAt ?? Date.now();
+    const maxReady = Math.max(0, Math.floor(input.maxReady ?? input.index.entries.length));
+    const maxChangedPaths = input.maxChangedPaths === undefined ? undefined : Math.max(0, Math.floor(input.maxChangedPaths));
+    const maxChangedRegions = input.maxChangedRegions === undefined ? undefined : Math.max(0, Math.floor(input.maxChangedRegions));
+    const maxHighRisk = input.maxHighRisk === undefined ? undefined : Math.max(0, Math.floor(input.maxHighRisk));
+    const allowRisks = uniqueStrings(input.allowRisks ?? ['low', 'medium']);
+    const admitted = [];
+    const deferred = [];
+    const usedPaths = new Set();
+    const usedRegions = new Set();
+    let highRiskCount = 0;
+    for (const entry of input.index.entries) {
+        const reasons = [];
+        if (entry.disposition !== 'auto-mergeable' || !entry.autoMergeable)
+            reasons.push('not-auto-mergeable');
+        if (entry.staleAgainstHead)
+            reasons.push('stale-against-head');
+        if (entry.conflictingJobIds.length)
+            reasons.push('conflicting-changes');
+        if (!allowRisks.includes(entry.riskLevel))
+            reasons.push('risk-not-admitted');
+        if (admitted.length >= maxReady)
+            reasons.push('max-ready');
+        const nextPaths = new Set([...usedPaths, ...entry.changedPaths]);
+        const nextRegions = new Set([...usedRegions, ...entry.changedRegions]);
+        const nextHighRiskCount = highRiskCount + (entry.riskLevel === 'high' ? 1 : 0);
+        if (maxChangedPaths !== undefined && nextPaths.size > maxChangedPaths)
+            reasons.push('max-changed-paths');
+        if (maxChangedRegions !== undefined && nextRegions.size > maxChangedRegions)
+            reasons.push('max-changed-regions');
+        if (maxHighRisk !== undefined && nextHighRiskCount > maxHighRisk)
+            reasons.push('max-high-risk');
+        if (reasons.length) {
+            deferred.push({ jobId: entry.jobId, reasons: uniqueStrings(reasons) });
+            continue;
+        }
+        admitted.push(entry.jobId);
+        for (const file of entry.changedPaths)
+            usedPaths.add(file);
+        for (const region of entry.changedRegions)
+            usedRegions.add(region);
+        highRiskCount = nextHighRiskCount;
+    }
+    return {
+        kind: FRONTIER_SWARM_MERGE_ADMISSION_KIND,
+        version: FRONTIER_SWARM_MERGE_ADMISSION_VERSION,
+        id: input.id ?? 'swarm-merge-admission:' + stableHash([input.index.id, admitted, deferred, generatedAt]),
+        mergeIndexId: input.index.id,
+        generatedAt,
+        admitted,
+        deferred,
+        budget: {
+            maxReady,
+            ...(maxChangedPaths !== undefined ? { maxChangedPaths } : {}),
+            ...(maxChangedRegions !== undefined ? { maxChangedRegions } : {}),
+            ...(maxHighRisk !== undefined ? { maxHighRisk } : {}),
+            allowRisks
+        },
+        summary: {
+            admittedCount: admitted.length,
+            deferredCount: deferred.length,
+            changedPathCount: usedPaths.size,
+            changedRegionCount: usedRegions.size,
+            highRiskCount
+        },
+        ...(toJsonObject(input.metadata) ? { metadata: toJsonObject(input.metadata) } : {})
+    };
+}
+export function createSwarmContextPack(input = {}) {
+    const generatedAt = input.generatedAt ?? Date.now();
+    const task = input.job?.task ?? (input.task ? isSwarmTask(input.task) ? input.task : normalizeTask(input.task) : undefined);
+    const files = uniqueStrings([
+        ...(input.files ?? []),
+        ...(input.job?.task.sourceRefs ?? []),
+        ...(input.job?.task.targetRefs ?? []),
+        ...(task?.sourceRefs ?? []),
+        ...(task?.targetRefs ?? [])
+    ]);
+    const apiMap = Object.fromEntries(Object.entries(input.apiMap ?? {}).map(([key, values]) => [key, uniqueStrings(values)]));
+    const commands = normalizeCommands([
+        ...(input.commands ?? []),
+        ...(input.oracleCommands ?? []),
+        ...(input.job?.verification ?? [])
+    ]);
+    const expectedEvidence = uniqueStrings([
+        ...(input.expectedEvidence ?? []),
+        ...(input.job?.evidencePrefix ? [joinPathParts(input.job.evidencePrefix, 'evidence.json')] : [])
+    ]);
+    return {
+        kind: FRONTIER_SWARM_CONTEXT_PACK_KIND,
+        version: FRONTIER_SWARM_CONTEXT_PACK_VERSION,
+        id: input.id ?? 'swarm-context-pack:' + stableHash([input.job?.id, task?.id, files, apiMap, generatedAt]),
+        ...(input.job ? { jobId: input.job.id } : {}),
+        ...(task ? { taskId: task.id } : {}),
+        ...(input.job?.lane ?? task?.lane ? { lane: input.job?.lane ?? task?.lane } : {}),
+        title: input.title ?? input.job?.title ?? task?.title ?? 'Swarm Context Pack',
+        generatedAt,
+        files,
+        apiMap,
+        knownFailures: uniqueStrings(input.knownFailures ?? []),
+        commands,
+        oracleCommands: commands,
+        ...(input.evidenceSchema !== undefined ? { evidenceSchema: toJsonValue(input.evidenceSchema) } : {}),
+        expectedEvidence,
+        exclusions: uniqueStrings(input.exclusions ?? []),
+        avoidInvestigating: uniqueStrings(input.avoidInvestigating ?? []),
+        playbookIds: uniqueStrings(input.playbookIds ?? []),
+        ...(toJsonObject(input.metadata) ? { metadata: toJsonObject(input.metadata) } : {})
+    };
+}
+export function createSwarmOracleCorpus(input = {}) {
+    const generatedAt = input.generatedAt ?? Date.now();
+    const artifacts = (input.artifacts ?? []).map(normalizeOracleArtifact).sort((left, right) => left.id.localeCompare(right.id));
+    const byKind = groupArtifactIdsBy(artifacts, (artifact) => [artifact.kind]);
+    const byTag = groupArtifactIdsBy(artifacts, (artifact) => artifact.tags);
+    return {
+        kind: FRONTIER_SWARM_ORACLE_CORPUS_KIND,
+        version: FRONTIER_SWARM_ORACLE_CORPUS_VERSION,
+        id: input.id ?? 'swarm-oracle-corpus:' + stableHash([artifacts, generatedAt]),
+        title: input.title ?? titleFromId(input.id ?? 'oracle corpus'),
+        generatedAt,
+        artifacts,
+        byKind,
+        byTag,
+        summary: {
+            artifactCount: artifacts.length,
+            kindCount: Object.keys(byKind).length,
+            tagCount: Object.keys(byTag).length
+        },
+        ...(toJsonObject(input.metadata) ? { metadata: toJsonObject(input.metadata) } : {})
+    };
+}
+export function createSwarmObservabilityPoint(input = {}) {
+    const eventRefs = normalizeNamedRefs(input.eventRefs ?? [], 'event');
+    return {
+        kind: FRONTIER_SWARM_OBSERVABILITY_POINT_KIND,
+        version: FRONTIER_SWARM_OBSERVABILITY_POINT_VERSION,
+        id: input.id ?? 'swarm-observability-point:' + stableHash([input.subject, input.scope, input.operationIndex, input.at, input.path, input.selector, eventRefs]),
+        ...(input.subject ? { subject: input.subject } : {}),
+        ...(input.scope ? { scope: input.scope } : {}),
+        ...(input.operationIndex !== undefined ? { operationIndex: Math.max(0, Math.floor(input.operationIndex)) } : {}),
+        ...(input.at !== undefined ? { at: input.at } : {}),
+        ...(input.path ? { path: input.path } : {}),
+        ...(input.selector ? { selector: input.selector } : {}),
+        ...(input.before !== undefined ? { before: toJsonValue(input.before) } : {}),
+        ...(input.after !== undefined ? { after: toJsonValue(input.after) } : {}),
+        eventRefs,
+        ...(toJsonObject(input.metadata) ? { metadata: toJsonObject(input.metadata) } : {})
+    };
+}
+export function createSwarmReplayBundle(input = {}) {
+    const generatedAt = input.generatedAt ?? Date.now();
+    const commands = normalizeCommands(input.commands ?? []);
+    const inputs = normalizeNamedRefs(input.inputs ?? [], 'input');
+    const artifacts = normalizeNamedRefs(input.artifacts ?? [], 'artifact');
+    const sourceRefs = normalizeNamedRefs(input.sourceRefs ?? [], 'source');
+    const seeds = normalizeSeedRefs(input.seeds ?? []);
+    const expectedEvidence = uniqueStrings(input.expectedEvidence ?? []);
+    const title = input.title ?? titleFromId(input.id ?? input.subject ?? 'replay bundle');
+    return {
+        kind: FRONTIER_SWARM_REPLAY_BUNDLE_KIND,
+        version: FRONTIER_SWARM_REPLAY_BUNDLE_VERSION,
+        id: input.id ?? 'swarm-replay-bundle:' + stableHash([title, input.subject, commands, inputs, artifacts, sourceRefs, seeds, expectedEvidence, generatedAt]),
+        title,
+        ...(input.subject ? { subject: input.subject } : {}),
+        generatedAt,
+        commands,
+        inputs,
+        artifacts,
+        sourceRefs,
+        seeds,
+        ...(toJsonObject(input.environment) ? { environment: toJsonObject(input.environment) } : {}),
+        expectedEvidence,
+        summary: {
+            commandCount: commands.length,
+            inputCount: inputs.length,
+            artifactCount: artifacts.length,
+            sourceRefCount: sourceRefs.length
+        },
+        ...(toJsonObject(input.metadata) ? { metadata: toJsonObject(input.metadata) } : {})
+    };
+}
+export function createSwarmParityOracle(input = {}) {
+    const generatedAt = input.generatedAt ?? Date.now();
+    const referenceCommands = normalizeCommands(input.referenceCommands ?? []);
+    const testCommands = normalizeCommands(input.testCommands ?? []);
+    const comparators = (input.comparators ?? []).map(normalizeParityComparator);
+    const artifacts = normalizeNamedRefs(input.artifacts ?? [], 'parity-artifact');
+    const status = input.status ?? inferParityStatus(comparators);
+    return {
+        kind: FRONTIER_SWARM_PARITY_ORACLE_KIND,
+        version: FRONTIER_SWARM_PARITY_ORACLE_VERSION,
+        id: input.id ?? 'swarm-parity-oracle:' + stableHash([input.title, input.subject, referenceCommands, testCommands, comparators, artifacts, generatedAt]),
+        title: input.title ?? titleFromId(input.id ?? input.subject ?? 'parity oracle'),
+        status,
+        ...(input.subject ? { subject: input.subject } : {}),
+        generatedAt,
+        referenceCommands,
+        testCommands,
+        comparators,
+        artifacts,
+        replayBundleIds: uniqueStrings(input.replayBundleIds ?? []),
+        summary: {
+            comparatorCount: comparators.length,
+            passedCount: comparators.filter((comparator) => comparator.status === 'passed').length,
+            failedCount: comparators.filter((comparator) => comparator.status === 'failed').length,
+            blockedCount: comparators.filter((comparator) => comparator.status === 'blocked').length
+        },
+        ...(toJsonObject(input.metadata) ? { metadata: toJsonObject(input.metadata) } : {})
+    };
+}
+export function createSwarmDivergenceReport(input = {}) {
+    const generatedAt = input.generatedAt ?? Date.now();
+    const observabilityPoints = (input.observabilityPoints ?? []).map((point) => isSwarmObservabilityPoint(point) ? point : createSwarmObservabilityPoint(point));
+    const earliest = observabilityPoints
+        .filter((point) => point.operationIndex !== undefined)
+        .sort((left, right) => left.operationIndex - right.operationIndex)[0];
+    const divergesAt = input.divergesAt ?? earliest?.path;
+    const operationIndex = input.operationIndex ?? earliest?.operationIndex;
+    return {
+        kind: FRONTIER_SWARM_DIVERGENCE_REPORT_KIND,
+        version: FRONTIER_SWARM_DIVERGENCE_REPORT_VERSION,
+        id: input.id ?? 'swarm-divergence-report:' + stableHash([input.subject, input.divergesAt, input.operationIndex, observabilityPoints, generatedAt]),
+        title: input.title ?? titleFromId(input.id ?? input.subject ?? 'divergence report'),
+        status: input.status ?? 'failed',
+        severity: input.severity ?? 'error',
+        ...(input.subject ? { subject: input.subject } : {}),
+        confidence: input.confidence ?? 'medium',
+        ...(divergesAt ? { divergesAt } : {}),
+        ...(operationIndex !== undefined ? { operationIndex } : {}),
+        ...(input.expected !== undefined ? { expected: toJsonValue(input.expected) } : {}),
+        ...(input.actual !== undefined ? { actual: toJsonValue(input.actual) } : {}),
+        observabilityPoints,
+        traceRefs: normalizeNamedRefs(input.traceRefs ?? [], 'trace'),
+        replayBundleIds: uniqueStrings(input.replayBundleIds ?? []),
+        evidenceRefs: normalizeNamedRefs(input.evidenceRefs ?? [], 'evidence'),
+        generatedAt,
+        ...(toJsonObject(input.metadata) ? { metadata: toJsonObject(input.metadata) } : {})
+    };
+}
+export function createSwarmWatchpointPlan(input = {}) {
+    const generatedAt = input.generatedAt ?? Date.now();
+    const watchpoints = (input.watchpoints ?? []).map(normalizeWatchpoint);
+    const commands = normalizeCommands(input.commands ?? []);
+    return {
+        kind: FRONTIER_SWARM_WATCHPOINT_PLAN_KIND,
+        version: FRONTIER_SWARM_WATCHPOINT_PLAN_VERSION,
+        id: input.id ?? 'swarm-watchpoint-plan:' + stableHash([input.subject, watchpoints, commands, generatedAt]),
+        title: input.title ?? titleFromId(input.id ?? input.subject ?? 'watchpoint plan'),
+        ...(input.subject ? { subject: input.subject } : {}),
+        matchMode: input.matchMode ?? 'all',
+        generatedAt,
+        watchpoints,
+        commands,
+        replayBundleIds: uniqueStrings(input.replayBundleIds ?? []),
+        divergenceReportIds: uniqueStrings(input.divergenceReportIds ?? []),
+        summary: {
+            watchpointCount: watchpoints.length,
+            commandCount: commands.length
+        },
+        ...(toJsonObject(input.metadata) ? { metadata: toJsonObject(input.metadata) } : {})
+    };
+}
+export function createSwarmDebugHandoff(input = {}) {
+    const generatedAt = input.generatedAt ?? Date.now();
+    const focus = input.focus ? (isSwarmObservabilityPoint(input.focus) ? input.focus : createSwarmObservabilityPoint(input.focus)) : undefined;
+    return {
+        kind: FRONTIER_SWARM_DEBUG_HANDOFF_KIND,
+        version: FRONTIER_SWARM_DEBUG_HANDOFF_VERSION,
+        id: input.id ?? 'swarm-debug-handoff:' + stableHash([input.subject, focus, input.replayBundleIds, input.divergenceReportIds, input.watchpointPlanIds, generatedAt]),
+        title: input.title ?? titleFromId(input.id ?? input.subject ?? 'debug handoff'),
+        status: input.status ?? 'ready',
+        ...(input.subject ? { subject: input.subject } : {}),
+        ...(focus ? { focus } : {}),
+        replayBundleIds: uniqueStrings(input.replayBundleIds ?? []),
+        divergenceReportIds: uniqueStrings(input.divergenceReportIds ?? []),
+        watchpointPlanIds: uniqueStrings(input.watchpointPlanIds ?? []),
+        commands: normalizeCommands(input.commands ?? []),
+        files: normalizeNamedRefs(input.files ?? [], 'file'),
+        artifacts: normalizeNamedRefs(input.artifacts ?? [], 'artifact'),
+        comparisons: (input.comparisons ?? []).map(normalizeParityComparator),
+        ...(toJsonObject(input.environment) ? { environment: toJsonObject(input.environment) } : {}),
+        generatedAt,
+        ...(toJsonObject(input.metadata) ? { metadata: toJsonObject(input.metadata) } : {})
+    };
+}
+export function createSwarmInstrumentationBudget(input = {}) {
+    const generatedAt = input.generatedAt ?? Date.now();
+    return {
+        kind: FRONTIER_SWARM_INSTRUMENTATION_BUDGET_KIND,
+        version: FRONTIER_SWARM_INSTRUMENTATION_BUDGET_VERSION,
+        id: input.id ?? 'swarm-instrumentation-budget:' + stableHash([input.lane, input.maxEvents, input.maxBytes, input.maxDurationMs, input.maxOverheadRatio, generatedAt]),
+        title: input.title ?? titleFromId(input.id ?? input.lane ?? 'instrumentation budget'),
+        ...(input.lane ? { lane: input.lane } : {}),
+        generatedAt,
+        ...(positiveNumber(input.maxEvents) ? { maxEvents: Math.floor(input.maxEvents) } : {}),
+        ...(positiveNumber(input.maxBytes) ? { maxBytes: Math.floor(input.maxBytes) } : {}),
+        ...(positiveNumber(input.maxDurationMs) ? { maxDurationMs: Math.floor(input.maxDurationMs) } : {}),
+        ...(positiveNumber(input.maxOverheadRatio) ? { maxOverheadRatio: input.maxOverheadRatio } : {}),
+        captureKinds: uniqueStrings(input.captureKinds ?? []),
+        sampling: {
+            mode: input.sampling?.mode ?? 'adaptive',
+            ...(positiveNumber(input.sampling?.rate) ? { rate: input.sampling?.rate } : {}),
+            ...(toJsonObject(input.sampling?.metadata) ? { metadata: toJsonObject(input.sampling?.metadata) } : {})
+        },
+        ...(toJsonObject(input.metadata) ? { metadata: toJsonObject(input.metadata) } : {})
+    };
+}
+export function checkSwarmInstrumentationBudget(budgetInput, usageInput = {}) {
+    const budget = isSwarmInstrumentationBudget(budgetInput) ? budgetInput : createSwarmInstrumentationBudget(budgetInput);
+    const usage = {
+        events: Math.max(0, Math.floor(usageInput.events ?? 0)),
+        bytes: Math.max(0, Math.floor(usageInput.bytes ?? 0)),
+        durationMs: Math.max(0, Math.floor(usageInput.durationMs ?? 0)),
+        overheadRatio: Math.max(0, usageInput.overheadRatio ?? 0),
+        captureKinds: uniqueStrings(usageInput.captureKinds ?? []),
+        ...(toJsonObject(usageInput.metadata) ? { metadata: toJsonObject(usageInput.metadata) } : {})
+    };
+    const violations = [];
+    if (budget.maxEvents !== undefined && usage.events > budget.maxEvents)
+        violations.push('max-events');
+    if (budget.maxBytes !== undefined && usage.bytes > budget.maxBytes)
+        violations.push('max-bytes');
+    if (budget.maxDurationMs !== undefined && usage.durationMs > budget.maxDurationMs)
+        violations.push('max-duration-ms');
+    if (budget.maxOverheadRatio !== undefined && usage.overheadRatio > budget.maxOverheadRatio)
+        violations.push('max-overhead-ratio');
+    for (const kind of usage.captureKinds.filter((kind) => budget.captureKinds.length > 0 && !budget.captureKinds.includes(kind))) {
+        violations.push(`capture-kind:${kind}`);
+    }
+    return { ok: violations.length === 0, budgetId: budget.id, usage, violations: uniqueStrings(violations) };
+}
+export function classifySwarmBottleneck(input) {
+    const source = normalizeBottleneckSource(input);
+    const text = [source.text, source.status, ...(source.reasons ?? []), ...(source.evidencePaths ?? []), ...(source.changedPaths ?? [])].join(' ').toLowerCase();
+    const verification = source.verification ?? [];
+    let kind = 'queue';
+    let confidence = 'medium';
+    if (/missing.*oracle|no oracle|needs-fixture|fixture/.test(text))
+        kind = 'missing-oracle';
+    else if (/flaky|timeout|browser|playwright|chrome|port/.test(text))
+        kind = 'flaky-harness';
+    else if (/instrument|logging|trace|telemetry|overhead/.test(text))
+        kind = 'instrumentation-overhead';
+    else if (/merge|conflict|review|needs-port|ownership/.test(text))
+        kind = 'merge-review';
+    else if (/dependency|depends|blocked/.test(text))
+        kind = 'blocked-dependency';
+    else if (/perf|slow|latency|throughput|cpu|memory|resource-capacity/.test(text))
+        kind = 'performance';
+    else if (/diverg|correct|parity|oracle failed|regression/.test(text))
+        kind = 'correctness';
+    if (verification.some((entry) => entry.status !== undefined && entry.status !== 0 && entry.required !== false))
+        confidence = 'high';
+    if ((source.evidencePaths?.length ?? 0) === 0 && (source.changedPaths?.length ?? 0) > 0)
+        confidence = 'low';
+    return {
+        kind,
+        confidence,
+        reasons: uniqueStrings([kind, ...(source.reasons ?? []), ...verification.filter((entry) => entry.status !== undefined && entry.status !== 0).map((entry) => entry.name ?? 'failed-verification')]),
+        route: routeForBottleneck(kind, source.lane)
+    };
+}
+export function createSwarmBottleneckReport(input = {}) {
+    const generatedAt = input.generatedAt ?? Date.now();
+    const classifications = (input.sources ?? []).map(classifySwarmBottleneck);
+    const byKind = groupObjects(classifications, (classification) => classification.kind);
+    return {
+        kind: FRONTIER_SWARM_BOTTLENECK_REPORT_KIND,
+        version: FRONTIER_SWARM_BOTTLENECK_REPORT_VERSION,
+        id: input.id ?? 'swarm-bottleneck-report:' + stableHash([classifications, generatedAt]),
+        generatedAt,
+        classifications,
+        byKind,
+        summary: {
+            sourceCount: input.sources?.length ?? 0,
+            kindCount: Object.keys(byKind).length
+        },
+        ...(toJsonObject(input.metadata) ? { metadata: toJsonObject(input.metadata) } : {})
+    };
+}
+export function createSwarmEvidenceIndex(input = {}) {
+    const source = isSwarmRun(input) ? { run: input } : input;
+    const generatedAt = source.generatedAt ?? Date.now();
+    const runEntries = source.run?.results.flatMap((result) => result.evidencePaths.map((path) => normalizeEvidenceIndexEntry({
+        jobId: result.jobId,
+        queueItemId: result.queueItemIds[0],
+        path,
+        kind: evidenceKindFromPath(path),
+        status: result.status,
+        confidence: result.status === 'verified' || result.mergeReadiness === 'verified-patch' ? 1 : 0.65,
+        generatedAt
+    }))) ?? [];
+    const entries = [...runEntries, ...(source.entries ?? []).map((entry) => normalizeEvidenceIndexEntry({ ...entry, generatedAt: entry.generatedAt ?? generatedAt }))];
+    const byJobId = groupObjects(entries.filter((entry) => entry.jobId), (entry) => entry.jobId);
+    const byTopic = groupObjects(entries.filter((entry) => entry.topic), (entry) => entry.topic);
+    const byPath = groupObjects(entries.filter((entry) => entry.path), (entry) => entry.path);
+    return {
+        kind: FRONTIER_SWARM_EVIDENCE_INDEX_KIND,
+        version: FRONTIER_SWARM_EVIDENCE_INDEX_VERSION,
+        id: source.id ?? 'swarm-evidence-index:' + stableHash([source.run?.id, entries, generatedAt]),
+        ...(source.run?.id ? { runId: source.run.id } : {}),
+        generatedAt,
+        entries,
+        byJobId,
+        byTopic,
+        byPath,
+        summary: {
+            entryCount: entries.length,
+            jobCount: Object.keys(byJobId).length,
+            topicCount: Object.keys(byTopic).length,
+            pathCount: Object.keys(byPath).length
+        },
+        ...(toJsonObject(source.metadata) ? { metadata: toJsonObject(source.metadata) } : {})
+    };
+}
+export function querySwarmEvidenceIndex(index, query = {}) {
+    const entries = index.entries.filter((entry) => ((query.jobId === undefined || entry.jobId === query.jobId)
+        && (query.lane === undefined || entry.lane === query.lane)
+        && (query.topic === undefined || entry.topic === query.topic)
+        && (query.pathIncludes === undefined || (entry.path ?? '').includes(query.pathIncludes))
+        && (query.kind === undefined || entry.kind === query.kind)
+        && (query.status === undefined || entry.status === query.status)
+        && (query.tag === undefined || entry.tags.includes(query.tag))
+        && (query.minConfidence === undefined || entry.confidence >= query.minConfidence)
+        && matchesFacetQuery(entry.facets, query.facet)));
+    return { entries, summary: { entryCount: entries.length } };
+}
+export function createSwarmBlackboard(input = {}) {
+    const generatedAt = input.generatedAt ?? Date.now();
+    const entries = (input.entries ?? []).map((entry) => normalizeBlackboardEntry({ ...entry, generatedAt: entry.generatedAt ?? generatedAt }));
+    const byTopic = groupObjects(entries, (entry) => entry.topic);
+    const byKind = groupObjects(entries, (entry) => entry.kind);
+    return {
+        kind: FRONTIER_SWARM_BLACKBOARD_KIND,
+        version: FRONTIER_SWARM_BLACKBOARD_VERSION,
+        id: input.id ?? 'swarm-blackboard:' + stableHash([input.runId, entries, generatedAt]),
+        ...(input.runId ? { runId: input.runId } : {}),
+        generatedAt,
+        entries,
+        byTopic,
+        byKind,
+        summary: {
+            entryCount: entries.length,
+            topicCount: Object.keys(byTopic).length,
+            kindCount: Object.keys(byKind).length
+        },
+        ...(toJsonObject(input.metadata) ? { metadata: toJsonObject(input.metadata) } : {})
+    };
+}
+export function querySwarmBlackboard(blackboard, query = {}) {
+    const textIncludes = query.textIncludes?.toLowerCase();
+    const entries = blackboard.entries.filter((entry) => ((query.kind === undefined || entry.kind === query.kind)
+        && (query.topic === undefined || entry.topic === query.topic)
+        && (query.status === undefined || entry.status === query.status)
+        && (query.lane === undefined || entry.lane === query.lane)
+        && (query.jobId === undefined || entry.jobId === query.jobId)
+        && (query.owner === undefined || entry.owner === query.owner)
+        && (query.tag === undefined || entry.tags.includes(query.tag))
+        && (textIncludes === undefined || entry.text.toLowerCase().includes(textIncludes))));
+    return { entries, summary: { entryCount: entries.length } };
+}
+export function createSwarmReferenceOraclePlan(input = {}) {
+    const generatedAt = input.generatedAt ?? Date.now();
+    const targets = (input.targets ?? []).map((target) => ({
+        id: target.id,
+        role: target.role ?? 'candidate',
+        ...(target.command ? { command: normalizeCommand(target.command) } : {}),
+        ...(toJsonObject(target.metadata) ? { metadata: toJsonObject(target.metadata) } : {})
+    }));
+    return {
+        kind: FRONTIER_SWARM_REFERENCE_ORACLE_PLAN_KIND,
+        version: FRONTIER_SWARM_REFERENCE_ORACLE_PLAN_VERSION,
+        id: input.id ?? 'swarm-reference-oracle-plan:' + stableHash([input.serviceId, input.subject, input.fixtureId, targets, input.window, generatedAt]),
+        ...(input.serviceId ? { serviceId: input.serviceId } : {}),
+        ...(input.subject ? { subject: input.subject } : {}),
+        ...(input.fixtureId ? { fixtureId: input.fixtureId } : {}),
+        generatedAt,
+        targets,
+        ...(input.window ? { window: normalizeReferenceWindow(input.window) } : {}),
+        watchpoints: (input.watchpoints ?? []).map(normalizeWatchpoint),
+        artifactKinds: uniqueStrings(input.artifactKinds ?? []),
+        ...(toJsonObject(input.metadata) ? { metadata: toJsonObject(input.metadata) } : {})
+    };
+}
+export function createSwarmReferenceOracleResponse(input = {}) {
+    const generatedAt = input.generatedAt ?? Date.now();
+    return {
+        kind: FRONTIER_SWARM_REFERENCE_ORACLE_RESPONSE_KIND,
+        version: FRONTIER_SWARM_REFERENCE_ORACLE_RESPONSE_VERSION,
+        id: input.id ?? 'swarm-reference-oracle-response:' + stableHash([input.planId, input.status, input.targetResults, input.divergence, generatedAt]),
+        ...(input.planId ? { planId: input.planId } : {}),
+        status: input.status ?? (input.divergence ? 'failed' : 'pending'),
+        ...(input.subject ? { subject: input.subject } : {}),
+        generatedAt,
+        targetResults: (input.targetResults ?? []).map((target) => ({
+            targetId: target.targetId,
+            status: target.status ?? 'pending',
+            artifacts: normalizeNamedRefs(target.artifacts ?? [], 'reference-oracle-artifact'),
+            ...(toJsonObject(target.metadata) ? { metadata: toJsonObject(target.metadata) } : {})
+        })),
+        ...(input.divergence ? { divergence: createSwarmDivergenceReport(input.divergence) } : {}),
+        ...(toJsonObject(input.metadata) ? { metadata: toJsonObject(input.metadata) } : {})
+    };
+}
+export function createSwarmArtifactRoutingPlan(input = {}) {
+    const generatedAt = input.generatedAt ?? Date.now();
+    const artifacts = [
+        ...normalizeNamedRefs(input.artifacts ?? [], 'artifact'),
+        ...(input.bundles ?? []).flatMap((bundle) => bundle.evidencePaths.map((path) => normalizeNamedRef({ path, kind: evidenceKindFromPath(path), role: bundle.disposition }, 'evidence')))
+    ];
+    const hints = (input.hints ?? []).map(normalizeRoutingHint);
+    const routes = artifacts.map((artifact) => {
+        const matched = hints.filter((hint) => ((hint.artifactKind === undefined || hint.artifactKind === artifact.kind)
+            && (hint.pathPattern === undefined || (artifact.path ?? artifact.uri ?? '').includes(hint.pathPattern))));
+        const bucket = matched[0]?.bucket ?? defaultArtifactBucket(artifact);
+        return {
+            artifact,
+            bucket,
+            ...(matched[0]?.lane ? { lane: matched[0].lane } : {}),
+            reasons: uniqueStrings(matched.map((hint) => hint.reason))
+        };
+    });
+    const byBucket = groupIds(routes.map((route) => ({ id: route.artifact.id, bucket: route.bucket })), (route) => route.bucket);
+    return {
+        kind: FRONTIER_SWARM_ARTIFACT_ROUTING_PLAN_KIND,
+        version: FRONTIER_SWARM_ARTIFACT_ROUTING_PLAN_VERSION,
+        id: input.id ?? 'swarm-artifact-routing-plan:' + stableHash([routes, generatedAt]),
+        generatedAt,
+        routes,
+        byBucket,
+        summary: {
+            routeCount: routes.length,
+            bucketCount: Object.keys(byBucket).length
+        },
+        ...(toJsonObject(input.metadata) ? { metadata: toJsonObject(input.metadata) } : {})
+    };
+}
+export function createSwarmFixtureCatalog(input = {}) {
+    const generatedAt = input.generatedAt ?? Date.now();
+    const fixtures = (input.fixtures ?? []).map(normalizeFixture);
+    const byTag = {};
+    for (const fixture of fixtures) {
+        for (const tag of fixture.tags)
+            byTag[tag] = uniqueStrings([...(byTag[tag] ?? []), fixture.id]);
+    }
+    return {
+        kind: FRONTIER_SWARM_FIXTURE_CATALOG_KIND,
+        version: FRONTIER_SWARM_FIXTURE_CATALOG_VERSION,
+        id: input.id ?? 'swarm-fixture-catalog:' + stableHash([fixtures, generatedAt]),
+        generatedAt,
+        fixtures,
+        byTag,
+        summary: {
+            fixtureCount: fixtures.length,
+            tagCount: Object.keys(byTag).length
+        },
+        ...(toJsonObject(input.metadata) ? { metadata: toJsonObject(input.metadata) } : {})
+    };
+}
+export function createSwarmProgressModel(input = {}) {
+    const generatedAt = input.generatedAt ?? Date.now();
+    const items = (input.items ?? []).map((item) => ({
+        id: item.id,
+        ...(item.surface ? { surface: item.surface } : {}),
+        status: item.status ?? 'not-started',
+        evidencePaths: uniqueStrings(item.evidencePaths ?? []),
+        blockers: uniqueStrings(item.blockers ?? []),
+        ...(toJsonObject(item.metadata) ? { metadata: toJsonObject(item.metadata) } : {})
+    }));
+    const byStatus = groupIds(items, (item) => item.status);
+    return {
+        kind: FRONTIER_SWARM_PROGRESS_MODEL_KIND,
+        version: FRONTIER_SWARM_PROGRESS_MODEL_VERSION,
+        id: input.id ?? 'swarm-progress-model:' + stableHash([items, generatedAt]),
+        generatedAt,
+        items,
+        byStatus,
+        summary: {
+            itemCount: items.length,
+            acceptedCount: byStatus.accepted?.length ?? 0,
+            blockedCount: byStatus.blocked?.length ?? 0
+        },
+        ...(toJsonObject(input.metadata) ? { metadata: toJsonObject(input.metadata) } : {})
+    };
+}
+export function createSwarmAutoReviewReport(input = {}) {
+    const generatedAt = input.generatedAt ?? Date.now();
+    const derived = (input.bundles ?? []).flatMap((bundle) => deriveAutoReviewFindings(bundle, generatedAt));
+    const findings = [...derived, ...(input.findings ?? []).map((finding) => normalizeAutoReviewFinding(finding, generatedAt))];
+    const byKind = groupObjects(findings, (finding) => finding.kind);
+    return {
+        kind: FRONTIER_SWARM_AUTO_REVIEW_REPORT_KIND,
+        version: FRONTIER_SWARM_AUTO_REVIEW_REPORT_VERSION,
+        id: input.id ?? 'swarm-auto-review-report:' + stableHash([findings, generatedAt]),
+        generatedAt,
+        findings,
+        byKind,
+        summary: {
+            findingCount: findings.length,
+            highSeverityCount: findings.filter((finding) => finding.severity === 'error' || finding.severity === 'critical').length
+        },
+        ...(toJsonObject(input.metadata) ? { metadata: toJsonObject(input.metadata) } : {})
+    };
+}
+export function createSwarmRebaseReport(input = {}) {
+    const generatedAt = input.generatedAt ?? Date.now();
+    const fromIndex = input.mergeIndex?.entries.map((entry) => ({
+        jobId: entry.jobId,
+        status: entry.staleAgainstHead ? 'stale-evidence' : entry.conflictingJobIds.length ? 'semantic-overlap' : 'clean-apply',
+        reasons: uniqueStrings([...entry.reasons, ...entry.conflictKeys])
+    })) ?? [];
+    const fromBundles = !input.mergeIndex && input.bundles ? input.bundles.map((bundle) => ({
+        jobId: bundle.jobId,
+        status: bundle.staleAgainstHead ? 'stale-evidence' : 'clean-apply',
+        reasons: [...bundle.reasons]
+    })) : [];
+    const entries = [...fromIndex, ...fromBundles, ...(input.entries ?? [])].map((entry) => ({
+        jobId: entry.jobId,
+        status: entry.status ?? 'clean-apply',
+        reasons: uniqueStrings(entry.reasons ?? []),
+        ...('metadata' in entry && toJsonObject(entry.metadata) ? { metadata: toJsonObject(entry.metadata) } : {})
+    }));
+    const byStatus = groupIds(entries, (entry) => entry.status);
+    return {
+        kind: FRONTIER_SWARM_REBASE_REPORT_KIND,
+        version: FRONTIER_SWARM_REBASE_REPORT_VERSION,
+        id: input.id ?? 'swarm-rebase-report:' + stableHash([input.currentHead, entries, generatedAt]),
+        ...(input.currentHead ? { currentHead: input.currentHead } : {}),
+        generatedAt,
+        entries,
+        byStatus,
+        summary: {
+            entryCount: entries.length,
+            cleanCount: byStatus['clean-apply']?.length ?? 0,
+            conflictCount: (byStatus['textual-conflict']?.length ?? 0) + (byStatus['semantic-overlap']?.length ?? 0),
+            staleCount: byStatus['stale-evidence']?.length ?? 0
+        },
+        ...(toJsonObject(input.metadata) ? { metadata: toJsonObject(input.metadata) } : {})
+    };
+}
+export function createSwarmUsageGovernor(input = {}) {
+    const generatedAt = input.generatedAt ?? Date.now();
+    return {
+        kind: FRONTIER_SWARM_USAGE_GOVERNOR_KIND,
+        version: FRONTIER_SWARM_USAGE_GOVERNOR_VERSION,
+        id: input.id ?? 'swarm-usage-governor:' + stableHash([input.maxWorkers, input.maxTokensByLane, input.maxCostUsd, input.retryBudget, generatedAt]),
+        generatedAt,
+        ...(positiveNumber(input.maxWorkers) ? { maxWorkers: Math.floor(input.maxWorkers) } : {}),
+        maxTokensByLane: { ...(input.maxTokensByLane ?? {}) },
+        ...(positiveNumber(input.maxCostUsd) ? { maxCostUsd: input.maxCostUsd } : {}),
+        retryBudget: Math.max(0, Math.floor(input.retryBudget ?? 0)),
+        stopConditions: uniqueStrings(input.stopConditions ?? []),
+        preferStaticWhenLowBudget: input.preferStaticWhenLowBudget ?? true,
+        ...(toJsonObject(input.metadata) ? { metadata: toJsonObject(input.metadata) } : {})
+    };
+}
+export function checkSwarmUsageGovernor(governorInput, usage = {}) {
+    const governor = isSwarmUsageGovernor(governorInput) ? governorInput : createSwarmUsageGovernor(governorInput);
+    const reasons = [];
+    if (governor.maxWorkers !== undefined && (usage.activeWorkers ?? 0) > governor.maxWorkers)
+        reasons.push('max-workers');
+    if (governor.maxCostUsd !== undefined && (usage.costUsd ?? 0) > governor.maxCostUsd)
+        reasons.push('max-cost-usd');
+    if ((usage.retriesUsed ?? 0) > governor.retryBudget)
+        reasons.push('retry-budget');
+    for (const [lane, maxTokens] of Object.entries(governor.maxTokensByLane)) {
+        if ((usage.tokensByLane?.[lane] ?? 0) > maxTokens)
+            reasons.push(`max-tokens:${lane}`);
+    }
+    return {
+        ok: reasons.length === 0,
+        reasons,
+        ...(governor.maxWorkers !== undefined ? { recommendedMaxWorkers: Math.max(1, governor.maxWorkers - (reasons.length ? 1 : 0)) } : {}),
+        preferStatic: governor.preferStaticWhenLowBudget && reasons.some((reason) => reason.startsWith('max-tokens') || reason === 'max-cost-usd')
+    };
+}
+export function createSwarmLanePlaybook(input) {
+    const generatedAt = input.generatedAt ?? Date.now();
+    const successful = (input.successfulBundles ?? []).filter((bundle) => bundle.status === 'completed' || bundle.status === 'verified' || bundle.autoMergeable);
+    const hotPaths = createSwarmHotspotReport({ bundles: successful, threshold: 2, generatedAt }).entries
+        .filter((entry) => entry.touchCount >= 2)
+        .map((entry) => entry.path);
+    return {
+        kind: FRONTIER_SWARM_LANE_PLAYBOOK_KIND,
+        version: FRONTIER_SWARM_LANE_PLAYBOOK_VERSION,
+        id: input.id ?? 'swarm-lane-playbook:' + stableHash([input.lane, successful.map((bundle) => bundle.jobId), input.notes, generatedAt]),
+        lane: normalizeId(input.lane, 'playbook lane'),
+        title: input.title ?? `${titleFromId(input.lane)} Playbook`,
+        generatedAt,
+        notes: uniqueStrings(input.notes ?? []),
+        commands: normalizeCommands(input.commands ?? []),
+        avoidInvestigating: uniqueStrings(input.avoidInvestigating ?? []),
+        evidencePatterns: uniqueStrings(input.evidencePatterns ?? successful.flatMap((bundle) => bundle.evidencePaths)),
+        successfulJobIds: uniqueStrings(successful.map((bundle) => bundle.jobId)),
+        hotPaths,
+        changedRegions: uniqueStrings(successful.flatMap((bundle) => bundle.changedRegions)),
+        ...(toJsonObject(input.metadata) ? { metadata: toJsonObject(input.metadata) } : {})
+    };
+}
+export function createSwarmPatchStackPlan(input) {
+    const generatedAt = input.generatedAt ?? Date.now();
+    const maxStackSize = Math.max(1, Math.floor(input.maxStackSize ?? 8));
+    const groups = new Map();
+    for (const entry of input.index.entries) {
+        const key = patchStackKey(entry);
+        groups.set(key, [...(groups.get(key) ?? []), entry]);
+    }
+    const stacks = [];
+    for (const [key, entries] of Array.from(groups.entries()).sort((left, right) => left[0].localeCompare(right[0]))) {
+        const sorted = [...entries].sort((left, right) => riskRank(left.riskLevel) - riskRank(right.riskLevel) || left.jobId.localeCompare(right.jobId));
+        for (let index = 0; index < sorted.length; index += maxStackSize) {
+            const slice = sorted.slice(index, index + maxStackSize);
+            const jobIds = slice.map((entry) => entry.jobId);
+            const conflicts = input.index.conflicts.filter((conflict) => conflict.jobIds.some((jobId) => jobIds.includes(jobId)));
+            stacks.push({
+                id: 'swarm-patch-stack:' + stableHash([input.index.id, key, index, jobIds]),
+                title: titleFromId(key),
+                ...(slice[0]?.lane ? { lane: slice[0].lane } : {}),
+                jobIds,
+                changedPaths: uniqueStrings(slice.flatMap((entry) => entry.changedPaths)),
+                changedRegions: uniqueStrings(slice.flatMap((entry) => entry.changedRegions)),
+                riskLevels: uniqueStrings(slice.map((entry) => entry.riskLevel)),
+                dispositions: uniqueStrings(slice.map((entry) => entry.disposition)),
+                conflicts,
+                gateHints: uniqueStrings(slice.flatMap((entry) => entry.evidencePaths.filter((file) => file.endsWith('.json') || file.endsWith('.jsonl'))))
+            });
+        }
+    }
+    return {
+        kind: FRONTIER_SWARM_PATCH_STACK_PLAN_KIND,
+        version: FRONTIER_SWARM_PATCH_STACK_PLAN_VERSION,
+        id: input.id ?? 'swarm-patch-stack-plan:' + stableHash([input.index.id, stacks, generatedAt]),
+        mergeIndexId: input.index.id,
+        generatedAt,
+        stacks,
+        summary: {
+            stackCount: stacks.length,
+            jobCount: input.index.entries.length,
+            conflictedStackCount: stacks.filter((stack) => stack.conflicts.length > 0).length
+        },
+        ...(toJsonObject(input.metadata) ? { metadata: toJsonObject(input.metadata) } : {})
+    };
+}
 export function resolveSwarmCompute(manifestInput, taskInput) {
     const compiled = compileSwarm(manifestInput);
     const task = isSwarmTask(taskInput) ? taskInput : normalizeTask(taskInput);
@@ -474,6 +1647,7 @@ export function createSwarmSchedule(input) {
     const runningByLane = countBy(runningJobs.map((job) => job.lane));
     const runningByKey = countBy(runningJobs.map((job) => job.concurrencyKey));
     const runningByCompute = countBy(runningJobs.map((job) => job.compute));
+    const runningByResource = resourceUsageFromScheduled(runningJobs);
     const ready = [];
     const blocked = [];
     const sortedJobs = [...plan.jobs].sort((left, right) => left.priority - right.priority || left.id.localeCompare(right.id));
@@ -495,6 +1669,9 @@ export function createSwarmSchedule(input) {
         if ((runningByCompute[job.compute.id] ?? 0) >= computeMax)
             reasons.push('compute-capacity');
         const scheduled = scheduleJob(job, dependencyIds);
+        for (const resource of resourceQuotaViolations(scheduled, runningByResource, limits.resourceQuotas)) {
+            reasons.push(`resource-capacity:${resource}`);
+        }
         if (reasons.length) {
             blocked.push({ ...scheduled, reasons, waitingFor });
             continue;
@@ -507,6 +1684,7 @@ export function createSwarmSchedule(input) {
         runningByLane[job.lane] = (runningByLane[job.lane] ?? 0) + 1;
         runningByKey[job.concurrencyKey] = (runningByKey[job.concurrencyKey] ?? 0) + 1;
         runningByCompute[job.compute.id] = (runningByCompute[job.compute.id] ?? 0) + 1;
+        addResourceUsage(runningByResource, scheduled);
     }
     return {
         kind: FRONTIER_SWARM_SCHEDULE_KIND,
@@ -530,6 +1708,46 @@ export function createSwarmSchedule(input) {
         }
     };
 }
+export function createSwarmSchedulerRecommendations(input) {
+    const generatedAt = input.generatedAt ?? Date.now();
+    const recommendations = [];
+    const blockedByReason = new Map();
+    for (const job of input.schedule.blocked) {
+        for (const reason of job.reasons)
+            blockedByReason.set(reason, [...(blockedByReason.get(reason) ?? []), job]);
+    }
+    for (const [reason, jobs] of blockedByReason) {
+        const resource = reason.startsWith('resource-capacity:') ? reason.slice('resource-capacity:'.length) : undefined;
+        recommendations.push({
+            id: 'swarm-scheduler-recommendation:' + stableHash([input.schedule.id, reason, jobs.map((job) => job.jobId), generatedAt]),
+            reason,
+            jobIds: jobs.map((job) => job.jobId).sort(),
+            ...(resource ? { resource } : {}),
+            ...(jobs[0]?.lane ? { lane: jobs[0].lane } : {}),
+            action: schedulerActionForReason(reason),
+            priority: schedulerPriorityForReason(reason)
+        });
+    }
+    for (const conflict of input.mergeIndex?.conflicts ?? []) {
+        recommendations.push({
+            id: 'swarm-scheduler-recommendation:' + stableHash([input.schedule.id, conflict.key, conflict.jobIds, generatedAt]),
+            reason: `merge-conflict:${conflict.kind}`,
+            jobIds: [...conflict.jobIds],
+            action: 'serialize-conflicting-surface-or-split-ownership',
+            priority: 15
+        });
+    }
+    return {
+        kind: FRONTIER_SWARM_SCHEDULER_RECOMMENDATIONS_KIND,
+        version: FRONTIER_SWARM_SCHEDULER_RECOMMENDATIONS_VERSION,
+        id: input.id ?? 'swarm-scheduler-recommendations:' + stableHash([input.schedule.id, recommendations, generatedAt]),
+        scheduleId: input.schedule.id,
+        generatedAt,
+        recommendations: recommendations.sort((left, right) => left.priority - right.priority || left.id.localeCompare(right.id)),
+        summary: { recommendationCount: recommendations.length },
+        ...(toJsonObject(input.metadata) ? { metadata: toJsonObject(input.metadata) } : {})
+    };
+}
 export function createSwarmLeases(input) {
     const now = input.now ?? Date.now();
     const leaseMs = Math.max(1, Math.floor(input.leaseMs ?? 900000));
@@ -813,7 +2031,8 @@ function normalizeScheduleLimits(manifest, options) {
         ...(positiveNumber(options.maxReadyJobs) ? { maxReadyJobs: Math.floor(options.maxReadyJobs) } : {}),
         maxLaneConcurrency: { ...maxLaneConcurrency, ...(options.maxLaneConcurrency ?? {}) },
         maxConcurrencyKeyConcurrency: { ...(options.maxConcurrencyKeyConcurrency ?? {}) },
-        maxComputeConcurrency: { ...(options.maxComputeConcurrency ?? {}) }
+        maxComputeConcurrency: { ...(options.maxComputeConcurrency ?? {}) },
+        resourceQuotas: normalizeResourceQuotas(options.resourceQuotas ?? {})
     };
 }
 function mergeScheduleLimits(base, override) {
@@ -821,7 +2040,8 @@ function mergeScheduleLimits(base, override) {
         maxReadyJobs: positiveNumber(override.maxReadyJobs) ? Math.floor(override.maxReadyJobs) : base.maxReadyJobs,
         maxLaneConcurrency: { ...base.maxLaneConcurrency, ...(override.maxLaneConcurrency ?? {}) },
         maxConcurrencyKeyConcurrency: { ...base.maxConcurrencyKeyConcurrency, ...(override.maxConcurrencyKeyConcurrency ?? {}) },
-        maxComputeConcurrency: { ...base.maxComputeConcurrency, ...(override.maxComputeConcurrency ?? {}) }
+        maxComputeConcurrency: { ...base.maxComputeConcurrency, ...(override.maxComputeConcurrency ?? {}) },
+        resourceQuotas: { ...base.resourceQuotas, ...normalizeResourceQuotas(override.resourceQuotas ?? {}) }
     };
 }
 function scheduleJob(job, dependsOn = job.dependsOn) {
@@ -837,6 +2057,63 @@ function scheduleJob(job, dependsOn = job.dependsOn) {
         ...(job.resourceRequirements ? { resourceRequirements: cloneJsonValue(job.resourceRequirements) } : {})
     };
 }
+function normalizeResourceQuotas(input) {
+    const quotas = {};
+    for (const [resource, value] of Object.entries(input)) {
+        if (positiveNumber(value))
+            quotas[resource] = value;
+    }
+    return quotas;
+}
+function resourceUsageFromScheduled(jobs) {
+    const usage = {};
+    for (const job of jobs)
+        addResourceUsage(usage, job);
+    return usage;
+}
+function addResourceUsage(usage, job) {
+    for (const [resource, amount] of Object.entries(job.resourceRequirements?.resources ?? {})) {
+        usage[resource] = (usage[resource] ?? 0) + amount;
+    }
+    if (job.resourceRequirements?.browser?.required) {
+        if (job.resourceRequirements.resources.browser === undefined)
+            usage.browser = (usage.browser ?? 0) + 1;
+        if (job.resourceRequirements.resources['browser-port'] === undefined)
+            usage['browser-port'] = (usage['browser-port'] ?? 0) + 1;
+    }
+}
+function resourceQuotaViolations(job, usage, quotas) {
+    const next = { ...usage };
+    addResourceUsage(next, job);
+    return Object.entries(quotas)
+        .filter(([resource, quota]) => (next[resource] ?? 0) > quota)
+        .map(([resource]) => resource)
+        .sort();
+}
+function schedulerActionForReason(reason) {
+    if (reason.startsWith('resource-capacity:'))
+        return 'lower-concurrency-or-add-resource-pool';
+    if (reason === 'lane-capacity')
+        return 'increase-lane-capacity-or-split-lane';
+    if (reason === 'compute-capacity')
+        return 'increase-compute-capacity-or-use-another-compute';
+    if (reason === 'concurrency-key-capacity')
+        return 'serialize-or-split-concurrency-key';
+    if (reason === 'waiting-for-dependencies')
+        return 'prioritize-dependency-chain';
+    if (reason === 'ready-capacity')
+        return 'raise-ready-window-or-drain-ready-jobs';
+    return 'review-scheduler-blocker';
+}
+function schedulerPriorityForReason(reason) {
+    if (reason.startsWith('resource-capacity:'))
+        return 10;
+    if (reason === 'waiting-for-dependencies')
+        return 20;
+    if (reason === 'ready-capacity')
+        return 25;
+    return 30;
+}
 function normalizeBudget(input = {}) {
     return {
         ...(positiveNumber(input.maxCostUsd) ? { maxCostUsd: input.maxCostUsd } : {}),
@@ -900,31 +2177,469 @@ function selectReviewers(pool, required, salt) {
     return sorted.slice(0, Math.min(required, sorted.length));
 }
 function conflictMap(results) {
-    const byPath = new Map();
-    for (const result of results) {
-        const keys = result.changedRegions.length
-            ? result.changedRegions.map((region) => `region:${region}`)
-            : result.changedPaths.map((file) => `file:${file}`);
-        for (const key of keys) {
-            const list = byPath.get(key) ?? [];
-            list.push(result.jobId);
-            byPath.set(key, list);
+    const conflicts = new Map();
+    for (let leftIndex = 0; leftIndex < results.length; leftIndex += 1) {
+        for (let rightIndex = leftIndex + 1; rightIndex < results.length; rightIndex += 1) {
+            const left = results[leftIndex];
+            const right = results[rightIndex];
+            if (!left || !right || pairConflictKeys(left, right).length === 0)
+                continue;
+            const leftConflicts = conflicts.get(left.jobId) ?? new Set();
+            const rightConflicts = conflicts.get(right.jobId) ?? new Set();
+            leftConflicts.add(right.jobId);
+            rightConflicts.add(left.jobId);
+            conflicts.set(left.jobId, leftConflicts);
+            conflicts.set(right.jobId, rightConflicts);
         }
     }
-    const conflicts = new Map();
-    for (const jobIds of byPath.values()) {
-        if (jobIds.length < 2)
-            continue;
-        for (const jobId of jobIds) {
-            const set = conflicts.get(jobId) ?? new Set();
-            for (const other of jobIds) {
-                if (other !== jobId)
-                    set.add(other);
+    return conflicts;
+}
+function queueOverlayStatusFromBundle(bundle) {
+    if (bundle.staleAgainstHead || bundle.disposition === 'stale-against-head')
+        return 'stale-against-head';
+    if (bundle.disposition === 'rejected' || bundle.disposition === 'blocked' || bundle.status === 'failed' || bundle.commandsFailed.length > 0) {
+        return 'failed-evidence';
+    }
+    if (bundle.disposition === 'auto-mergeable' && bundle.autoMergeable)
+        return 'ready-to-apply';
+    if (bundle.disposition === 'needs-port')
+        return 'needs-human-port';
+    if (bundle.disposition === 'discovery-only')
+        return 'discovery-only';
+    if (bundle.mergeReadiness === 'blocked')
+        return 'blocked';
+    if (bundle.mergeReadiness === 'rejected')
+        return 'rejected';
+    return 'unknown';
+}
+function queueOverlayStatusFromResult(result) {
+    if (result.mergeDisposition === 'stale-against-head')
+        return 'stale-against-head';
+    if (result.status === 'failed' || result.exitCode !== undefined && result.exitCode !== 0 || result.ownershipViolations.length > 0)
+        return 'failed-evidence';
+    if (result.mergeDisposition === 'auto-mergeable')
+        return 'ready-to-apply';
+    if (result.mergeDisposition === 'needs-port')
+        return 'needs-human-port';
+    if (result.mergeDisposition === 'discovery-only')
+        return 'discovery-only';
+    if (result.status === 'blocked')
+        return 'blocked';
+    return 'unknown';
+}
+function queueJobStatusFromOverlay(entry) {
+    if (entry.status === 'ready-to-apply' || entry.status === 'discovery-only')
+        return 'completed';
+    if (entry.status === 'needs-human-port')
+        return 'blocked';
+    if (entry.status === 'failed-evidence' || entry.status === 'rejected' || entry.status === 'stale-against-head')
+        return 'failed';
+    if (entry.status === 'blocked')
+        return 'blocked';
+    return 'completed';
+}
+function groupOverlayEntries(entries) {
+    const out = {};
+    for (const entry of entries)
+        out[entry.queueItemId] = [...(out[entry.queueItemId] ?? []), entry];
+    for (const key of Object.keys(out)) {
+        out[key] = [...(out[key] ?? [])].sort((left, right) => right.generatedAt - left.generatedAt || left.jobId.localeCompare(right.jobId));
+    }
+    return out;
+}
+function mergeIndexConflictKeys(bundle) {
+    return bundle.changedRegions.length
+        ? bundle.changedRegions.map((region) => `region:${region}`).sort()
+        : bundle.changedPaths.map((file) => `path:${file}`).sort();
+}
+function createMergeIndexConflicts(entries) {
+    const conflicts = [];
+    for (let leftIndex = 0; leftIndex < entries.length; leftIndex += 1) {
+        for (let rightIndex = leftIndex + 1; rightIndex < entries.length; rightIndex += 1) {
+            const left = entries[leftIndex];
+            const right = entries[rightIndex];
+            if (!left || !right)
+                continue;
+            const keys = pairConflictKeys(left, right);
+            for (const key of keys) {
+                const kind = key.startsWith('region:') ? 'region' : 'path';
+                const value = key.slice(key.indexOf(':') + 1);
+                conflicts.push({
+                    jobIds: [left.jobId, right.jobId].sort(),
+                    key,
+                    kind,
+                    ...(kind === 'region' ? { region: value } : { path: value })
+                });
             }
-            conflicts.set(jobId, set);
         }
     }
-    return conflicts;
+    const deduped = new Map();
+    for (const conflict of conflicts)
+        deduped.set(`${conflict.key}:${conflict.jobIds.join(',')}`, conflict);
+    return Array.from(deduped.values()).sort((left, right) => left.key.localeCompare(right.key) || left.jobIds.join(',').localeCompare(right.jobIds.join(',')));
+}
+function pairConflictKeys(left, right) {
+    if (left.changedRegions.length > 0 && right.changedRegions.length > 0) {
+        const rightRegions = new Set(right.changedRegions);
+        return left.changedRegions.filter((region) => rightRegions.has(region)).map((region) => `region:${region}`).sort();
+    }
+    const rightPaths = new Set(right.changedPaths);
+    return left.changedPaths.filter((file) => rightPaths.has(file)).map((file) => `path:${file}`).sort();
+}
+function groupJobIdsBy(items, key) {
+    const out = {};
+    for (const item of items)
+        out[key(item)] = uniqueStrings([...(out[key(item)] ?? []), item.jobId]);
+    return out;
+}
+function groupJobIdsByMany(items, key) {
+    const out = {};
+    for (const item of items) {
+        for (const value of key(item))
+            out[value] = uniqueStrings([...(out[value] ?? []), item.jobId]);
+    }
+    return out;
+}
+function suggestedModuleId(file) {
+    const base = file.split('/').pop()?.replace(/\.[^.]+$/, '') ?? file;
+    return slug(base).replace(/-/g, '.');
+}
+function reviewerLaneReasons(entry) {
+    const reasons = [];
+    if (entry.conflictingJobIds.length)
+        reasons.push('conflicting-changes');
+    if (entry.riskLevel === 'high')
+        reasons.push('high-risk');
+    if (entry.disposition !== 'auto-mergeable')
+        reasons.push(entry.disposition);
+    if (!entry.autoMergeable)
+        reasons.push('not-auto-mergeable');
+    if (entry.staleAgainstHead)
+        reasons.push('stale-against-head');
+    return uniqueStrings(reasons);
+}
+function hashBucket(value, buckets) {
+    const hex = stableHash(value).split(':')[1] ?? '0';
+    return parseInt(hex, 16) % Math.max(1, buckets);
+}
+function normalizeOracleArtifact(input) {
+    return {
+        id: normalizeId(input.id, 'oracle artifact id'),
+        path: normalizeId(input.path, 'oracle artifact path'),
+        kind: input.kind ?? 'oracle',
+        ...(input.command ? { command: typeof input.command === 'string' ? normalizeCommands([input.command])[0] : normalizeCommands([input.command])[0] } : {}),
+        ...(input.hash ? { hash: input.hash } : {}),
+        ...(input.sourceRef ? { sourceRef: input.sourceRef } : {}),
+        tags: uniqueStrings(input.tags ?? []),
+        ...(toJsonObject(input.metadata) ? { metadata: toJsonObject(input.metadata) } : {})
+    };
+}
+function normalizeCommand(input) {
+    return normalizeCommands([input])[0];
+}
+function normalizeNamedRef(input, fallbackKind) {
+    if (typeof input === 'string' || typeof input === 'number') {
+        const value = String(input);
+        return { id: value, kind: fallbackKind, path: value, tags: [] };
+    }
+    const path = input.path ?? input.uri;
+    const id = input.id ?? path ?? stableHash(input);
+    return {
+        id,
+        kind: input.kind ?? fallbackKind,
+        ...(input.path ? { path: input.path } : {}),
+        ...(input.uri ? { uri: input.uri } : {}),
+        ...(input.role ? { role: input.role } : {}),
+        ...(input.hash ? { hash: input.hash } : {}),
+        ...(positiveNumber(input.bytes) ? { bytes: Math.floor(input.bytes) } : {}),
+        tags: uniqueStrings(input.tags ?? []),
+        ...(toJsonObject(input.metadata) ? { metadata: toJsonObject(input.metadata) } : {})
+    };
+}
+function normalizeNamedRefs(input, fallbackKind) {
+    return input.map((entry) => normalizeNamedRef(entry, fallbackKind)).sort((left, right) => left.id.localeCompare(right.id));
+}
+function normalizeSeedRefs(input) {
+    return input.map((entry) => normalizeNamedRef(entry, 'seed')).sort((left, right) => left.id.localeCompare(right.id));
+}
+function normalizeParityComparator(input) {
+    const title = input.title ?? titleFromId(input.id ?? input.path ?? 'comparator');
+    return {
+        id: input.id ?? 'swarm-parity-comparator:' + stableHash([title, input.status, input.expected, input.actual, input.path, input.operationIndex]),
+        title,
+        status: input.status ?? (input.expected !== undefined && input.actual !== undefined && stableStringify(input.expected) === stableStringify(input.actual) ? 'passed' : 'unknown'),
+        ...(input.expected !== undefined ? { expected: toJsonValue(input.expected) } : {}),
+        ...(input.actual !== undefined ? { actual: toJsonValue(input.actual) } : {}),
+        ...(input.path ? { path: input.path } : {}),
+        ...(input.operationIndex !== undefined ? { operationIndex: Math.max(0, Math.floor(input.operationIndex)) } : {}),
+        evidenceRefs: normalizeNamedRefs(input.evidenceRefs ?? [], 'evidence'),
+        ...(toJsonObject(input.metadata) ? { metadata: toJsonObject(input.metadata) } : {})
+    };
+}
+function inferParityStatus(comparators) {
+    if (comparators.some((comparator) => comparator.status === 'failed'))
+        return 'failed';
+    if (comparators.some((comparator) => comparator.status === 'blocked'))
+        return 'blocked';
+    if (comparators.length > 0 && comparators.every((comparator) => comparator.status === 'passed'))
+        return 'passed';
+    return 'pending';
+}
+function normalizeWatchpoint(input) {
+    const title = input.title ?? titleFromId(input.id ?? input.path ?? input.selector ?? input.target ?? 'watchpoint');
+    return {
+        id: input.id ?? 'swarm-watchpoint:' + stableHash([input.target, input.path, input.selector, input.operator, input.value, input.action]),
+        title,
+        ...(input.target ? { target: input.target } : {}),
+        ...(input.path ? { path: input.path } : {}),
+        ...(input.selector ? { selector: input.selector } : {}),
+        operator: input.operator ?? 'changed',
+        ...(input.value !== undefined ? { value: toJsonValue(input.value) } : {}),
+        action: input.action ?? 'capture',
+        ...(toJsonObject(input.metadata) ? { metadata: toJsonObject(input.metadata) } : {})
+    };
+}
+function normalizeBottleneckSource(input) {
+    if (input.kind === FRONTIER_SWARM_MERGE_BUNDLE_KIND) {
+        const bundle = input;
+        return {
+            jobId: bundle.jobId,
+            lane: bundle.lane,
+            status: bundle.status,
+            reasons: bundle.reasons,
+            evidencePaths: bundle.evidencePaths,
+            changedPaths: bundle.changedPaths,
+            text: bundle.title,
+            metadata: bundle.metadata
+        };
+    }
+    if ('text' in input || 'reasons' in input || 'lane' in input)
+        return input;
+    const result = input;
+    if (result.jobId) {
+        return {
+            jobId: result.jobId,
+            status: result.status,
+            reasons: result.error !== undefined ? [stringifyError(result.error)] : [],
+            verification: result.verification,
+            evidencePaths: result.evidencePaths,
+            changedPaths: result.changedPaths,
+            text: result.lastMessage,
+            metadata: result.metadata
+        };
+    }
+    return input;
+}
+function routeForBottleneck(kind, lane) {
+    if (kind === 'missing-oracle')
+        return { lane: lane ?? 'verification', workKind: 'oracle', priority: 20 };
+    if (kind === 'flaky-harness')
+        return { lane: lane ?? 'evidence', workKind: 'harness', priority: 25 };
+    if (kind === 'merge-review')
+        return { lane: lane ?? 'review', workKind: 'review', priority: 10 };
+    if (kind === 'instrumentation-overhead')
+        return { lane: lane ?? 'diagnostics', workKind: 'instrumentation', priority: 30 };
+    if (kind === 'performance')
+        return { lane: lane ?? 'performance', workKind: 'benchmark', priority: 35 };
+    if (kind === 'correctness')
+        return { lane: lane ?? 'implementation', workKind: 'debug', priority: 15 };
+    return { ...(lane ? { lane } : {}), workKind: 'triage', priority: 50 };
+}
+function evidenceKindFromPath(path) {
+    const lower = path.toLowerCase();
+    if (lower.endsWith('.patch') || lower.endsWith('.diff'))
+        return 'patch';
+    if (lower.endsWith('.jsonl'))
+        return 'jsonl';
+    if (lower.endsWith('.json'))
+        return 'json';
+    if (lower.includes('trace'))
+        return 'trace';
+    if (lower.includes('screenshot'))
+        return 'screenshot';
+    if (lower.includes('last-message'))
+        return 'handoff';
+    return 'evidence';
+}
+function normalizeEvidenceIndexEntry(input) {
+    const generatedAt = input.generatedAt ?? Date.now();
+    return {
+        id: input.id ?? 'swarm-evidence-entry:' + stableHash([input.jobId, input.queueItemId, input.path, input.topic, input.kind, generatedAt]),
+        ...(input.jobId ? { jobId: input.jobId } : {}),
+        ...(input.queueItemId ? { queueItemId: input.queueItemId } : {}),
+        ...(input.lane ? { lane: input.lane } : {}),
+        ...(input.topic ? { topic: input.topic } : {}),
+        ...(input.path ? { path: input.path } : {}),
+        kind: input.kind ?? (input.path ? evidenceKindFromPath(input.path) : 'evidence'),
+        status: input.status ?? 'unknown',
+        confidence: clamp01(input.confidence ?? 0.5),
+        tags: uniqueStrings(input.tags ?? []),
+        facets: normalizeFacets(input.facets ?? {}),
+        generatedAt,
+        ...(toJsonObject(input.metadata) ? { metadata: toJsonObject(input.metadata) } : {})
+    };
+}
+function matchesFacetQuery(facets, query) {
+    if (!query)
+        return true;
+    return Object.entries(query).every(([key, value]) => facets[key] === value);
+}
+function normalizeFacets(input) {
+    return Object.fromEntries(Object.entries(input).filter(([, value]) => ['string', 'number', 'boolean'].includes(typeof value)));
+}
+function normalizeBlackboardEntry(input) {
+    const generatedAt = input.generatedAt ?? Date.now();
+    const topic = input.topic ?? input.kind ?? 'general';
+    return {
+        id: input.id ?? 'swarm-blackboard-entry:' + stableHash([input.kind, topic, input.text, input.sourceIds, generatedAt]),
+        kind: input.kind ?? 'fact',
+        topic,
+        status: input.status ?? 'fresh',
+        text: input.text ?? '',
+        ...(input.lane ? { lane: input.lane } : {}),
+        ...(input.jobId ? { jobId: input.jobId } : {}),
+        ...(input.owner ? { owner: input.owner } : {}),
+        confidence: input.confidence ?? 'medium',
+        sourceIds: uniqueStrings(input.sourceIds ?? []),
+        paths: uniqueStrings(input.paths ?? []),
+        tags: uniqueStrings(input.tags ?? []),
+        supersedes: uniqueStrings(input.supersedes ?? []),
+        generatedAt,
+        ...(toJsonObject(input.metadata) ? { metadata: toJsonObject(input.metadata) } : {})
+    };
+}
+function normalizeReferenceWindow(input) {
+    return {
+        ...(input.start !== undefined ? { start: Math.max(0, Math.floor(input.start)) } : {}),
+        ...(input.end !== undefined ? { end: Math.max(0, Math.floor(input.end)) } : {}),
+        ...(input.focus ? { focus: input.focus } : {}),
+        ...(toJsonObject(input.metadata) ? { metadata: toJsonObject(input.metadata) } : {})
+    };
+}
+function normalizeRoutingHint(input) {
+    return {
+        ...(input.artifactKind ? { artifactKind: input.artifactKind } : {}),
+        ...(input.pathPattern ? { pathPattern: input.pathPattern } : {}),
+        ...(input.lane ? { lane: input.lane } : {}),
+        bucket: input.bucket ?? 'needs-human-port',
+        reason: input.reason ?? 'matched-routing-hint',
+        ...(toJsonObject(input.metadata) ? { metadata: toJsonObject(input.metadata) } : {})
+    };
+}
+function defaultArtifactBucket(artifact) {
+    if (artifact.kind === 'patch')
+        return 'ready-to-apply';
+    if (artifact.kind === 'handoff' || artifact.kind === 'trace' || artifact.kind === 'jsonl')
+        return 'discovery-only';
+    return 'needs-human-port';
+}
+function normalizeFixture(input) {
+    return {
+        id: normalizeId(input.id, 'fixture id'),
+        title: input.title ?? titleFromId(input.id),
+        ...(input.description ? { description: input.description } : {}),
+        ...(input.state !== undefined ? { state: toJsonValue(input.state) } : {}),
+        artifacts: normalizeNamedRefs(input.artifacts ?? [], 'fixture-artifact'),
+        setupCommands: normalizeCommands(input.setupCommands ?? []),
+        tags: uniqueStrings(input.tags ?? []),
+        ...(toJsonObject(input.metadata) ? { metadata: toJsonObject(input.metadata) } : {})
+    };
+}
+function deriveAutoReviewFindings(bundle, generatedAt) {
+    const findings = [];
+    if (bundle.ownershipViolations.length) {
+        findings.push(normalizeAutoReviewFinding({
+            jobId: bundle.jobId,
+            kind: 'ownership-violation',
+            severity: 'error',
+            message: 'Bundle changed paths outside its ownership lease.',
+            paths: bundle.ownershipViolations,
+            evidencePaths: bundle.evidencePaths
+        }, generatedAt));
+    }
+    if (bundle.evidencePaths.length === 0 && bundle.changedPaths.length > 0) {
+        findings.push(normalizeAutoReviewFinding({
+            jobId: bundle.jobId,
+            kind: 'missing-evidence',
+            severity: 'warning',
+            message: 'Patch bundle has changed paths but no evidence paths.',
+            paths: bundle.changedPaths
+        }, generatedAt));
+    }
+    if (bundle.changedPaths.length > 12) {
+        findings.push(normalizeAutoReviewFinding({
+            jobId: bundle.jobId,
+            kind: 'overlarge-patch',
+            severity: 'warning',
+            message: 'Patch bundle touches many files and should be split or reviewed manually.',
+            paths: bundle.changedPaths,
+            evidencePaths: bundle.evidencePaths
+        }, generatedAt));
+    }
+    return findings;
+}
+function normalizeAutoReviewFinding(input, generatedAt) {
+    return {
+        id: input.id ?? 'swarm-auto-review-finding:' + stableHash([input.jobId, input.kind, input.message, input.paths, generatedAt]),
+        ...(input.jobId ? { jobId: input.jobId } : {}),
+        kind: input.kind ?? 'weak-evidence',
+        severity: input.severity ?? 'warning',
+        message: input.message,
+        paths: uniqueStrings(input.paths ?? []),
+        evidencePaths: uniqueStrings(input.evidencePaths ?? []),
+        ...(toJsonObject(input.metadata) ? { metadata: toJsonObject(input.metadata) } : {})
+    };
+}
+function isSwarmObservabilityPoint(value) {
+    return !!value && typeof value === 'object' && value.kind === FRONTIER_SWARM_OBSERVABILITY_POINT_KIND;
+}
+function isSwarmInstrumentationBudget(value) {
+    return !!value && typeof value === 'object' && value.kind === FRONTIER_SWARM_INSTRUMENTATION_BUDGET_KIND;
+}
+function isSwarmUsageGovernor(value) {
+    return !!value && typeof value === 'object' && value.kind === FRONTIER_SWARM_USAGE_GOVERNOR_KIND;
+}
+function isSwarmRun(value) {
+    return !!value && typeof value === 'object' && value.kind === FRONTIER_SWARM_RUN_KIND;
+}
+function groupObjects(items, key) {
+    const out = {};
+    for (const item of items) {
+        const group = key(item);
+        out[group] = [...(out[group] ?? []), item];
+    }
+    return out;
+}
+function clamp01(value) {
+    if (!Number.isFinite(value))
+        return 0;
+    return Math.max(0, Math.min(1, value));
+}
+function groupArtifactIdsBy(artifacts, key) {
+    const out = {};
+    for (const artifact of artifacts) {
+        for (const value of key(artifact))
+            out[value] = uniqueStrings([...(out[value] ?? []), artifact.id]);
+    }
+    return out;
+}
+function patchStackKey(entry) {
+    const lane = entry.lane ?? 'unassigned';
+    if (entry.changedRegions.length)
+        return `${lane}:${entry.changedRegions[0]}`;
+    const firstPath = entry.changedPaths[0] ?? 'evidence-only';
+    return `${lane}:${firstPath.split('/').slice(0, 2).join('/') || firstPath}`;
+}
+function riskRank(risk) {
+    if (risk === 'low')
+        return 0;
+    if (risk === 'medium')
+        return 1;
+    if (risk === 'unknown')
+        return 2;
+    if (risk === 'high')
+        return 3;
+    return 4;
 }
 function groupMergeReadyJobs(ready, results) {
     const byJob = new Map(results.map((result) => [result.jobId, result]));
@@ -949,7 +2664,10 @@ function groupIds(items, key) {
     const out = {};
     for (const item of items) {
         const group = key(item);
-        out[group] = [...(out[group] ?? []), item.jobId];
+        const id = item.jobId ?? item.id;
+        if (!id)
+            continue;
+        out[group] = [...(out[group] ?? []), id];
     }
     for (const ids of Object.values(out))
         ids.sort();