@shapeshift-labs/frontier-swarm 0.5.9 → 0.5.11

package/dist/index.js

@@ -1,4527 +1,35 @@
-export const FRONTIER_SWARM_MANIFEST_KIND = 'frontier.swarm.manifest';
-export const FRONTIER_SWARM_MANIFEST_VERSION = 1;
-export const FRONTIER_SWARM_TASK_KIND = 'frontier.swarm.task';
-export const FRONTIER_SWARM_TASK_VERSION = 1;
-export const FRONTIER_SWARM_PLAN_KIND = 'frontier.swarm.plan';
-export const FRONTIER_SWARM_PLAN_VERSION = 1;
-export const FRONTIER_SWARM_RUN_KIND = 'frontier.swarm.run';
-export const FRONTIER_SWARM_RUN_VERSION = 1;
-export const FRONTIER_SWARM_EVENT_KIND = 'frontier.swarm.event';
-export const FRONTIER_SWARM_EVENT_VERSION = 1;
-export const FRONTIER_SWARM_EVENT_STREAM_KIND = 'frontier.swarm.event-stream';
-export const FRONTIER_SWARM_EVENT_STREAM_VERSION = 1;
-export const FRONTIER_SWARM_MAILBOX_KIND = 'frontier.swarm.mailbox';
-export const FRONTIER_SWARM_MAILBOX_VERSION = 1;
-export const FRONTIER_SWARM_PROOF_KIND = 'frontier.swarm.proof';
-export const FRONTIER_SWARM_PROOF_VERSION = 1;
-export const FRONTIER_SWARM_SCHEDULE_KIND = 'frontier.swarm.schedule';
-export const FRONTIER_SWARM_SCHEDULE_VERSION = 1;
-export const FRONTIER_SWARM_LEASE_KIND = 'frontier.swarm.lease';
-export const FRONTIER_SWARM_LEASE_VERSION = 1;
-export const FRONTIER_SWARM_QUEUE_SNAPSHOT_KIND = 'frontier.swarm.queue-snapshot';
-export const FRONTIER_SWARM_QUEUE_SNAPSHOT_VERSION = 1;
-export const FRONTIER_SWARM_RUN_CHECKPOINT_KIND = 'frontier.swarm.run-checkpoint';
-export const FRONTIER_SWARM_RUN_CHECKPOINT_VERSION = 1;
-export const FRONTIER_SWARM_ARTIFACT_INDEX_KIND = 'frontier.swarm.artifact-index';
-export const FRONTIER_SWARM_ARTIFACT_INDEX_VERSION = 1;
-export const FRONTIER_SWARM_REVIEW_PLAN_KIND = 'frontier.swarm.review-plan';
-export const FRONTIER_SWARM_REVIEW_PLAN_VERSION = 1;
-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_COORDINATOR_DASHBOARD_KIND = 'frontier.swarm.coordinator-dashboard';
-export const FRONTIER_SWARM_COORDINATOR_DASHBOARD_VERSION = 1;
-export const FRONTIER_SWARM_ADAPTIVE_LOAD_PLAN_KIND = 'frontier.swarm.adaptive-load-plan';
-export const FRONTIER_SWARM_ADAPTIVE_LOAD_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';
-const DEFAULT_COMPLETED_STATUSES = ['completed', 'verified', 'done', 'verified-local-harness'];
-const DEFAULT_SWARM_EVENT_TYPES = [
-    'swarm.started',
-    'swarm.finished',
-    'agent.scheduled',
-    'agent.finished',
-    'agent.handoff',
-    'agent.blocked',
-    'agent.ownership-request',
-    'agent.evidence',
-    'review.requested',
-    'review.completed',
-    'merge.proposed'
-];
-export function defineSwarmManifest(input = {}) {
-    return createSwarmManifest(input);
-}
-export function createSwarmManifest(input = {}) {
-    const compute = normalizeComputeList(input.compute);
-    const defaultCompute = input.policy?.defaultCompute ?? compute[0]?.id ?? FRONTIER_SWARM_DEFAULT_CODEX_COMPUTE_ID;
-    const layers = (input.layers ?? []).map(normalizeLayer);
-    const lanes = (input.lanes ?? []).map(normalizeLane);
-    const policy = normalizePolicy(input.policy, defaultCompute);
-    return {
-        kind: FRONTIER_SWARM_MANIFEST_KIND,
-        version: FRONTIER_SWARM_MANIFEST_VERSION,
-        id: normalizeId(input.id ?? 'frontier-swarm', 'manifest id'),
-        title: input.title ?? titleFromId(input.id ?? 'frontier swarm'),
-        ...(input.description ? { description: input.description } : {}),
-        ...(input.package ? { package: input.package } : {}),
-        ...(input.feature ? { feature: input.feature } : {}),
-        ...(input.owner ? { owner: input.owner } : {}),
-        compute,
-        layers,
-        lanes,
-        policy,
-        resources: uniqueStrings(input.resources ?? []),
-        tags: uniqueStrings(input.tags ?? []),
-        ...(toJsonObject(input.metadata) ? { metadata: toJsonObject(input.metadata) } : {}),
-        summary: {
-            computeCount: compute.length,
-            layerCount: layers.length,
-            laneCount: lanes.length
-        }
-    };
-}
-export function defineSwarmTasks(input = []) {
-    const raw = Array.isArray(input) ? input : (input.tasks ?? input.items ?? []);
-    return raw.map(normalizeTask);
-}
-export function compileSwarm(input) {
-    const manifest = isSwarmManifest(input) ? cloneJsonValue(input) : createSwarmManifest(input);
-    const computeById = new Map(manifest.compute.map((compute) => [compute.id, compute]));
-    const layersById = new Map(manifest.layers.map((layer) => [layer.id, layer]));
-    const lanesById = new Map(manifest.lanes.map((lane) => [lane.id, lane]));
-    return {
-        manifest,
-        computeById,
-        layersById,
-        lanesById,
-        validation: validateSwarmManifest(manifest)
-    };
-}
-export function validateSwarmManifest(input) {
-    const manifest = isSwarmManifest(input) ? input : createSwarmManifest(input);
-    const issues = [];
-    const computeIds = new Set();
-    const layerIds = new Set();
-    const laneIds = new Set();
-    for (const compute of manifest.compute) {
-        if (computeIds.has(compute.id))
-            addIssue(issues, 'duplicate-compute', 'error', `compute.${compute.id}`, `Duplicate compute id: ${compute.id}`);
-        computeIds.add(compute.id);
-    }
-    if (!computeIds.has(manifest.policy.defaultCompute)) {
-        addIssue(issues, 'missing-default-compute', 'error', 'policy.defaultCompute', `Default compute is not declared: ${manifest.policy.defaultCompute}`);
-    }
-    for (const layer of manifest.layers) {
-        if (layerIds.has(layer.id))
-            addIssue(issues, 'duplicate-layer', 'error', `layers.${layer.id}`, `Duplicate layer id: ${layer.id}`);
-        layerIds.add(layer.id);
-    }
-    for (const layer of manifest.layers) {
-        if (layer.parentId && !layerIds.has(layer.parentId)) {
-            addIssue(issues, 'missing-parent-layer', 'error', `layers.${layer.id}.parentId`, `Layer parent is not declared: ${layer.parentId}`);
-        }
-        for (const [childLayer, compute] of Object.entries(layer.childCompute)) {
-            if (childLayer !== '*' && !layerIds.has(childLayer)) {
-                addIssue(issues, 'missing-child-layer', 'error', `layers.${layer.id}.childCompute.${childLayer}`, `Child layer is not declared: ${childLayer}`);
-            }
-            if (!computeIds.has(compute)) {
-                addIssue(issues, 'missing-child-compute', 'error', `layers.${layer.id}.childCompute.${childLayer}`, `Child compute is not declared: ${compute}`);
-            }
-        }
-        for (const field of ['compute', 'defaultCompute']) {
-            const compute = layer[field];
-            if (compute && !computeIds.has(compute)) {
-                addIssue(issues, 'missing-layer-compute', 'error', `layers.${layer.id}.${field}`, `Layer compute is not declared: ${compute}`);
-            }
-        }
-        if (hasLayerCycle(layer.id, manifest.layers)) {
-            addIssue(issues, 'layer-cycle', 'error', `layers.${layer.id}`, `Layer parent chain contains a cycle at ${layer.id}`);
-        }
-    }
-    for (const lane of manifest.lanes) {
-        if (laneIds.has(lane.id))
-            addIssue(issues, 'duplicate-lane', 'error', `lanes.${lane.id}`, `Duplicate lane id: ${lane.id}`);
-        laneIds.add(lane.id);
-        if (lane.layer && !layerIds.has(lane.layer)) {
-            addIssue(issues, 'missing-lane-layer', 'error', `lanes.${lane.id}.layer`, `Lane layer is not declared: ${lane.layer}`);
-        }
-        if (lane.compute && !computeIds.has(lane.compute)) {
-            addIssue(issues, 'missing-lane-compute', 'error', `lanes.${lane.id}.compute`, `Lane compute is not declared: ${lane.compute}`);
-        }
-    }
-    return { valid: issues.every((issue) => issue.severity !== 'error'), issues };
-}
-export function createSwarmPlan(manifestInput, taskInput, options = {}) {
-    const compiled = compileSwarm(manifestInput);
-    const tasks = normalizeTaskList(taskInput);
-    const jobs = selectSwarmTasks(compiled.manifest, tasks, options).map((task) => createJob(compiled, task, options));
-    const id = options.id ?? 'swarm-plan:' + stableHash([compiled.manifest.id, jobs.map((job) => job.id), options]);
-    const graph = createSwarmJobGraph(jobs);
-    const validation = validateTasksForManifest(compiled, tasks, graph);
-    return {
-        kind: FRONTIER_SWARM_PLAN_KIND,
-        version: FRONTIER_SWARM_PLAN_VERSION,
-        id,
-        runId: options.runId ?? id.replace(/^swarm-plan:/, 'swarm-run:'),
-        manifestId: compiled.manifest.id,
-        createdAt: options.now ?? Date.now(),
-        filters: {
-            lanes: options.lanes ? [...options.lanes] : undefined,
-            layers: options.layers ? [...options.layers] : undefined,
-            statuses: options.statuses ? [...options.statuses] : undefined,
-            selectors: options.selectors ? [...options.selectors] : undefined,
-            includeCompleted: options.includeCompleted,
-            limit: options.limit,
-            compute: options.compute
-        },
-        limits: normalizeScheduleLimits(compiled.manifest, options),
-        validation,
-        jobs,
-        graph,
-        summary: summarizeJobs(jobs),
-        ...(toJsonObject(options.metadata) ? { metadata: toJsonObject(options.metadata) } : {})
-    };
-}
-export function createSwarmTaskSelection(manifestInput, taskInput, options = {}) {
-    const manifest = compileSwarm(manifestInput).manifest;
-    const tasks = normalizeTaskList(taskInput);
-    const lanes = new Set(options.lanes ?? []);
-    const layers = new Set(options.layers ?? []);
-    const statuses = new Set(options.statuses ?? []);
-    const workKinds = new Set(options.workKinds ?? []);
-    const selectors = (options.selectors ?? []).map((selector) => selector.toLowerCase());
-    const completed = new Set(manifest.policy.completedStatuses);
-    const limit = options.limit === undefined ? tasks.length : Math.max(0, Math.floor(options.limit));
-    const candidates = tasks
-        .filter((task) => !task.lane || manifest.lanes.some((lane) => lane.id === task.lane))
-        .filter((task) => lanes.size === 0 || (task.lane !== undefined && lanes.has(task.lane)))
-        .filter((task) => layers.size === 0 || taskLayer(manifest, task) !== undefined && layers.has(taskLayer(manifest, task)))
-        .filter((task) => statuses.size === 0 || statuses.has(task.status))
-        .filter((task) => workKinds.size === 0 || workKinds.has(task.workKind))
-        .filter((task) => options.includeCompleted || !completed.has(task.status))
-        .filter((task) => selectors.length === 0 || selectors.some((selector) => searchableTask(task).includes(selector)))
-        .map((task) => createSelectionEntry(manifest, task, options.priority))
-        .filter((entry) => options.includeOwnershipWarnings || entry.ownershipWarnings.length === 0)
-        .sort((left, right) => (left.selectionPriority - right.selectionPriority
-        || left.task.priority - right.task.priority
-        || left.task.id.localeCompare(right.task.id)));
-    const ordered = options.spreadLanes ? roundRobinSelectionByLane(candidates) : candidates;
-    const entries = ordered.slice(0, limit).map((entry, index) => {
-        if (!options.assignSelectionPriority)
-            return entry;
-        return { ...entry, task: { ...entry.task, priority: index } };
-    });
-    return {
-        tasks: entries.map((entry) => entry.task),
-        entries,
-        summary: summarizeTaskSelection(entries)
-    };
-}
-export function createSwarmRun(input) {
-    const results = (input.results ?? []).map(normalizeResult);
-    const events = (input.events ?? []).map((event) => normalizeEvent({ ...event, runId: event.runId ?? input.id ?? input.plan.runId }));
-    const run = {
-        kind: FRONTIER_SWARM_RUN_KIND,
-        version: FRONTIER_SWARM_RUN_VERSION,
-        id: input.id ?? input.plan.runId,
-        planId: input.plan.id,
-        manifestId: input.plan.manifestId,
-        startedAt: input.startedAt ?? Date.now(),
-        status: input.status ?? 'planned',
-        jobs: input.plan.jobs.map((job) => cloneJsonValue(job)),
-        events,
-        results,
-        summary: summarizeRun(input.plan.jobs, results),
-        ...(toJsonObject(input.metadata) ? { metadata: toJsonObject(input.metadata) } : {})
-    };
-    return run;
-}
-export function recordSwarmEvent(runInput, eventInput) {
-    const run = cloneJsonValue(runInput);
-    run.events = run.events.concat(normalizeEvent({ ...eventInput, runId: eventInput.runId ?? run.id }));
-    return run;
-}
-export function createSwarmMailbox(input = {}) {
-    const scope = input.scope ?? (input.lane ? 'lane' : input.jobId ? 'job' : 'global');
-    const eventTypes = uniqueStrings(input.eventTypes ?? DEFAULT_SWARM_EVENT_TYPES);
-    return {
-        kind: FRONTIER_SWARM_MAILBOX_KIND,
-        version: FRONTIER_SWARM_MAILBOX_VERSION,
-        id: input.id ?? 'swarm-mailbox:' + stableHash([input.runId, scope, input.lane, input.jobId, input.path, eventTypes]),
-        ...(input.runId ? { runId: input.runId } : {}),
-        scope,
-        ...(input.lane ? { lane: input.lane } : {}),
-        ...(input.jobId ? { jobId: input.jobId } : {}),
-        ...(input.path ? { path: input.path } : {}),
-        eventTypes,
-        appendOnly: input.appendOnly ?? true,
-        ...(toJsonObject(input.metadata) ? { metadata: toJsonObject(input.metadata) } : {})
-    };
-}
-export function createSwarmEventStream(input = {}) {
-    const laneIds = uniqueStrings((input.lanes ?? []).map(readLaneId));
-    const eventTypes = uniqueStrings(input.eventTypes ?? DEFAULT_SWARM_EVENT_TYPES);
-    const appendOnly = input.appendOnly ?? true;
-    const global = createSwarmMailbox({
-        runId: input.runId,
-        scope: 'global',
-        path: input.root ? joinPathParts(input.root, 'global.jsonl') : undefined,
-        eventTypes,
-        appendOnly
-    });
-    const lanes = Object.fromEntries(laneIds.map((lane) => [lane, createSwarmMailbox({
-            runId: input.runId,
-            scope: 'lane',
-            lane,
-            path: input.root ? joinPathParts(input.root, 'lanes', `${lane}.jsonl`) : undefined,
-            eventTypes,
-            appendOnly
-        })]));
-    return {
-        kind: FRONTIER_SWARM_EVENT_STREAM_KIND,
-        version: FRONTIER_SWARM_EVENT_STREAM_VERSION,
-        id: input.id ?? 'swarm-event-stream:' + stableHash([input.runId, input.root, laneIds, eventTypes]),
-        ...(input.runId ? { runId: input.runId } : {}),
-        ...(input.root ? { root: input.root } : {}),
-        appendOnly,
-        global,
-        lanes,
-        eventTypes,
-        ...(toJsonObject(input.metadata) ? { metadata: toJsonObject(input.metadata) } : {}),
-        summary: {
-            mailboxCount: 1 + laneIds.length,
-            laneCount: laneIds.length,
-            eventTypeCount: eventTypes.length
-        }
-    };
-}
-export function routeSwarmEventToMailboxes(stream, eventInput) {
-    const event = isSwarmEvent(eventInput) ? eventInput : normalizeEvent(eventInput);
-    const mailboxes = [stream.global];
-    if (event.lane && stream.lanes[event.lane])
-        mailboxes.push(stream.lanes[event.lane]);
-    return mailboxes;
-}
-export function completeSwarmJob(runInput, resultInput) {
-    const run = cloneJsonValue(runInput);
-    const result = normalizeResult(resultInput);
-    const resultIndex = run.results.findIndex((entry) => entry.jobId === result.jobId);
-    if (resultIndex >= 0)
-        run.results[resultIndex] = result;
-    else
-        run.results.push(result);
-    run.jobs = run.jobs.map((job) => job.id === result.jobId ? { ...job, status: result.status } : job);
-    run.summary = summarizeRun(run.jobs, run.results);
-    if (run.results.length >= run.jobs.length && run.summary.failedCount === 0 && run.summary.blockedCount === 0) {
-        run.status = 'completed';
-        run.finishedAt = result.finishedAt ?? Date.now();
-    }
-    else if (run.summary.failedCount && run.summary.failedCount > 0) {
-        run.status = 'failed';
-    }
-    return run;
-}
-export function checkSwarmOwnership(job, changedPaths) {
-    const changed = uniqueStrings(changedPaths);
-    const violations = changed.filter((file) => !job.allowedWrites.some((glob) => matchesGlob(file, glob)));
-    return {
-        ok: violations.length === 0,
-        changedPaths: changed,
-        allowedWrites: [...job.allowedWrites],
-        violations
-    };
-}
-export function resolveSwarmChangedRegions(job, changedPaths) {
-    const changed = uniqueStrings(changedPaths);
-    const regions = new Set(job.changedRegions);
-    for (const region of job.ownershipRegions) {
-        if (region.globs.some((glob) => changed.some((file) => matchesGlob(file, glob))))
-            regions.add(region.id);
-        for (const selector of region.selectors) {
-            if (changed.includes(selector))
-                regions.add(region.id);
-        }
-    }
-    return Array.from(regions).sort();
-}
-export function classifySwarmMergeReadiness(result) {
-    if (result.mergeReadiness)
-        return result.mergeReadiness;
-    if (result.status === 'blocked')
-        return 'blocked';
-    if (result.status === 'failed' || result.exitCode !== undefined && result.exitCode !== 0)
-        return 'rejected';
-    const changedPaths = result.changedPaths ?? [];
-    if (changedPaths.length === 0)
-        return 'discovery-only';
-    const ownershipViolations = result.ownershipViolations ?? [];
-    if (ownershipViolations.length)
-        return 'rejected';
-    const verification = result.verification ?? [];
-    const failedRequired = verification.some((entry) => entry.required !== false && entry.status !== 0);
-    if (failedRequired)
-        return 'patch-candidate';
-    return verification.length > 0 || result.status === 'verified' ? 'verified-patch' : 'patch-candidate';
-}
-export function classifySwarmMergeDisposition(result, input = {}) {
-    if (result.mergeDisposition)
-        return result.mergeDisposition;
-    if (input.staleAgainstHead)
-        return 'stale-against-head';
-    const readiness = classifySwarmMergeReadiness(result);
-    if (readiness === 'discovery-only')
-        return 'discovery-only';
-    if (readiness === 'blocked')
-        return 'blocked';
-    if (readiness === 'rejected')
-        return 'rejected';
-    if (readiness === 'verified-patch')
-        return 'auto-mergeable';
-    return 'needs-port';
-}
-export function createSwarmMergeBundle(input) {
-    const generatedAt = input.generatedAt ?? Date.now();
-    const result = isSwarmJobResult(input.result) ? cloneJsonValue(input.result) : normalizeResult(input.result);
-    const job = input.job;
-    const inputMetadata = toJsonObject(input.metadata);
-    const semanticImport = normalizeSemanticImportSummary(input.semanticImport ?? result.semanticImport ?? inputMetadata?.semanticImport);
-    const changedPaths = uniqueStrings(result.changedPaths);
-    const changedRegions = uniqueStrings([
-        ...result.changedRegions,
-        ...(job ? resolveSwarmChangedRegions(job, changedPaths) : [])
-    ]);
-    const evidencePaths = uniqueStrings([...(result.evidencePaths ?? []), ...(input.evidencePaths ?? [])]);
-    const queueItemIds = uniqueStrings([...(result.queueItemIds ?? []), ...(input.queueItemIds ?? []), ...(job ? [job.taskId] : [])]);
-    const disposition = input.disposition ?? classifySwarmMergeDisposition(result, { staleAgainstHead: input.staleAgainstHead });
-    const commandsPassed = result.verification.filter((entry) => entry.status === 0 || entry.required === false && entry.status === undefined);
-    const commandsFailed = result.verification.filter((entry) => entry.status !== undefined && entry.status !== 0 && entry.required !== false);
-    const ownedFilesTouched = job ? changedPaths.filter((file) => job.allowedWrites.some((glob) => matchesGlob(file, glob))) : changedPaths;
-    const reasons = mergeBundleReasons(result, disposition, input.staleAgainstHead ?? false);
-    return {
-        kind: FRONTIER_SWARM_MERGE_BUNDLE_KIND,
-        version: FRONTIER_SWARM_MERGE_BUNDLE_VERSION,
-        id: input.id ?? 'swarm-merge-bundle:' + stableHash([input.runId, input.planId, result.jobId, changedPaths, changedRegions, disposition, generatedAt]),
-        ...(input.runId ? { runId: input.runId } : {}),
-        ...(input.planId ? { planId: input.planId } : {}),
-        jobId: result.jobId,
-        ...(job ? { taskId: job.taskId, lane: job.lane, title: job.title } : {}),
-        generatedAt,
-        status: result.status,
-        mergeReadiness: result.mergeReadiness,
-        disposition,
-        riskLevel: input.riskLevel ?? result.riskLevel ?? inferMergeRisk(result, disposition),
-        autoMergeable: disposition === 'auto-mergeable' && reasons.length === 0,
-        changedPaths,
-        changedRegions,
-        ownedFilesTouched,
-        allowedWrites: job ? [...job.allowedWrites] : [],
-        ownershipViolations: [...result.ownershipViolations],
-        ...(input.patchPath ?? result.patchPath ? { patchPath: input.patchPath ?? result.patchPath } : {}),
-        ...(input.patchHash ? { patchHash: input.patchHash } : {}),
-        evidencePaths,
-        commandsPassed,
-        commandsFailed,
-        queueItemIds,
-        ...(input.branchName ? { branchName: input.branchName } : {}),
-        ...(input.commit ? { commit: input.commit } : {}),
-        staleAgainstHead: input.staleAgainstHead ?? false,
-        reasons,
-        ...(semanticImport ? { semanticImport } : {}),
-        ...(inputMetadata ? { metadata: inputMetadata } : {})
-    };
-}
-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],
-                ...(bundle.semanticImport ? { semanticImport: cloneJsonValue(bundle.semanticImport) } : {}),
-                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] : [],
-                ...(result.semanticImport ? { semanticImport: cloneJsonValue(result.semanticImport) } : {}),
-                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,
-                ...(overlay.semanticImport ? { semanticImport: overlay.semanticImport } : {}),
-                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'] : [])]),
-            ...(bundle.semanticImport ? { semanticImport: cloneJsonValue(bundle.semanticImport) } : {}),
-            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 createSwarmCoordinatorDashboard(input = {}) {
-    const generatedAt = input.generatedAt ?? Date.now();
-    const runId = input.run?.id ?? input.mergeIndex?.runId ?? input.queueOverlay?.runId;
-    const planId = input.plan?.id ?? input.mergeIndex?.planId;
-    const bundles = input.bundles ?? input.run?.results.map((result) => createSwarmMergeBundle({
-        runId,
-        planId,
-        job: input.plan?.jobs.find((job) => job.id === result.jobId),
-        result,
-        generatedAt
-    })) ?? [];
-    const mergeIndex = input.mergeIndex ?? (bundles.length ? createSwarmMergeIndex({ runId, planId, bundles, generatedAt }) : undefined);
-    const queueOverlay = input.queueOverlay ?? (bundles.length ? createSwarmQueueOverlay({ runId, bundles, generatedAt }) : undefined);
-    const evidenceIndex = input.evidenceIndex ?? (input.run ? createSwarmEvidenceIndex({ run: input.run, generatedAt }) : undefined);
-    const admission = input.admission;
-    const jobsById = new Map((input.plan?.jobs ?? []).map((job) => [job.id, job]));
-    const resultsById = new Map((input.run?.results ?? []).map((result) => [result.jobId, result]));
-    const entriesById = new Map((mergeIndex?.entries ?? []).map((entry) => [entry.jobId, entry]));
-    const bundlesById = new Map(bundles.map((bundle) => [bundle.jobId, bundle]));
-    const processes = normalizeCoordinatorProcesses(input.processes ?? []);
-    const processesByJob = groupObjects(processes.filter((process) => process.jobId), (process) => process.jobId);
-    const duplicateGroups = createCoordinatorDuplicateGroups(mergeIndex?.entries ?? []);
-    const duplicateByJob = new Map();
-    for (const group of duplicateGroups) {
-        for (const jobId of group.jobIds)
-            duplicateByJob.set(jobId, group);
-    }
-    const admissionDeferred = new Map((admission?.deferred ?? []).map((entry) => [entry.jobId, entry.reasons]));
-    const admitted = new Set(admission?.admitted ?? []);
-    const jobIds = uniqueStrings([
-        ...(input.plan?.jobs ?? []).map((job) => job.id),
-        ...(input.run?.results ?? []).map((result) => result.jobId),
-        ...(mergeIndex?.entries ?? []).map((entry) => entry.jobId),
-        ...processes.map((process) => process.jobId)
-    ]).sort();
-    const jobs = jobIds.map((jobId) => {
-        const planJob = jobsById.get(jobId);
-        const result = resultsById.get(jobId);
-        const entry = entriesById.get(jobId);
-        const bundle = bundlesById.get(jobId);
-        const processList = processesByJob[jobId] ?? [];
-        const duplicateGroup = duplicateByJob.get(jobId);
-        const admissionReasons = admissionDeferred.get(jobId) ?? [];
-        const admissionStatus = admitted.has(jobId)
-            ? 'admitted'
-            : admissionReasons.length
-                ? 'deferred'
-                : entry?.autoMergeable
-                    ? 'not-admissible'
-                    : 'unknown';
-        const score = scoreCoordinatorMergeJob(entry, bundle, evidenceIndex?.byJobId[jobId]?.length ?? 0, duplicateGroup, admissionStatus, admissionReasons);
-        const evidencePaths = uniqueStrings([
-            ...(entry?.evidencePaths ?? []),
-            ...(result?.evidencePaths ?? []),
-            ...(bundle?.evidencePaths ?? [])
-        ]);
-        const changedRegions = uniqueStrings([...(entry?.changedRegions ?? []), ...(result?.changedRegions ?? []), ...(bundle?.changedRegions ?? [])]);
-        return {
-            jobId,
-            ...(entry?.taskId ?? result?.queueItemIds[0] ?? planJob?.taskId ? { taskId: entry?.taskId ?? result?.queueItemIds[0] ?? planJob?.taskId } : {}),
-            ...(entry?.lane ?? planJob?.lane ? { lane: entry?.lane ?? planJob?.lane } : {}),
-            ...(entry?.title ?? planJob?.title ? { title: entry?.title ?? planJob?.title } : {}),
-            status: entry?.status ?? result?.status ?? planJob?.status ?? 'planned',
-            liveness: coordinatorJobLiveness(result, entry, processList),
-            mergeReadiness: entry?.mergeReadiness ?? result?.mergeReadiness ?? 'blocked',
-            disposition: entry?.disposition ?? result?.mergeDisposition ?? 'blocked',
-            riskLevel: entry?.riskLevel ?? result?.riskLevel ?? 'unknown',
-            mergeScore: score.score,
-            mergeScoreReasons: score.reasons,
-            admissionStatus,
-            admissionReasons,
-            staleAgainstHead: Boolean(entry?.staleAgainstHead || bundle?.staleAgainstHead),
-            ...(duplicateGroup ? { duplicateGroupId: duplicateGroup.id, ...(duplicateGroup.jobIds[0] !== jobId ? { duplicateOf: duplicateGroup.jobIds[0] } : {}) } : {}),
-            changedPaths: uniqueStrings([...(entry?.changedPaths ?? []), ...(result?.changedPaths ?? []), ...(bundle?.changedPaths ?? [])]),
-            changedRegions,
-            semanticRegions: changedRegions,
-            ownershipViolations: uniqueStrings([...(entry?.ownershipViolations ?? []), ...(result?.ownershipViolations ?? []), ...(bundle?.ownershipViolations ?? [])]),
-            ...(entry?.patchPath ?? result?.patchPath ?? bundle?.patchPath ? { patchPath: entry?.patchPath ?? result?.patchPath ?? bundle?.patchPath } : {}),
-            evidencePaths,
-            ...(primaryEvidencePath(evidencePaths) ? { primaryEvidencePath: primaryEvidencePath(evidencePaths) } : {}),
-            sourceCitations: createCoordinatorSourceCitations(entry, evidenceIndex),
-            tests: {
-                passed: bundle?.commandsPassed.length ?? result?.verification.filter((test) => test.status === 0).length ?? 0,
-                failed: bundle?.commandsFailed.length ?? result?.verification.filter((test) => test.status !== undefined && test.status !== 0).length ?? 0,
-                requiredFailed: bundle?.commandsFailed.length ?? result?.verification.filter((test) => test.required !== false && test.status !== undefined && test.status !== 0).length ?? 0
-            },
-            ...(entry?.semanticImport ?? result?.semanticImport ?? bundle?.semanticImport ? {
-                semanticImport: cloneJsonValue(entry?.semanticImport ?? result?.semanticImport ?? bundle?.semanticImport)
-            } : {}),
-            generatedAt
-        };
-    }).sort((left, right) => right.mergeScore - left.mergeScore || left.jobId.localeCompare(right.jobId));
-    const byLane = groupIds(jobs, (job) => job.lane ?? 'unassigned');
-    const byDisposition = groupIds(jobs, (job) => job.disposition);
-    const byLiveness = groupIds(jobs, (job) => job.liveness);
-    return {
-        kind: FRONTIER_SWARM_COORDINATOR_DASHBOARD_KIND,
-        version: FRONTIER_SWARM_COORDINATOR_DASHBOARD_VERSION,
-        id: input.id ?? 'swarm-coordinator-dashboard:' + stableHash([runId, planId, jobs, duplicateGroups, generatedAt]),
-        ...(runId ? { runId } : {}),
-        ...(planId ? { planId } : {}),
-        generatedAt,
-        jobs,
-        duplicateGroups,
-        processes,
-        byLane,
-        byDisposition,
-        byLiveness,
-        ...(mergeIndex ? { mergeIndex } : {}),
-        ...(queueOverlay ? { queueOverlay } : {}),
-        ...(evidenceIndex ? { evidenceIndex } : {}),
-        ...(admission ? { admission } : {}),
-        summary: {
-            jobCount: jobs.length,
-            readyToApplyCount: jobs.filter((job) => job.disposition === 'auto-mergeable' && job.admissionStatus !== 'deferred').length,
-            needsHumanPortCount: jobs.filter((job) => job.disposition === 'needs-port').length,
-            failedEvidenceCount: jobs.filter((job) => job.disposition === 'rejected' || job.disposition === 'blocked' || job.tests.requiredFailed > 0).length,
-            staleAgainstHeadCount: jobs.filter((job) => job.staleAgainstHead).length,
-            duplicateGroupCount: duplicateGroups.length,
-            semanticSidecarCount: jobs.filter((job) => job.semanticImport && job.semanticImport.total > 0).length,
-            semanticRegionCount: jobs.reduce((total, job) => total + job.semanticRegions.length, 0),
-            averageMergeScore: averageScore(jobs.map((job) => job.mergeScore))
-        },
-        ...(toJsonObject(input.metadata) ? { metadata: toJsonObject(input.metadata) } : {})
-    };
-}
-export function querySwarmCoordinatorDashboard(dashboard, query = {}) {
-    const jobs = dashboard.jobs.filter((job) => ((query.jobId === undefined || job.jobId === query.jobId)
-        && (query.lane === undefined || job.lane === query.lane)
-        && (query.disposition === undefined || job.disposition === query.disposition)
-        && (query.liveness === undefined || job.liveness === query.liveness)
-        && (query.admissionStatus === undefined || job.admissionStatus === query.admissionStatus)
-        && (query.pathIncludes === undefined || job.changedPaths.concat(job.evidencePaths).some((entry) => entry.includes(query.pathIncludes)))
-        && (query.region === undefined || job.changedRegions.includes(query.region) || job.semanticRegions.includes(query.region))
-        && (query.hasSemanticImport === undefined || Boolean(job.semanticImport && job.semanticImport.total > 0) === query.hasSemanticImport)
-        && (query.hasSemanticRegions === undefined || (job.semanticRegions.length > 0) === query.hasSemanticRegions)
-        && (query.staleAgainstHead === undefined || job.staleAgainstHead === query.staleAgainstHead)
-        && (query.duplicateOnly !== true || Boolean(job.duplicateGroupId))
-        && (query.minMergeScore === undefined || job.mergeScore >= query.minMergeScore)
-        && (query.maxMergeScore === undefined || job.mergeScore <= query.maxMergeScore)));
-    return {
-        jobs,
-        summary: {
-            jobCount: jobs.length,
-            averageMergeScore: averageScore(jobs.map((job) => job.mergeScore))
-        }
-    };
-}
-export function createSwarmAdaptiveLoadPlan(input = {}) {
-    const generatedAt = input.generatedAt ?? Date.now();
-    const mode = input.mode ?? 'balanced';
-    const maxLimits = createAdaptiveMaxLimits(input);
-    const minLimits = createAdaptiveMinLimits(input.minLimits, maxLimits);
-    const currentLimits = clampAdaptiveLimits(createAdaptiveCurrentLimits(input.currentLimits, maxLimits), minLimits, maxLimits);
-    const effectiveLimits = mode === 'off'
-        ? cloneJsonValue(maxLimits)
-        : cloneJsonValue(currentLimits);
-    const schedule = input.schedule ?? (input.plan ? createSwarmSchedule({ plan: input.plan, run: input.run }) : undefined);
-    const observations = normalizeAdaptiveObservations([
-        ...deriveAdaptiveScheduleObservations(schedule, generatedAt),
-        ...deriveAdaptiveRunObservations(input.run, generatedAt),
-        ...deriveAdaptiveMergeIndexObservations(input.mergeIndex, generatedAt),
-        ...deriveAdaptiveDashboardObservations(input.dashboard, generatedAt),
-        ...deriveAdaptiveAdmissionObservations(input.admission, generatedAt),
-        ...(input.observations ?? [])
-    ], generatedAt);
-    const decisions = [];
-    const bottlenecks = observations.filter((observation) => adaptiveObservationIsBottleneck(observation));
-    if (mode === 'observe') {
-        for (const observation of bottlenecks) {
-            decisions.push(createAdaptiveDecision({
-                action: 'observe',
-                target: adaptiveDecisionTargetForObservation(observation),
-                key: adaptiveDecisionKeyForObservation(observation),
-                reason: observation.reasons[0] ?? observation.kind,
-                observationIds: [observation.id]
-            }));
-        }
-    }
-    else if (mode !== 'off') {
-        for (const observation of bottlenecks) {
-            applyAdaptiveObservation(effectiveLimits, minLimits, maxLimits, mode, observation, decisions);
-        }
-        const healthy = observations.filter((observation) => observation.kind === 'healthy-throughput');
-        if (bottlenecks.length === 0 && healthy.length > 0) {
-            for (const observation of healthy) {
-                applyAdaptiveRecovery(effectiveLimits, maxLimits, observation, decisions);
-            }
-        }
-    }
-    const summary = {
-        observationCount: observations.length,
-        bottleneckCount: bottlenecks.length,
-        decisionCount: decisions.length,
-        reducedCount: decisions.filter((decision) => decision.action === 'decrease').length,
-        increasedCount: decisions.filter((decision) => decision.action === 'increase').length,
-        ...(effectiveLimits.maxReadyJobs !== undefined ? { effectiveMaxReadyJobs: effectiveLimits.maxReadyJobs } : {}),
-        ...(maxLimits.maxReadyJobs !== undefined ? { maxReadyJobs: maxLimits.maxReadyJobs } : {})
-    };
-    return {
-        kind: FRONTIER_SWARM_ADAPTIVE_LOAD_PLAN_KIND,
-        version: FRONTIER_SWARM_ADAPTIVE_LOAD_PLAN_VERSION,
-        id: input.id ?? 'swarm-adaptive-load-plan:' + stableHash([input.plan?.id, input.run?.id, mode, observations, decisions, generatedAt]),
-        ...(input.plan?.id ? { planId: input.plan.id } : {}),
-        ...(input.run?.id ? { runId: input.run.id } : {}),
-        mode,
-        generatedAt,
-        maxLimits,
-        currentLimits,
-        minLimits,
-        effectiveLimits,
-        observations,
-        decisions,
-        summary,
-        ...(toJsonObject(input.metadata) ? { metadata: toJsonObject(input.metadata) } : {})
-    };
-}
-export function createSwarmScheduleInputFromAdaptiveLoadPlan(plan, adaptive, input = {}) {
-    return {
-        plan,
-        ...(input.run ? { run: input.run } : {}),
-        ...(input.now !== undefined ? { now: input.now } : {}),
-        ...(adaptive.effectiveLimits.maxReadyJobs !== undefined ? { maxReadyJobs: adaptive.effectiveLimits.maxReadyJobs } : {}),
-        maxLaneConcurrency: adaptive.effectiveLimits.maxLaneConcurrency,
-        maxConcurrencyKeyConcurrency: adaptive.effectiveLimits.maxConcurrencyKeyConcurrency,
-        maxComputeConcurrency: adaptive.effectiveLimits.maxComputeConcurrency,
-        resourceQuotas: adaptive.effectiveLimits.resourceQuotas
-    };
-}
-export function resolveSwarmCompute(manifestInput, taskInput) {
-    const compiled = compileSwarm(manifestInput);
-    const task = isSwarmTask(taskInput) ? taskInput : normalizeTask(taskInput);
-    return resolveTaskCompute(compiled, task);
-}
-export function createSwarmProof(input, options = {}) {
-    const manifestId = 'manifestId' in input ? input.manifestId : input.id;
-    const summary = input.summary;
-    const generatedAt = options.generatedAt ?? Date.now();
-    return {
-        kind: FRONTIER_SWARM_PROOF_KIND,
-        version: FRONTIER_SWARM_PROOF_VERSION,
-        id: 'swarm-proof:' + stableHash([manifestId, summary, generatedAt]),
-        manifestId,
-        generatedAt,
-        hash: stableHash([input, options.validation, options.metadata]),
-        summary,
-        ...(options.validation ? { validation: options.validation } : {}),
-        ...(toJsonObject(options.metadata) ? { metadata: toJsonObject(options.metadata) } : {})
-    };
-}
-export function createSwarmSchedule(input) {
-    const plan = 'plan' in input ? input.plan : input;
-    const run = 'plan' in input ? input.run : undefined;
-    const createdAt = 'plan' in input ? input.now ?? Date.now() : Date.now();
-    const limits = mergeScheduleLimits(plan.limits, 'plan' in input ? input : {});
-    const resultsByJob = new Map((run?.results ?? []).map((result) => [result.jobId, result]));
-    const completed = new Set();
-    const failed = new Set();
-    for (const result of resultsByJob.values()) {
-        if (result.status === 'completed' || result.status === 'verified')
-            completed.add(result.jobId);
-        if (result.status === 'failed' || result.exitCode !== undefined && result.exitCode !== 0)
-            failed.add(result.jobId);
-    }
-    const runningJobs = (run?.jobs ?? plan.jobs)
-        .filter((job) => job.status === 'running')
-        .map((job) => ({
-        jobId: job.id,
-        lane: job.lane,
-        compute: job.compute.id,
-        concurrencyKey: job.concurrencyKey,
-        capabilities: [...job.capabilities],
-        ...(job.resourceRequirements ? { resourceRequirements: cloneJsonValue(job.resourceRequirements) } : {})
-    }));
-    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));
-    for (const job of sortedJobs) {
-        if (completed.has(job.id) || failed.has(job.id) || runningJobs.some((running) => running.jobId === job.id))
-            continue;
-        const dependencyIds = plan.graph.dependenciesByJobId[job.id] ?? [];
-        const waitingFor = dependencyIds.filter((dep) => !completed.has(dep));
-        const reasons = [];
-        if (waitingFor.length)
-            reasons.push('waiting-for-dependencies');
-        const laneMax = limits.maxLaneConcurrency[job.lane] ?? Number.POSITIVE_INFINITY;
-        const keyMax = limits.maxConcurrencyKeyConcurrency[job.concurrencyKey] ?? Number.POSITIVE_INFINITY;
-        const computeMax = limits.maxComputeConcurrency[job.compute.id] ?? job.compute.maxConcurrency ?? Number.POSITIVE_INFINITY;
-        if ((runningByLane[job.lane] ?? 0) >= laneMax)
-            reasons.push('lane-capacity');
-        if ((runningByKey[job.concurrencyKey] ?? 0) >= keyMax)
-            reasons.push('concurrency-key-capacity');
-        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;
-        }
-        if (limits.maxReadyJobs !== undefined && ready.length >= limits.maxReadyJobs) {
-            blocked.push({ ...scheduled, reasons: ['ready-capacity'], waitingFor: [] });
-            continue;
-        }
-        ready.push(scheduled);
-        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,
-        version: FRONTIER_SWARM_SCHEDULE_VERSION,
-        id: 'swarm-schedule:' + stableHash([plan.id, run?.id, ready.map((job) => job.jobId), blocked.map((job) => [job.jobId, job.reasons]), createdAt]),
-        planId: plan.id,
-        ...(run ? { runId: run.id } : {}),
-        createdAt,
-        ready,
-        blocked,
-        running: runningJobs,
-        completed: Array.from(completed).sort(),
-        failed: Array.from(failed).sort(),
-        summary: {
-            jobCount: plan.jobs.length,
-            readyCount: ready.length,
-            blockedCount: blocked.length,
-            runningCount: runningJobs.length,
-            completedCount: completed.size,
-            failedCount: failed.size
-        }
-    };
-}
-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));
-    const activeJobIds = new Set((input.existingLeases ?? []).filter((lease) => lease.status === 'active' && lease.expiresAt > now).map((lease) => lease.jobId));
-    const existingMaxFence = Math.max(0, ...(input.existingLeases ?? []).map((lease) => lease.fencingToken));
-    const count = Math.max(0, Math.floor(input.count ?? input.schedule.ready.length));
-    return input.schedule.ready
-        .filter((job) => !activeJobIds.has(job.jobId))
-        .slice(0, count)
-        .map((job, index) => ({
-        kind: FRONTIER_SWARM_LEASE_KIND,
-        version: FRONTIER_SWARM_LEASE_VERSION,
-        id: 'swarm-lease:' + stableHash([input.schedule.id, job.jobId, input.workerId, now, existingMaxFence + index + 1]),
-        jobId: job.jobId,
-        workerId: input.workerId,
-        token: stableHash([job.jobId, input.workerId, now, existingMaxFence + index + 1]),
-        leasedAt: now,
-        expiresAt: now + leaseMs,
-        fencingToken: existingMaxFence + index + 1,
-        status: 'active'
-    }));
-}
-export function renewSwarmLease(input) {
-    const now = input.now ?? Date.now();
-    const leaseMs = Math.max(1, Math.floor(input.leaseMs ?? Math.max(1, input.lease.expiresAt - input.lease.leasedAt)));
-    return {
-        ...cloneJsonValue(input.lease),
-        leasedAt: now,
-        expiresAt: now + leaseMs,
-        status: input.status ?? 'active'
-    };
-}
-export function createSwarmQueueSnapshot(input) {
-    const generatedAt = input.generatedAt ?? Date.now();
-    const leases = [...(input.leases ?? [])].map((lease) => cloneJsonValue(lease));
-    const jobs = (input.jobs ? input.jobs.map(normalizeQueueJob) : queueJobsFromPlan(input.plan, input.run, leases)).sort((left, right) => (left.priority - right.priority
-        || left.jobId.localeCompare(right.jobId)));
-    const byStatus = groupIds(jobs, (job) => job.status);
-    const byLane = groupIds(jobs, (job) => job.lane ?? 'unassigned');
-    return {
-        kind: FRONTIER_SWARM_QUEUE_SNAPSHOT_KIND,
-        version: FRONTIER_SWARM_QUEUE_SNAPSHOT_VERSION,
-        id: input.id ?? 'swarm-queue-snapshot:' + stableHash([input.plan.id, input.run?.id, jobs, leases, generatedAt]),
-        planId: input.plan.id,
-        runId: input.run?.id ?? input.plan.runId,
-        generatedAt,
-        jobs,
-        byStatus,
-        byLane,
-        leases,
-        ...(toJsonObject(input.metadata) ? { metadata: toJsonObject(input.metadata) } : {}),
-        summary: {
-            jobCount: jobs.length,
-            leaseCount: 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 createSwarmRunCheckpoint(input) {
-    const run = 'kind' in input ? input : input.run;
-    const sequence = 'kind' in input ? run.events.length + run.results.length : input.sequence ?? run.events.length + run.results.length;
-    const savedAt = 'kind' in input ? Date.now() : input.savedAt ?? Date.now();
-    return {
-        kind: FRONTIER_SWARM_RUN_CHECKPOINT_KIND,
-        version: FRONTIER_SWARM_RUN_CHECKPOINT_VERSION,
-        id: 'swarm-run-checkpoint:' + stableHash([run.id, sequence, savedAt, run.summary]),
-        runId: run.id,
-        planId: run.planId,
-        sequence,
-        savedAt,
-        status: run.status,
-        eventCount: run.events.length,
-        resultCount: run.results.length,
-        hash: stableHash(run),
-        ...(!('kind' in input) && toJsonObject(input.metadata) ? { metadata: toJsonObject(input.metadata) } : {})
-    };
-}
-export function checkSwarmBudget(job, usageInput) {
-    const usage = normalizeUsage(usageInput);
-    const budget = job.budget;
-    const violations = [];
-    if (budget?.maxCostUsd !== undefined && usage.costUsd > budget.maxCostUsd)
-        violations.push('max-cost-usd');
-    if (budget?.maxInputTokens !== undefined && usage.inputTokens > budget.maxInputTokens)
-        violations.push('max-input-tokens');
-    if (budget?.maxOutputTokens !== undefined && usage.outputTokens > budget.maxOutputTokens)
-        violations.push('max-output-tokens');
-    if (budget?.maxDurationMs !== undefined && usage.durationMs > budget.maxDurationMs)
-        violations.push('max-duration-ms');
-    if (budget && usage.attempts > budget.maxRetries + 1)
-        violations.push('max-retries');
-    return { ok: violations.length === 0, jobId: job.id, usage, ...(budget ? { budget } : {}), violations };
-}
-export function createSwarmArtifactIndex(input) {
-    const run = 'kind' in input ? input : input.run;
-    const generatedAt = 'kind' in input ? Date.now() : input.generatedAt ?? Date.now();
-    const explicit = 'kind' in input ? [] : input.artifacts ?? [];
-    const artifacts = [
-        ...(run?.results ?? []).flatMap((result) => result.evidencePaths.map((evidencePath) => normalizeArtifact({ jobId: result.jobId, path: evidencePath, kind: 'evidence' }))),
-        ...explicit.map(normalizeArtifact)
-    ].sort((left, right) => left.jobId.localeCompare(right.jobId) || left.path.localeCompare(right.path));
-    const byJobId = groupArtifacts(artifacts, (artifact) => artifact.jobId);
-    const byKind = groupArtifacts(artifacts, (artifact) => artifact.kind);
-    return {
-        kind: FRONTIER_SWARM_ARTIFACT_INDEX_KIND,
-        version: FRONTIER_SWARM_ARTIFACT_INDEX_VERSION,
-        id: 'swarm-artifact-index:' + stableHash([artifacts, generatedAt]),
-        generatedAt,
-        artifacts,
-        byJobId,
-        byKind,
-        summary: {
-            artifactCount: artifacts.length,
-            jobCount: Object.keys(byJobId).length,
-            kindCount: Object.keys(byKind).length,
-            totalBytes: artifacts.reduce((total, artifact) => total + (artifact.bytes ?? 0), 0)
-        }
-    };
-}
-export function createSwarmReviewPlan(input) {
-    const generatedAt = input.generatedAt ?? Date.now();
-    const resultsByJob = new Map((input.run?.results ?? []).map((result) => [result.jobId, result]));
-    const budgetsByJob = new Map((input.budgetDecisions ?? []).map((decision) => [decision.jobId, decision]));
-    const assignments = [];
-    for (const job of input.plan.jobs) {
-        const result = resultsByJob.get(job.id);
-        const budget = budgetsByJob.get(job.id);
-        const reason = reviewReason(job, result, budget, input.sampleSalt ?? input.plan.id);
-        if (!reason)
-            continue;
-        const pool = job.review.reviewerPool.length ? job.review.reviewerPool : [...(input.reviewers ?? [])];
-        assignments.push({
-            jobId: job.id,
-            taskId: job.taskId,
-            reviewers: selectReviewers(pool, job.review.requiredReviewers, job.id),
-            required: job.review.alwaysReview || reason === 'violations' || reason === 'failed' || reason === 'budget',
-            reason
-        });
-    }
-    return {
-        kind: FRONTIER_SWARM_REVIEW_PLAN_KIND,
-        version: FRONTIER_SWARM_REVIEW_PLAN_VERSION,
-        id: 'swarm-review-plan:' + stableHash([input.plan.id, assignments, generatedAt]),
-        planId: input.plan.id,
-        generatedAt,
-        assignments,
-        summary: {
-            assignmentCount: assignments.length,
-            requiredCount: assignments.filter((assignment) => assignment.required).length,
-            sampledCount: assignments.filter((assignment) => assignment.reason === 'sampled').length
-        }
-    };
-}
-export function createSwarmMergePlan(input) {
-    const generatedAt = input.generatedAt ?? Date.now();
-    const resultsByJob = new Map(input.run.results.map((result) => [result.jobId, result]));
-    const reviewRequired = new Set((input.reviewPlan?.assignments ?? []).filter((assignment) => assignment.required).map((assignment) => assignment.jobId));
-    const conflicts = conflictMap(input.run.results);
-    const ready = [];
-    const blocked = [];
-    for (const job of input.plan.jobs) {
-        const result = resultsByJob.get(job.id);
-        const reasons = [];
-        if (!result || result.status !== 'completed' && result.status !== 'verified')
-            reasons.push('not-completed');
-        if (result?.ownershipViolations.length)
-            reasons.push('ownership-violations');
-        if (reviewRequired.has(job.id))
-            reasons.push('review-required');
-        const conflictingJobIds = Array.from(conflicts.get(job.id) ?? []).sort();
-        if (conflictingJobIds.length)
-            reasons.push('conflicting-changes');
-        if (reasons.length)
-            blocked.push({ jobId: job.id, reasons: uniqueStrings(reasons), conflictingJobIds });
-        else
-            ready.push(job.id);
-    }
-    const groups = groupMergeReadyJobs(ready, input.run.results);
-    return {
-        kind: FRONTIER_SWARM_MERGE_PLAN_KIND,
-        version: FRONTIER_SWARM_MERGE_PLAN_VERSION,
-        id: 'swarm-merge-plan:' + stableHash([input.plan.id, ready, blocked, generatedAt]),
-        planId: input.plan.id,
-        generatedAt,
-        ready,
-        blocked,
-        groups,
-        summary: { readyCount: ready.length, blockedCount: blocked.length, groupCount: groups.length }
-    };
-}
-export function decomposeSwarmFeature(input) {
-    const filesByLane = new Map();
-    const lanes = input.lanes.length ? [...input.lanes] : ['implementation'];
-    for (const lane of lanes)
-        filesByLane.set(lane, []);
-    for (const file of input.files ?? []) {
-        const selected = lanes.find((lane) => file.toLowerCase().includes(lane.toLowerCase())) ?? lanes[filesByLane.size ? stableHash(file).charCodeAt(10) % lanes.length : 0];
-        filesByLane.get(selected)?.push(file);
-    }
-    return lanes.map((lane, index) => ({
-        id: `${input.featureId}-${slug(lane)}`,
-        lane,
-        title: `${titleFromId(lane)} for ${input.featureId}`,
-        objective: input.objective,
-        priority: 100 + index,
-        targetRefs: filesByLane.get(lane) ?? [],
-        verification: input.checks ?? [],
-        review: input.reviewers?.length ? { requiredReviewers: 1, reviewerPool: input.reviewers } : undefined,
-        metadata: toJsonObject(input.metadata)
-    }));
-}
-export function encodeSwarmJsonl(records) {
-    return records.map((record) => JSON.stringify(record)).join('\n') + (records.length ? '\n' : '');
-}
-export function decodeSwarmJsonl(jsonl) {
-    return jsonl.split(/\r?\n/).filter((line) => line.trim().length > 0).map((line) => JSON.parse(line));
-}
-export function matchesGlob(file, glob) {
-    const escaped = glob
-        .replace(/[.+^${}()|[\]\\]/g, '\\$&')
-        .replace(/\*\*/g, '\u0000')
-        .replace(/\*/g, '[^/]*')
-        .replace(/\u0000/g, '.*');
-    return new RegExp('^' + escaped + '$').test(file);
-}
-function createSwarmJobGraph(jobs) {
-    const nodes = jobs.map((job) => job.id).sort();
-    const nodeSet = new Set(nodes);
-    const taskToJob = new Map(jobs.map((job) => [job.taskId, job.id]));
-    const edges = [];
-    const issues = [];
-    for (const job of jobs) {
-        for (const rawDep of job.dependsOn) {
-            const dep = nodeSet.has(rawDep) ? rawDep : taskToJob.get(rawDep);
-            if (!dep) {
-                addIssue(issues, 'missing-job-dependency', 'error', `jobs.${job.id}.dependsOn`, `Job dependency is not in this plan: ${rawDep}`);
-                continue;
-            }
-            if (dep === job.id) {
-                addIssue(issues, 'self-job-dependency', 'error', `jobs.${job.id}.dependsOn`, `Job cannot depend on itself: ${job.id}`);
-                continue;
-            }
-            edges.push({ from: dep, to: job.id, type: 'depends-on' });
-        }
-    }
-    const dependenciesByJobId = Object.fromEntries(nodes.map((node) => [node, []]));
-    const dependentsByJobId = Object.fromEntries(nodes.map((node) => [node, []]));
-    for (const edge of edges) {
-        dependenciesByJobId[edge.to]?.push(edge.from);
-        dependentsByJobId[edge.from]?.push(edge.to);
-    }
-    for (const key of nodes) {
-        dependenciesByJobId[key] = uniqueStrings(dependenciesByJobId[key] ?? []).sort();
-        dependentsByJobId[key] = uniqueStrings(dependentsByJobId[key] ?? []).sort();
-        if (hasJobDependencyCycle(key, dependenciesByJobId)) {
-            addIssue(issues, 'job-dependency-cycle', 'error', `jobs.${key}.dependsOn`, `Job dependency graph contains a cycle at ${key}`);
-        }
-    }
-    return {
-        nodes,
-        edges: edges.sort((left, right) => left.from.localeCompare(right.from) || left.to.localeCompare(right.to)),
-        dependentsByJobId,
-        dependenciesByJobId,
-        roots: nodes.filter((node) => dependenciesByJobId[node]?.length === 0),
-        leaves: nodes.filter((node) => dependentsByJobId[node]?.length === 0),
-        issues
-    };
-}
-function normalizeScheduleLimits(manifest, options) {
-    const maxLaneConcurrency = {};
-    for (const lane of manifest.lanes) {
-        const browserMax = lane.resourceRequirements?.browser?.maxConcurrency;
-        const value = options.maxLaneConcurrency?.[lane.id] ?? lane.maxConcurrency ?? browserMax ?? manifest.policy.defaultConcurrency;
-        maxLaneConcurrency[lane.id] = Math.max(1, Math.floor(value));
-    }
-    return {
-        ...(positiveNumber(options.maxReadyJobs) ? { maxReadyJobs: Math.floor(options.maxReadyJobs) } : {}),
-        maxLaneConcurrency: { ...maxLaneConcurrency, ...(options.maxLaneConcurrency ?? {}) },
-        maxConcurrencyKeyConcurrency: { ...(options.maxConcurrencyKeyConcurrency ?? {}) },
-        maxComputeConcurrency: { ...(options.maxComputeConcurrency ?? {}) },
-        resourceQuotas: normalizeResourceQuotas(options.resourceQuotas ?? {})
-    };
-}
-function mergeScheduleLimits(base, override) {
-    return {
-        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 ?? {}) },
-        resourceQuotas: { ...base.resourceQuotas, ...normalizeResourceQuotas(override.resourceQuotas ?? {}) }
-    };
-}
-function scheduleJob(job, dependsOn = job.dependsOn) {
-    return {
-        jobId: job.id,
-        taskId: job.taskId,
-        lane: job.lane,
-        compute: job.compute.id,
-        concurrencyKey: job.concurrencyKey,
-        priority: job.priority,
-        dependsOn: [...dependsOn],
-        capabilities: [...job.capabilities],
-        ...(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 createAdaptiveMaxLimits(input) {
-    const plan = input.plan;
-    const jobCount = Math.max(1, plan?.jobs.length ?? input.schedule?.summary.jobCount ?? input.dashboard?.summary.jobCount ?? 1);
-    const raw = mergeAdaptiveScheduleLimitInputs(plan?.limits, input.maxLimits);
-    const maxReadyJobs = positiveNumber(raw.maxReadyJobs) ? Math.floor(raw.maxReadyJobs) : jobCount;
-    const maxLaneConcurrency = { ...raw.maxLaneConcurrency };
-    const maxConcurrencyKeyConcurrency = { ...raw.maxConcurrencyKeyConcurrency };
-    const maxComputeConcurrency = { ...raw.maxComputeConcurrency };
-    const resourceQuotas = { ...raw.resourceQuotas };
-    for (const job of plan?.jobs ?? []) {
-        maxLaneConcurrency[job.lane] = adaptivePositiveLimit(maxLaneConcurrency[job.lane], job.compute.maxConcurrency ?? maxReadyJobs);
-        maxConcurrencyKeyConcurrency[job.concurrencyKey] = adaptivePositiveLimit(maxConcurrencyKeyConcurrency[job.concurrencyKey], maxReadyJobs);
-        maxComputeConcurrency[job.compute.id] = adaptivePositiveLimit(maxComputeConcurrency[job.compute.id], job.compute.maxConcurrency ?? maxReadyJobs);
-        for (const [resource, amount] of Object.entries(job.resourceRequirements?.resources ?? {})) {
-            resourceQuotas[resource] = adaptivePositiveLimit(resourceQuotas[resource], Math.max(1, Math.ceil(amount), maxReadyJobs));
-        }
-        if (job.resourceRequirements?.browser?.required) {
-            resourceQuotas.browser = adaptivePositiveLimit(resourceQuotas.browser, maxReadyJobs);
-            resourceQuotas['browser-port'] = adaptivePositiveLimit(resourceQuotas['browser-port'], maxReadyJobs);
-        }
-    }
-    return {
-        maxReadyJobs,
-        maxLaneConcurrency: normalizeAdaptiveLimitRecord(maxLaneConcurrency),
-        maxConcurrencyKeyConcurrency: normalizeAdaptiveLimitRecord(maxConcurrencyKeyConcurrency),
-        maxComputeConcurrency: normalizeAdaptiveLimitRecord(maxComputeConcurrency),
-        resourceQuotas: normalizeAdaptiveLimitRecord(resourceQuotas)
-    };
-}
-function createAdaptiveCurrentLimits(input, maxLimits) {
-    if (!input)
-        return cloneJsonValue(maxLimits);
-    const raw = mergeAdaptiveScheduleLimitInputs(maxLimits, input);
-    return {
-        ...(positiveNumber(raw.maxReadyJobs) ? { maxReadyJobs: Math.floor(raw.maxReadyJobs) } : {}),
-        maxLaneConcurrency: normalizeAdaptiveLimitRecord(raw.maxLaneConcurrency),
-        maxConcurrencyKeyConcurrency: normalizeAdaptiveLimitRecord(raw.maxConcurrencyKeyConcurrency),
-        maxComputeConcurrency: normalizeAdaptiveLimitRecord(raw.maxComputeConcurrency),
-        resourceQuotas: normalizeAdaptiveLimitRecord(raw.resourceQuotas)
-    };
-}
-function createAdaptiveMinLimits(input, maxLimits) {
-    const raw = mergeAdaptiveScheduleLimitInputs(undefined, input);
-    const laneMinimums = Object.fromEntries(Object.keys(maxLimits.maxLaneConcurrency).map((key) => [key, 1]));
-    const keyMinimums = Object.fromEntries(Object.keys(maxLimits.maxConcurrencyKeyConcurrency).map((key) => [key, 1]));
-    const computeMinimums = Object.fromEntries(Object.keys(maxLimits.maxComputeConcurrency).map((key) => [key, 1]));
-    const resourceMinimums = Object.fromEntries(Object.keys(maxLimits.resourceQuotas).map((key) => [key, 1]));
-    return {
-        maxReadyJobs: adaptivePositiveLimit(raw.maxReadyJobs, 1),
-        maxLaneConcurrency: normalizeAdaptiveLimitRecord({ ...laneMinimums, ...raw.maxLaneConcurrency }),
-        maxConcurrencyKeyConcurrency: normalizeAdaptiveLimitRecord({ ...keyMinimums, ...raw.maxConcurrencyKeyConcurrency }),
-        maxComputeConcurrency: normalizeAdaptiveLimitRecord({ ...computeMinimums, ...raw.maxComputeConcurrency }),
-        resourceQuotas: normalizeAdaptiveLimitRecord({ ...resourceMinimums, ...raw.resourceQuotas })
-    };
-}
-function mergeAdaptiveScheduleLimitInputs(left, right) {
-    return {
-        ...(right?.maxReadyJobs !== undefined ? { maxReadyJobs: right.maxReadyJobs } : left?.maxReadyJobs !== undefined ? { maxReadyJobs: left.maxReadyJobs } : {}),
-        maxLaneConcurrency: { ...(left?.maxLaneConcurrency ?? {}), ...(right?.maxLaneConcurrency ?? {}) },
-        maxConcurrencyKeyConcurrency: { ...(left?.maxConcurrencyKeyConcurrency ?? {}), ...(right?.maxConcurrencyKeyConcurrency ?? {}) },
-        maxComputeConcurrency: { ...(left?.maxComputeConcurrency ?? {}), ...(right?.maxComputeConcurrency ?? {}) },
-        resourceQuotas: { ...(left?.resourceQuotas ?? {}), ...(right?.resourceQuotas ?? {}) }
-    };
-}
-function clampAdaptiveLimits(value, minLimits, maxLimits) {
-    return {
-        ...(value.maxReadyJobs !== undefined || maxLimits.maxReadyJobs !== undefined ? {
-            maxReadyJobs: clampAdaptiveLimit(value.maxReadyJobs ?? maxLimits.maxReadyJobs ?? 1, minLimits.maxReadyJobs ?? 1, maxLimits.maxReadyJobs ?? value.maxReadyJobs ?? 1)
-        } : {}),
-        maxLaneConcurrency: clampAdaptiveRecord(value.maxLaneConcurrency, minLimits.maxLaneConcurrency, maxLimits.maxLaneConcurrency),
-        maxConcurrencyKeyConcurrency: clampAdaptiveRecord(value.maxConcurrencyKeyConcurrency, minLimits.maxConcurrencyKeyConcurrency, maxLimits.maxConcurrencyKeyConcurrency),
-        maxComputeConcurrency: clampAdaptiveRecord(value.maxComputeConcurrency, minLimits.maxComputeConcurrency, maxLimits.maxComputeConcurrency),
-        resourceQuotas: clampAdaptiveRecord(value.resourceQuotas, minLimits.resourceQuotas, maxLimits.resourceQuotas)
-    };
-}
-function normalizeAdaptiveObservations(input, generatedAt) {
-    const out = [];
-    input.forEach((entry, index) => {
-        const reasons = uniqueStrings([...(entry.reason ? [entry.reason] : []), ...(entry.reasons ?? [])]);
-        const at = entry.at ?? generatedAt;
-        const observation = {
-            id: entry.id ?? 'swarm-adaptive-observation:' + stableHash([entry.kind, entry.jobId, entry.lane, entry.resource, reasons, index, at]),
-            kind: entry.kind,
-            severity: entry.severity ?? adaptiveDefaultSeverity(entry.kind),
-            at,
-            value: Number.isFinite(entry.value) ? Number(entry.value) : 1,
-            ...(entry.jobId ? { jobId: entry.jobId } : {}),
-            ...(entry.taskId ? { taskId: entry.taskId } : {}),
-            ...(entry.lane ? { lane: entry.lane } : {}),
-            ...(entry.compute ? { compute: entry.compute } : {}),
-            ...(entry.concurrencyKey ? { concurrencyKey: entry.concurrencyKey } : {}),
-            ...(entry.resource ? { resource: entry.resource } : {}),
-            ...(entry.path ? { path: entry.path } : {}),
-            ...(entry.region ? { region: entry.region } : {}),
-            reasons: reasons.length ? reasons : [entry.kind],
-            ...(toJsonObject(entry.metadata) ? { metadata: toJsonObject(entry.metadata) } : {})
-        };
-        out.push(observation);
-    });
-    return dedupeAdaptiveObservations(out);
-}
-function deriveAdaptiveScheduleObservations(schedule, at) {
-    if (!schedule)
-        return [];
-    const observations = [];
-    for (const blocked of schedule.blocked) {
-        for (const reason of blocked.reasons) {
-            if (reason === 'waiting-for-dependencies')
-                continue;
-            const resource = reason.startsWith('resource-capacity:') ? reason.slice('resource-capacity:'.length) : undefined;
-            observations.push({
-                kind: resource ? 'resource-capacity' : reason,
-                severity: reason === 'ready-capacity' ? 'info' : 'warning',
-                at,
-                jobId: blocked.jobId,
-                taskId: blocked.taskId,
-                lane: blocked.lane,
-                compute: blocked.compute,
-                concurrencyKey: blocked.concurrencyKey,
-                ...(resource ? { resource } : {}),
-                reason
-            });
-        }
-    }
-    return observations;
-}
-function deriveAdaptiveRunObservations(run, at) {
-    if (!run)
-        return [];
-    const observations = [];
-    for (const result of run.results) {
-        if (result.status === 'failed' || result.exitCode !== undefined && result.exitCode !== 0 || result.verification.some((entry) => entry.required !== false && entry.status !== undefined && entry.status !== 0)) {
-            observations.push({
-                kind: 'evidence-failure',
-                severity: 'error',
-                at,
-                jobId: result.jobId,
-                reason: 'worker failed or required evidence command failed'
-            });
-        }
-        if (result.mergeDisposition === 'discovery-only' || result.mergeReadiness === 'discovery-only') {
-            observations.push({
-                kind: 'discovery-only-output',
-                severity: 'info',
-                at,
-                jobId: result.jobId,
-                reason: 'worker produced discovery output instead of a mergeable patch'
-            });
-        }
-        if (semanticSummaryIsEmpty(result.semanticImport)) {
-            observations.push({
-                kind: 'semantic-empty',
-                severity: 'warning',
-                at,
-                jobId: result.jobId,
-                reason: 'semantic import emitted no selected/imported files or symbols'
-            });
-        }
-        else if (semanticSummaryIsWeak(result.semanticImport)) {
-            observations.push({
-                kind: 'semantic-weak',
-                severity: 'info',
-                at,
-                jobId: result.jobId,
-                reason: 'semantic import has limited source maps, regions, or patch hints'
-            });
-        }
-        if (result.durationMs !== undefined && result.durationMs > 900000) {
-            observations.push({
-                kind: 'slow-job',
-                severity: 'warning',
-                at,
-                jobId: result.jobId,
-                value: result.durationMs,
-                reason: 'worker duration exceeded adaptive slow-job threshold'
-            });
-        }
-        if ((result.status === 'completed' || result.status === 'verified') && result.exitCode === 0 && result.changedPaths.length > 0 && result.mergeDisposition !== 'discovery-only') {
-            observations.push({
-                kind: 'healthy-throughput',
-                severity: 'info',
-                at,
-                jobId: result.jobId,
-                reason: 'worker completed with changed paths'
-            });
-        }
-    }
-    return observations;
-}
-function deriveAdaptiveMergeIndexObservations(index, at) {
-    if (!index)
-        return [];
-    const observations = [];
-    for (const entry of index.entries) {
-        if (entry.staleAgainstHead || entry.disposition === 'stale-against-head') {
-            observations.push({
-                kind: 'stale-patch',
-                severity: 'warning',
-                at,
-                jobId: entry.jobId,
-                lane: entry.lane,
-                path: entry.changedPaths[0],
-                region: entry.changedRegions[0],
-                reason: 'patch is stale against coordinator head'
-            });
-        }
-        if (entry.conflictingJobIds.length) {
-            observations.push({
-                kind: 'merge-conflict',
-                severity: 'warning',
-                at,
-                jobId: entry.jobId,
-                lane: entry.lane,
-                path: entry.changedPaths[0],
-                region: entry.changedRegions[0],
-                value: entry.conflictingJobIds.length,
-                reason: 'merge index found conflicting changed paths or regions'
-            });
-        }
-        if (entry.disposition === 'discovery-only') {
-            observations.push({
-                kind: 'discovery-only-output',
-                severity: 'info',
-                at,
-                jobId: entry.jobId,
-                lane: entry.lane,
-                reason: 'merge index classified the bundle as discovery-only'
-            });
-        }
-        if (semanticSummaryIsEmpty(entry.semanticImport)) {
-            observations.push({
-                kind: 'semantic-empty',
-                severity: 'warning',
-                at,
-                jobId: entry.jobId,
-                lane: entry.lane,
-                reason: 'semantic sidecar is present but empty'
-            });
-        }
-        else if (semanticSummaryIsWeak(entry.semanticImport)) {
-            observations.push({
-                kind: 'semantic-weak',
-                severity: 'info',
-                at,
-                jobId: entry.jobId,
-                lane: entry.lane,
-                reason: 'semantic sidecar lacks merge-useful structure'
-            });
-        }
-    }
-    return observations;
-}
-function deriveAdaptiveDashboardObservations(dashboard, at) {
-    if (!dashboard)
-        return [];
-    const observations = [];
-    for (const job of dashboard.jobs) {
-        if (job.duplicateGroupId) {
-            observations.push({
-                kind: 'duplicate-output',
-                severity: 'info',
-                at,
-                jobId: job.jobId,
-                lane: job.lane,
-                path: job.changedPaths[0],
-                region: job.changedRegions[0],
-                reason: 'coordinator dashboard found duplicate worker output'
-            });
-        }
-        if (job.tests.requiredFailed > 0) {
-            observations.push({
-                kind: 'evidence-failure',
-                severity: 'error',
-                at,
-                jobId: job.jobId,
-                lane: job.lane,
-                reason: 'dashboard shows required evidence failures'
-            });
-        }
-        if (job.staleAgainstHead) {
-            observations.push({
-                kind: 'stale-patch',
-                severity: 'warning',
-                at,
-                jobId: job.jobId,
-                lane: job.lane,
-                path: job.changedPaths[0],
-                reason: 'dashboard marks patch stale against head'
-            });
-        }
-        if (semanticSummaryIsEmpty(job.semanticImport)) {
-            observations.push({
-                kind: 'semantic-empty',
-                severity: 'warning',
-                at,
-                jobId: job.jobId,
-                lane: job.lane,
-                reason: 'dashboard semantic import summary is empty'
-            });
-        }
-    }
-    return observations;
-}
-function deriveAdaptiveAdmissionObservations(admission, at) {
-    if (!admission)
-        return [];
-    const observations = [];
-    for (const deferral of admission.deferred) {
-        for (const reason of deferral.reasons) {
-            const kind = reason === 'stale-against-head'
-                ? 'stale-patch'
-                : reason === 'conflicting-changes'
-                    ? 'merge-conflict'
-                    : reason === 'not-auto-mergeable'
-                        ? 'discovery-only-output'
-                        : reason === 'max-ready'
-                            ? 'ready-capacity'
-                            : 'budget-pressure';
-            observations.push({
-                kind,
-                severity: kind === 'ready-capacity' ? 'info' : 'warning',
-                at,
-                jobId: deferral.jobId,
-                reason: `merge admission deferred: ${reason}`
-            });
-        }
-    }
-    return observations;
-}
-function applyAdaptiveObservation(limits, minLimits, maxLimits, mode, observation, decisions) {
-    if (observation.kind === 'ready-capacity') {
-        decisions.push(createAdaptiveDecision({
-            action: 'hold',
-            target: 'max-ready-jobs',
-            previous: limits.maxReadyJobs,
-            next: limits.maxReadyJobs,
-            max: maxLimits.maxReadyJobs,
-            min: minLimits.maxReadyJobs,
-            reason: observation.reasons[0] ?? 'ready-capacity',
-            observationIds: [observation.id]
-        }));
-        return;
-    }
-    const target = adaptiveDecisionTargetForObservation(observation);
-    const key = adaptiveDecisionKeyForObservation(observation);
-    if (adaptiveObservationIsCapacityBackpressure(observation)) {
-        decisions.push(createAdaptiveDecision({
-            action: 'hold',
-            target,
-            ...(key ? { key } : {}),
-            reason: observation.reasons[0] ?? observation.kind,
-            observationIds: [observation.id]
-        }));
-        return;
-    }
-    if (target === 'lane' && key) {
-        decreaseAdaptiveRecordLimit(limits.maxLaneConcurrency, minLimits.maxLaneConcurrency, maxLimits.maxLaneConcurrency, key, mode, observation, decisions, target);
-    }
-    else if (target === 'concurrency-key' && key) {
-        decreaseAdaptiveRecordLimit(limits.maxConcurrencyKeyConcurrency, minLimits.maxConcurrencyKeyConcurrency, maxLimits.maxConcurrencyKeyConcurrency, key, mode, observation, decisions, target);
-    }
-    else if (target === 'compute' && key) {
-        decreaseAdaptiveRecordLimit(limits.maxComputeConcurrency, minLimits.maxComputeConcurrency, maxLimits.maxComputeConcurrency, key, mode, observation, decisions, target);
-    }
-    else if (target === 'resource' && key) {
-        decreaseAdaptiveRecordLimit(limits.resourceQuotas, minLimits.resourceQuotas, maxLimits.resourceQuotas, key, mode, observation, decisions, target);
-    }
-    if (adaptiveObservationShouldReduceReadyWindow(observation)) {
-        const previous = limits.maxReadyJobs ?? maxLimits.maxReadyJobs ?? 1;
-        const min = minLimits.maxReadyJobs ?? 1;
-        const max = maxLimits.maxReadyJobs ?? previous;
-        const next = adaptiveReducedValue(previous, min, mode, observation);
-        limits.maxReadyJobs = clampAdaptiveLimit(next, min, max);
-        decisions.push(createAdaptiveDecision({
-            action: limits.maxReadyJobs < previous ? 'decrease' : 'hold',
-            target: 'max-ready-jobs',
-            previous,
-            next: limits.maxReadyJobs,
-            max,
-            min,
-            reason: observation.reasons[0] ?? observation.kind,
-            observationIds: [observation.id]
-        }));
-    }
-}
-function applyAdaptiveRecovery(limits, maxLimits, observation, decisions) {
-    if (limits.maxReadyJobs !== undefined && maxLimits.maxReadyJobs !== undefined && limits.maxReadyJobs < maxLimits.maxReadyJobs) {
-        const previous = limits.maxReadyJobs;
-        limits.maxReadyJobs = Math.min(maxLimits.maxReadyJobs, previous + 1);
-        decisions.push(createAdaptiveDecision({
-            action: 'increase',
-            target: 'max-ready-jobs',
-            previous,
-            next: limits.maxReadyJobs,
-            max: maxLimits.maxReadyJobs,
-            reason: observation.reasons[0] ?? observation.kind,
-            observationIds: [observation.id]
-        }));
-    }
-    if (observation.lane) {
-        increaseAdaptiveRecordLimit(limits.maxLaneConcurrency, maxLimits.maxLaneConcurrency, observation.lane, observation, decisions, 'lane');
-    }
-    if (observation.compute) {
-        increaseAdaptiveRecordLimit(limits.maxComputeConcurrency, maxLimits.maxComputeConcurrency, observation.compute, observation, decisions, 'compute');
-    }
-}
-function decreaseAdaptiveRecordLimit(record, minRecord, maxRecord, key, mode, observation, decisions, target) {
-    const previous = record[key] ?? maxRecord[key];
-    if (!positiveNumber(previous))
-        return;
-    const min = minRecord[key] ?? 1;
-    const max = maxRecord[key] ?? previous;
-    const next = clampAdaptiveLimit(adaptiveReducedValue(previous, min, mode, observation), min, max);
-    record[key] = next;
-    decisions.push(createAdaptiveDecision({
-        action: next < previous ? 'decrease' : 'hold',
-        target,
-        key,
-        previous,
-        next,
-        max,
-        min,
-        reason: observation.reasons[0] ?? observation.kind,
-        observationIds: [observation.id]
-    }));
-}
-function increaseAdaptiveRecordLimit(record, maxRecord, key, observation, decisions, target) {
-    const previous = record[key];
-    const max = maxRecord[key];
-    if (!positiveNumber(previous) || !positiveNumber(max) || previous >= max)
-        return;
-    record[key] = Math.min(max, previous + 1);
-    decisions.push(createAdaptiveDecision({
-        action: 'increase',
-        target,
-        key,
-        previous,
-        next: record[key],
-        max,
-        reason: observation.reasons[0] ?? observation.kind,
-        observationIds: [observation.id]
-    }));
-}
-function adaptiveReducedValue(previous, min, mode, observation) {
-    if (observation.kind === 'merge-conflict' || observation.kind === 'duplicate-output' || observation.kind === 'concurrency-key-capacity')
-        return min;
-    const severityFactor = observation.severity === 'critical' ? 0.45 : observation.severity === 'error' ? 0.55 : observation.severity === 'warning' ? 0.7 : 0.85;
-    const modeFactor = mode === 'conservative' ? 0.6 : mode === 'aggressive' ? 0.85 : 0.75;
-    return Math.max(min, Math.floor(previous * Math.min(severityFactor, modeFactor)));
-}
-function adaptiveObservationShouldReduceReadyWindow(observation) {
-    return observation.kind === 'evidence-failure'
-        || observation.kind === 'stale-patch'
-        || observation.kind === 'browser-contention'
-        || observation.kind === 'semantic-empty'
-        || observation.kind === 'log-noise'
-        || observation.kind === 'discovery-only-output'
-        || observation.kind === 'budget-pressure'
-        || observation.kind === 'slow-job';
-}
-function adaptiveObservationIsCapacityBackpressure(observation) {
-    return observation.kind === 'resource-capacity'
-        || observation.kind === 'lane-capacity'
-        || observation.kind === 'concurrency-key-capacity'
-        || observation.kind === 'compute-capacity';
-}
-function adaptiveDecisionTargetForObservation(observation) {
-    if (observation.kind === 'resource-capacity' || observation.kind === 'browser-contention')
-        return 'resource';
-    if (observation.kind === 'lane-capacity')
-        return 'lane';
-    if (observation.kind === 'concurrency-key-capacity' || observation.kind === 'merge-conflict' || observation.kind === 'duplicate-output')
-        return 'concurrency-key';
-    if (observation.kind === 'compute-capacity')
-        return 'compute';
-    if (observation.lane)
-        return 'lane';
-    return 'max-ready-jobs';
-}
-function adaptiveDecisionKeyForObservation(observation) {
-    const target = adaptiveDecisionTargetForObservation(observation);
-    if (target === 'resource')
-        return observation.resource ?? (observation.kind === 'browser-contention' ? 'browser' : undefined);
-    if (target === 'lane')
-        return observation.lane;
-    if (target === 'concurrency-key')
-        return observation.concurrencyKey ?? observation.region ?? observation.path;
-    if (target === 'compute')
-        return observation.compute;
-    return undefined;
-}
-function adaptiveObservationIsBottleneck(observation) {
-    if (observation.kind === 'healthy-throughput' || observation.kind === 'ready-capacity')
-        return false;
-    return observation.severity !== 'info'
-        || observation.kind === 'merge-conflict'
-        || observation.kind === 'stale-patch'
-        || observation.kind === 'semantic-empty'
-        || observation.kind === 'log-noise'
-        || observation.kind === 'duplicate-output';
-}
-function adaptiveDefaultSeverity(kind) {
-    if (kind === 'evidence-failure' || kind === 'budget-pressure')
-        return 'error';
-    if (kind === 'merge-conflict' || kind === 'stale-patch' || kind === 'semantic-empty' || kind === 'browser-contention' || kind.endsWith('-capacity'))
-        return 'warning';
-    return 'info';
-}
-function createAdaptiveDecision(input) {
-    return {
-        id: 'swarm-adaptive-decision:' + stableHash([input.action, input.target, input.key, input.previous, input.next, input.reason, input.observationIds]),
-        ...input
-    };
-}
-function semanticSummaryIsEmpty(summary) {
-    if (!summary)
-        return false;
-    return summary.total === 0
-        || summary.selected === 0 && summary.eligible === 0 && summary.imported === 0 && summary.semanticIndex.symbols === 0 && summary.semanticSidecars.symbols === 0;
-}
-function semanticSummaryIsWeak(summary) {
-    if (!summary || semanticSummaryIsEmpty(summary))
-        return false;
-    return summary.imported === 0
-        || summary.semanticIndex.symbols === 0
-        || summary.semanticSidecars.ownershipRegions === 0
-        || summary.sourceMapMappingCount === 0
-        || summary.proofSpec.failed > 0
-        || summary.proofSpec.stale > 0
-        || summary.proofSpec.open > 0
-        || summary.proofSpec.unknown > 0;
-}
-function dedupeAdaptiveObservations(observations) {
-    const byKey = new Map();
-    for (const observation of observations) {
-        const key = [
-            observation.kind,
-            observation.jobId ?? '',
-            observation.lane ?? '',
-            observation.compute ?? '',
-            observation.concurrencyKey ?? '',
-            observation.resource ?? '',
-            observation.path ?? '',
-            observation.region ?? '',
-            observation.reasons.join('|')
-        ].join('\0');
-        const existing = byKey.get(key);
-        if (!existing || adaptiveSeverityRank(observation.severity) > adaptiveSeverityRank(existing.severity))
-            byKey.set(key, observation);
-    }
-    return Array.from(byKey.values()).sort((left, right) => adaptiveSeverityRank(right.severity) - adaptiveSeverityRank(left.severity) || left.kind.localeCompare(right.kind) || (left.jobId ?? '').localeCompare(right.jobId ?? ''));
-}
-function adaptiveSeverityRank(severity) {
-    if (severity === 'critical')
-        return 4;
-    if (severity === 'error')
-        return 3;
-    if (severity === 'warning')
-        return 2;
-    if (severity === 'info')
-        return 1;
-    return 0;
-}
-function normalizeAdaptiveLimitRecord(input = {}) {
-    const out = {};
-    for (const [key, value] of Object.entries(input)) {
-        if (positiveNumber(value))
-            out[key] = Math.max(1, Math.floor(value));
-    }
-    return out;
-}
-function clampAdaptiveRecord(value, minRecord, maxRecord) {
-    const keys = uniqueStrings([...Object.keys(value), ...Object.keys(minRecord), ...Object.keys(maxRecord)]);
-    const out = {};
-    for (const key of keys) {
-        const max = maxRecord[key];
-        if (!positiveNumber(max))
-            continue;
-        const min = minRecord[key] ?? 1;
-        out[key] = clampAdaptiveLimit(value[key] ?? max, min, max);
-    }
-    return out;
-}
-function clampAdaptiveLimit(value, min, max) {
-    const upper = Math.max(1, Math.floor(max));
-    const lower = Math.min(upper, Math.max(1, Math.floor(min)));
-    return Math.min(upper, Math.max(lower, Math.floor(value)));
-}
-function adaptivePositiveLimit(value, fallback) {
-    return positiveNumber(value) ? Math.max(1, Math.floor(value)) : Math.max(1, Math.floor(fallback));
-}
-function normalizeBudget(input = {}) {
-    return {
-        ...(positiveNumber(input.maxCostUsd) ? { maxCostUsd: input.maxCostUsd } : {}),
-        ...(positiveNumber(input.maxInputTokens) ? { maxInputTokens: Math.floor(input.maxInputTokens) } : {}),
-        ...(positiveNumber(input.maxOutputTokens) ? { maxOutputTokens: Math.floor(input.maxOutputTokens) } : {}),
-        ...(positiveNumber(input.maxDurationMs) ? { maxDurationMs: Math.floor(input.maxDurationMs) } : {}),
-        maxRetries: Math.max(0, Math.floor(input.maxRetries ?? 0)),
-        ...(toJsonObject(input.metadata) ? { metadata: toJsonObject(input.metadata) } : {})
-    };
-}
-function normalizeUsage(input) {
-    return {
-        costUsd: Math.max(0, input.costUsd ?? 0),
-        inputTokens: Math.max(0, Math.floor(input.inputTokens ?? 0)),
-        outputTokens: Math.max(0, Math.floor(input.outputTokens ?? 0)),
-        durationMs: Math.max(0, Math.floor(input.durationMs ?? 0)),
-        attempts: Math.max(1, Math.floor(input.attempts ?? 1)),
-        ...(toJsonObject(input.metadata) ? { metadata: toJsonObject(input.metadata) } : {})
-    };
-}
-function normalizeReviewPolicy(input = {}) {
-    const sampleRate = typeof input.sampleRate === 'number' && Number.isFinite(input.sampleRate)
-        ? Math.min(1, Math.max(0, input.sampleRate))
-        : 0;
-    return {
-        requiredReviewers: Math.max(0, Math.floor(input.requiredReviewers ?? 0)),
-        sampleRate,
-        alwaysReview: input.alwaysReview ?? false,
-        reviewerPool: uniqueStrings(input.reviewerPool ?? []),
-        ...(toJsonObject(input.metadata) ? { metadata: toJsonObject(input.metadata) } : {})
-    };
-}
-function normalizeArtifact(input) {
-    return {
-        jobId: normalizeId(input.jobId, 'artifact job id'),
-        path: normalizeId(input.path, 'artifact path'),
-        kind: input.kind ?? 'artifact',
-        ...(positiveNumber(input.bytes) ? { bytes: Math.floor(input.bytes) } : {}),
-        ...(input.hash ? { hash: input.hash } : {}),
-        ...(input.producedAt !== undefined ? { producedAt: input.producedAt } : {}),
-        ...(toJsonObject(input.metadata) ? { metadata: toJsonObject(input.metadata) } : {})
-    };
-}
-function reviewReason(job, result, budget, sampleSalt) {
-    if (result?.ownershipViolations.length)
-        return 'violations';
-    if (result?.status === 'failed' || result?.exitCode !== undefined && result.exitCode !== 0)
-        return 'failed';
-    if (budget && !budget.ok)
-        return 'budget';
-    if (job.review.alwaysReview)
-        return 'always-review';
-    if (job.review.sampleRate > 0 && deterministicUnitInterval([sampleSalt, job.id]) < job.review.sampleRate)
-        return 'sampled';
-    return undefined;
-}
-function selectReviewers(pool, required, salt) {
-    if (required <= 0 || pool.length === 0)
-        return [];
-    const sorted = [...uniqueStrings(pool)].sort((left, right) => stableHash([salt, left]).localeCompare(stableHash([salt, right])));
-    return sorted.slice(0, Math.min(required, sorted.length));
-}
-function conflictMap(results) {
-    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);
-        }
-    }
-    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 })
-                });
-            }
-        }
-    }
-    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 normalizeCoordinatorProcesses(input) {
-    return input.map((entry) => ({
-        ...(entry.pid !== undefined ? { pid: Math.floor(entry.pid) } : {}),
-        role: entry.role ?? 'worker',
-        ...(entry.jobId ? { jobId: entry.jobId } : {}),
-        ...(entry.runId ? { runId: entry.runId } : {}),
-        status: entry.status ?? 'unknown',
-        ...(entry.startedAt !== undefined ? { startedAt: entry.startedAt } : {}),
-        ...(entry.lastSeenAt !== undefined ? { lastSeenAt: entry.lastSeenAt } : {}),
-        command: [...(entry.command ?? [])],
-        ...(toJsonObject(entry.metadata) ? { metadata: toJsonObject(entry.metadata) } : {})
-    })).sort((left, right) => (left.jobId ?? '').localeCompare(right.jobId ?? '') || (left.pid ?? 0) - (right.pid ?? 0));
-}
-function createCoordinatorDuplicateGroups(entries) {
-    const groups = new Map();
-    for (const entry of entries) {
-        for (const key of coordinatorDuplicateKeys(entry))
-            groups.set(key, [...(groups.get(key) ?? []), entry]);
-    }
-    return Array.from(groups.entries())
-        .filter(([, groupEntries]) => groupEntries.length > 1)
-        .map(([key, groupEntries]) => {
-        const jobIds = groupEntries.map((entry) => entry.jobId).sort();
-        return {
-            id: 'swarm-duplicate-group:' + stableHash([key, jobIds]),
-            key,
-            jobIds,
-            reason: key.startsWith('queue:') ? 'same-queue-item' : key.startsWith('region:') ? 'same-semantic-region' : 'same-changed-paths'
-        };
-    })
-        .sort((left, right) => left.key.localeCompare(right.key));
-}
-function coordinatorDuplicateKeys(entry) {
-    const keys = [];
-    if (entry.queueItemIds.length)
-        keys.push(`queue:${entry.queueItemIds.slice().sort().join('|')}`);
-    if (entry.changedRegions.length)
-        keys.push(`region:${entry.changedRegions.slice().sort().join('|')}`);
-    if (entry.changedPaths.length)
-        keys.push(`path:${entry.changedPaths.slice().sort().join('|')}`);
-    return keys;
-}
-function scoreCoordinatorMergeJob(entry, bundle, evidenceEntryCount, duplicateGroup, admissionStatus, admissionReasons) {
-    if (!entry)
-        return { score: 10, reasons: ['no-merge-index-entry'] };
-    let score = entry.disposition === 'auto-mergeable' && entry.autoMergeable ? 85 : entry.disposition === 'needs-port' ? 60 : entry.disposition === 'discovery-only' ? 35 : 15;
-    const reasons = [];
-    if (entry.staleAgainstHead) {
-        score -= 45;
-        reasons.push('stale-against-head');
-    }
-    if (entry.conflictingJobIds.length) {
-        score -= Math.min(35, 15 + entry.conflictingJobIds.length * 5);
-        reasons.push('conflicting-changes');
-    }
-    if (entry.ownershipViolations.length) {
-        score -= 40;
-        reasons.push('ownership-violations');
-    }
-    if (bundle?.commandsFailed.length) {
-        score -= Math.min(35, 15 + bundle.commandsFailed.length * 10);
-        reasons.push('failed-required-commands');
-    }
-    if (entry.evidencePaths.length === 0 && evidenceEntryCount === 0) {
-        score -= 15;
-        reasons.push('missing-evidence');
-    }
-    if (entry.riskLevel === 'high') {
-        score -= 15;
-        reasons.push('high-risk');
-    }
-    else if (entry.riskLevel === 'unknown') {
-        score -= 8;
-        reasons.push('unknown-risk');
-    }
-    else if (entry.riskLevel === 'medium') {
-        score -= 5;
-    }
-    if (entry.disposition === 'needs-port')
-        reasons.push('needs-human-port');
-    if (entry.disposition === 'discovery-only')
-        reasons.push('discovery-only');
-    if (duplicateGroup) {
-        score -= 12;
-        reasons.push('duplicate-candidate');
-    }
-    if (admissionStatus === 'deferred') {
-        score -= 10;
-        reasons.push(...admissionReasons);
-    }
-    if (entry.semanticImport && entry.changedPaths.length > 0) {
-        const symbols = entry.semanticImport.semanticIndex.symbols;
-        const regions = entry.semanticImport.semanticSidecars.ownershipRegions;
-        const errors = entry.semanticImport.errors;
-        if (symbols > 0 && regions > 0) {
-            score += 8;
-            reasons.push('semantic-sidecar-usable');
-        }
-        if (entry.semanticImport.semanticSidecars.empty > 0 || symbols === 0) {
-            score -= 8;
-            reasons.push('weak-semantic-sidecar');
-        }
-        if (errors > 0) {
-            score -= Math.min(25, errors * 10);
-            reasons.push('semantic-import-errors');
-        }
-    }
-    else if (entry.changedPaths.length > 0) {
-        score -= 5;
-        reasons.push('missing-semantic-sidecar');
-    }
-    if (bundle?.commandsPassed.length)
-        score += Math.min(8, bundle.commandsPassed.length * 2);
-    return { score: clampScore(score), reasons: uniqueStrings(reasons) };
-}
-function coordinatorJobLiveness(result, entry, processes) {
-    if (result || entry)
-        return 'finished';
-    if (processes.some((process) => process.status === 'running'))
-        return 'running';
-    if (processes.some((process) => process.status === 'missing'))
-        return 'missing';
-    return 'unknown';
-}
-function primaryEvidencePath(paths) {
-    return paths.find((entry) => entry.endsWith('/evidence.json') || entry === 'evidence.json')
-        ?? paths.find((entry) => entry.endsWith('/merge.json') || entry === 'merge.json')
-        ?? paths.find((entry) => entry.endsWith('/last-message.md') || entry.endsWith('/last.md'))
-        ?? paths[0];
-}
-function createCoordinatorSourceCitations(entry, evidenceIndex) {
-    const citations = [];
-    for (const file of entry?.changedPaths ?? [])
-        citations.push({ path: file, kind: 'changed-source' });
-    for (const region of entry?.changedRegions ?? [])
-        citations.push({ path: region, kind: 'semantic-region', region });
-    for (const evidence of evidenceIndex?.byJobId[entry?.jobId ?? ''] ?? []) {
-        if (!evidence.path)
-            continue;
-        citations.push({
-            path: evidence.path,
-            kind: evidence.kind,
-            ...(evidence.topic ? { symbol: evidence.topic } : {}),
-            confidence: evidence.confidence,
-            ...(Object.keys(evidence.facets).length ? { metadata: { facets: evidence.facets } } : {})
-        });
-    }
-    const seen = new Set();
-    return citations.filter((citation) => {
-        const key = `${citation.kind}:${citation.path}:${citation.symbol ?? ''}:${citation.region ?? ''}`;
-        if (seen.has(key))
-            return false;
-        seen.add(key);
-        return true;
-    }).sort((left, right) => left.kind.localeCompare(right.kind) || left.path.localeCompare(right.path));
-}
-function averageScore(scores) {
-    if (scores.length === 0)
-        return 0;
-    return Math.round(scores.reduce((sum, score) => sum + score, 0) / scores.length);
-}
-function clampScore(value) {
-    if (!Number.isFinite(value))
-        return 0;
-    return Math.max(0, Math.min(100, Math.round(value)));
-}
-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]));
-    return ready.map((jobId) => {
-        const changedPaths = [...(byJob.get(jobId)?.changedPaths ?? [])].sort();
-        return {
-            id: 'merge-group:' + stableHash([jobId, changedPaths]),
-            jobIds: [jobId],
-            changedPaths
-        };
-    });
-}
-function groupArtifacts(artifacts, key) {
-    const out = {};
-    for (const artifact of artifacts) {
-        const group = key(artifact);
-        out[group] = [...(out[group] ?? []), artifact];
-    }
-    return out;
-}
-function groupIds(items, key) {
-    const out = {};
-    for (const item of items) {
-        const group = key(item);
-        const id = item.jobId ?? item.id;
-        if (!id)
-            continue;
-        out[group] = [...(out[group] ?? []), id];
-    }
-    for (const ids of Object.values(out))
-        ids.sort();
-    return out;
-}
-function countBy(values) {
-    const out = {};
-    for (const value of values)
-        out[value] = (out[value] ?? 0) + 1;
-    return out;
-}
-function hasJobDependencyCycle(start, dependenciesByJobId) {
-    const visiting = new Set();
-    const visited = new Set();
-    const visit = (node) => {
-        if (visiting.has(node))
-            return true;
-        if (visited.has(node))
-            return false;
-        visiting.add(node);
-        for (const dep of dependenciesByJobId[node] ?? []) {
-            if (visit(dep))
-                return true;
-        }
-        visiting.delete(node);
-        visited.add(node);
-        return false;
-    };
-    return visit(start);
-}
-function deterministicUnitInterval(value) {
-    const hex = stableHash(value).split(':')[1] ?? '0';
-    return parseInt(hex, 16) / 0xffffffff;
-}
-function normalizeComputeList(input) {
-    const values = input && input.length > 0 ? input : [{
-            id: FRONTIER_SWARM_DEFAULT_CODEX_COMPUTE_ID,
-            kind: 'codex',
-            model: FRONTIER_SWARM_DEFAULT_MODEL,
-            reasoningEffort: FRONTIER_SWARM_DEFAULT_REASONING_EFFORT
-        }];
-    return values.map((compute) => ({
-        id: normalizeId(compute.id, 'compute id'),
-        kind: compute.kind ?? 'external',
-        ...(compute.title ? { title: compute.title } : {}),
-        ...(compute.model ? { model: compute.model } : {}),
-        ...(compute.reasoningEffort ? { reasoningEffort: compute.reasoningEffort } : {}),
-        ...(compute.serviceTier ? { serviceTier: compute.serviceTier } : {}),
-        ...(compute.profile ? { profile: compute.profile } : {}),
-        ...(compute.sandbox ? { sandbox: compute.sandbox } : {}),
-        ...(compute.approval ? { approval: compute.approval } : {}),
-        ...(positiveNumber(compute.maxConcurrency) ? { maxConcurrency: Math.floor(compute.maxConcurrency) } : {}),
-        ...(positiveNumber(compute.timeoutMs) ? { timeoutMs: Math.floor(compute.timeoutMs) } : {}),
-        ...(toJsonObject(compute.metadata) ? { metadata: toJsonObject(compute.metadata) } : {})
-    }));
-}
-function normalizeLayer(input) {
-    return {
-        id: normalizeId(input.id, 'layer id'),
-        title: input.title ?? titleFromId(input.id),
-        ...(input.description ? { description: input.description } : {}),
-        ...(input.parentId ? { parentId: normalizeId(input.parentId, 'parent layer id') } : {}),
-        ...(input.compute ? { compute: input.compute } : {}),
-        ...(input.defaultCompute ? { defaultCompute: input.defaultCompute } : {}),
-        childCompute: { ...(input.childCompute ?? {}) },
-        tags: uniqueStrings(input.tags ?? []),
-        ...(toJsonObject(input.metadata) ? { metadata: toJsonObject(input.metadata) } : {})
-    };
-}
-function normalizeLane(input) {
-    const allowedWrites = uniqueStrings([...(input.allowedWrites ?? []), ...(input.allowedGlobs ?? [])]);
-    return {
-        id: normalizeId(input.id, 'lane id'),
-        title: input.title ?? titleFromId(input.id),
-        ...(input.description ? { description: input.description } : {}),
-        ...(input.layer ? { layer: input.layer } : {}),
-        ...(input.compute ? { compute: input.compute } : {}),
-        allowedWrites,
-        sharedReadOnly: uniqueStrings(input.sharedReadOnly ?? []),
-        neverEdit: uniqueStrings(input.neverEdit ?? []),
-        ownershipRegions: normalizeOwnershipRegions(input.ownershipRegions ?? []),
-        capabilities: uniqueStrings(input.capabilities ?? []),
-        ...(input.resourceRequirements ? { resourceRequirements: normalizeResourceRequirements(input.resourceRequirements) } : {}),
-        ...(input.worktreePath ? { worktreePath: input.worktreePath } : {}),
-        ...(input.evidencePrefix || input.evidenceOutDirPrefix ? { evidencePrefix: input.evidencePrefix ?? input.evidenceOutDirPrefix } : {}),
-        concurrencyKey: input.concurrencyKey ?? input.id,
-        ...(positiveNumber(input.maxConcurrency) ? { maxConcurrency: Math.floor(input.maxConcurrency) } : {}),
-        handoffCommands: normalizeCommands(input.handoffCommands ?? []),
-        tags: uniqueStrings(input.tags ?? []),
-        ...(toJsonObject(input.metadata) ? { metadata: toJsonObject(input.metadata) } : {})
-    };
-}
-function normalizeOwnershipRegions(input = []) {
-    return input.map((region) => {
-        const globs = uniqueStrings([...(region.globs ?? []), ...(region.paths ?? [])]);
-        return {
-            id: normalizeId(region.id, 'ownership region id'),
-            title: region.title ?? titleFromId(region.id),
-            ...(region.description ? { description: region.description } : {}),
-            globs,
-            selectors: uniqueStrings(region.selectors ?? []),
-            ...(region.owner ? { owner: region.owner } : {}),
-            ...(toJsonObject(region.metadata) ? { metadata: toJsonObject(region.metadata) } : {})
-        };
-    });
-}
-function mergeOwnershipRegions(laneRegions, taskRegions) {
-    const byId = new Map();
-    for (const region of laneRegions)
-        byId.set(region.id, cloneJsonValue(region));
-    for (const region of taskRegions)
-        byId.set(region.id, cloneJsonValue(region));
-    return Array.from(byId.values()).sort((left, right) => left.id.localeCompare(right.id));
-}
-function normalizeResourceRequirements(input = {}) {
-    const resources = {};
-    for (const [key, value] of Object.entries(input.resources ?? {})) {
-        if (Number.isFinite(value) && value > 0)
-            resources[key] = value;
-    }
-    return {
-        capabilities: uniqueStrings(input.capabilities ?? []),
-        resources,
-        ...(input.browser ? { browser: normalizeBrowserResource(input.browser) } : {}),
-        ...(toJsonObject(input.metadata) ? { metadata: toJsonObject(input.metadata) } : {})
-    };
-}
-function normalizeBrowserResource(input) {
-    return {
-        required: input.required ?? true,
-        portPool: uniqueStrings((input.portPool ?? []).map((port) => String(port))),
-        ...(input.profileDir ? { profileDir: input.profileDir } : {}),
-        ...(input.profileDirPrefix ? { profileDirPrefix: input.profileDirPrefix } : {}),
-        ...(positiveNumber(input.maxConcurrency) ? { maxConcurrency: Math.floor(input.maxConcurrency) } : {}),
-        ...(input.headless !== undefined ? { headless: input.headless } : {}),
-        ...(toJsonObject(input.metadata) ? { metadata: toJsonObject(input.metadata) } : {})
-    };
-}
-function mergeResourceRequirements(lane, task, extraCapabilities = []) {
-    if (!lane && !task && extraCapabilities.length === 0)
-        return undefined;
-    const capabilities = uniqueStrings([...(lane?.capabilities ?? []), ...(task?.capabilities ?? []), ...extraCapabilities]);
-    const resources = { ...(lane?.resources ?? {}) };
-    for (const [key, value] of Object.entries(task?.resources ?? {}))
-        resources[key] = Math.max(resources[key] ?? 0, value);
-    const browser = task?.browser ?? lane?.browser;
-    const metadata = toJsonObject({ ...(lane?.metadata ?? {}), ...(task?.metadata ?? {}) });
-    return {
-        capabilities,
-        resources,
-        ...(browser ? { browser } : {}),
-        ...(metadata && Object.keys(metadata).length ? { metadata } : {})
-    };
-}
-function normalizePolicy(input, defaultCompute) {
-    return {
-        mode: input?.mode ?? 'hard-file-ownership',
-        defaultConcurrency: Math.max(1, Math.floor(input?.defaultConcurrency ?? 1)),
-        defaultCompute: input?.defaultCompute ?? defaultCompute,
-        ...(input?.defaultLayer ? { defaultLayer: input.defaultLayer } : {}),
-        completedStatuses: uniqueStrings(input?.completedStatuses ?? DEFAULT_COMPLETED_STATUSES),
-        sharedReadOnly: uniqueStrings(input?.sharedReadOnly ?? []),
-        neverEditWithoutParent: uniqueStrings(input?.neverEditWithoutParent ?? []),
-        requireCleanWorktree: input?.requireCleanWorktree ?? true,
-        ...(toJsonObject(input?.metadata) ? { metadata: toJsonObject(input?.metadata) } : {})
-    };
-}
-function normalizeTask(input) {
-    const targetRefs = uniqueStrings([...(input.targetRefs ?? []), ...(input.ownedFiles ?? [])]);
-    return {
-        kind: FRONTIER_SWARM_TASK_KIND,
-        version: FRONTIER_SWARM_TASK_VERSION,
-        id: normalizeId(input.id, 'task id'),
-        title: input.title ?? titleFromId(input.id),
-        objective: input.objective ?? input.description ?? input.title ?? input.id,
-        ...(input.description ? { description: input.description } : {}),
-        workKind: input.kind ?? 'agent-task',
-        status: input.status ?? 'open',
-        ...(input.lane ? { lane: input.lane } : {}),
-        ...(input.layer ? { layer: input.layer } : {}),
-        ...(input.compute ? { compute: input.compute } : {}),
-        ...(input.parentTaskId ? { parentTaskId: input.parentTaskId } : {}),
-        dependsOn: uniqueStrings(input.dependsOn ?? []),
-        ...(input.concurrencyKey ? { concurrencyKey: input.concurrencyKey } : {}),
-        ...(input.budget ? { budget: normalizeBudget(input.budget) } : {}),
-        ...(input.review ? { review: normalizeReviewPolicy(input.review) } : {}),
-        priority: Number.isFinite(input.priority) ? Number(input.priority) : 100,
-        sourceRefs: uniqueStrings(input.sourceRefs ?? []),
-        targetRefs,
-        allowedWrites: uniqueStrings([...(input.allowedWrites ?? []), ...targetRefs]),
-        ownershipRegions: normalizeOwnershipRegions(input.ownershipRegions ?? []),
-        ownedRegions: uniqueStrings(input.ownedRegions ?? []),
-        changedRegions: uniqueStrings(input.changedRegions ?? []),
-        capabilities: uniqueStrings(input.capabilities ?? []),
-        ...(input.resourceRequirements ? { resourceRequirements: normalizeResourceRequirements(input.resourceRequirements) } : {}),
-        acceptance: normalizeAcceptance(input),
-        verification: normalizeCommands(input.verification ?? []),
-        ...(input.evidenceCommand ? { evidenceCommand: input.evidenceCommand } : {}),
-        ...(input.shardCommand ? { shardCommand: input.shardCommand } : {}),
-        tags: uniqueStrings(input.tags ?? []),
-        ...(toJsonObject(input.metadata) ? { metadata: toJsonObject(input.metadata) } : {})
-    };
-}
-function normalizeTaskList(input) {
-    if (Array.isArray(input))
-        return input.map((task) => isSwarmTask(task) ? cloneJsonValue(task) : normalizeTask(task));
-    return defineSwarmTasks(input);
-}
-function normalizeAcceptance(input) {
-    const checks = (input.acceptanceChecks ?? []).map((check) => typeof check === 'string' ? check : check.description ?? check.id ?? '').filter(Boolean);
-    return uniqueStrings([...(input.acceptance ?? []), ...checks]);
-}
-function normalizeCommands(input) {
-    return input.map((entry) => {
-        if (typeof entry === 'string') {
-            return { name: entry, command: entry, args: [], required: true };
-        }
-        return {
-            name: entry.name ?? [entry.command, ...(entry.args ?? [])].join(' '),
-            command: entry.command,
-            args: [...(entry.args ?? [])],
-            required: entry.required ?? true,
-            ...(entry.cwd ? { cwd: entry.cwd } : {}),
-            ...(toJsonObject(entry.metadata) ? { metadata: toJsonObject(entry.metadata) } : {})
-        };
-    });
-}
-function selectSwarmTasks(manifest, tasks, options) {
-    const lanes = new Set(options.lanes ?? []);
-    const layers = new Set(options.layers ?? []);
-    const statuses = new Set(options.statuses ?? []);
-    const selectors = (options.selectors ?? []).map((selector) => selector.toLowerCase());
-    const completed = new Set(manifest.policy.completedStatuses);
-    const limit = options.limit === undefined ? tasks.length : Math.max(0, Math.floor(options.limit));
-    return tasks
-        .filter((task) => !task.lane || manifest.lanes.some((lane) => lane.id === task.lane))
-        .filter((task) => lanes.size === 0 || (task.lane !== undefined && lanes.has(task.lane)))
-        .filter((task) => layers.size === 0 || taskLayer(manifest, task) !== undefined && layers.has(taskLayer(manifest, task)))
-        .filter((task) => statuses.size === 0 || statuses.has(task.status))
-        .filter((task) => options.includeCompleted || !completed.has(task.status))
-        .filter((task) => selectors.length === 0 || selectors.some((selector) => searchableTask(task).includes(selector)))
-        .sort((left, right) => left.priority - right.priority || left.id.localeCompare(right.id))
-        .slice(0, limit);
-}
-function createSelectionEntry(manifest, task, priority) {
-    const lane = task.lane ? manifest.lanes.find((entry) => entry.id === task.lane) : undefined;
-    return {
-        task,
-        ...(lane ? { lane } : {}),
-        ownershipWarnings: selectionOwnershipWarnings(task, lane),
-        selectionPriority: selectionPriority(task, priority)
-    };
-}
-function selectionOwnershipWarnings(task, lane) {
-    if (!lane || lane.allowedWrites.length === 0)
-        return [];
-    return task.targetRefs
-        .filter((file) => !lane.allowedWrites.some((glob) => matchesGlob(file, glob)))
-        .map((file) => `${file} is outside allowed write globs for ${lane.id}`);
-}
-function selectionPriority(task, input) {
-    const statusRanks = input?.statuses ?? {};
-    const workKindRanks = input?.workKinds ?? {};
-    const statusRank = statusRanks[task.status] ?? input?.defaultStatusRank ?? 100;
-    const workKindRank = workKindRanks[task.workKind] ?? input?.defaultWorkKindRank ?? 100;
-    const statusWeight = input?.statusWeight ?? 1000;
-    const workKindWeight = input?.workKindWeight ?? 1;
-    return statusRank * statusWeight + workKindRank * workKindWeight;
-}
-function roundRobinSelectionByLane(entries) {
-    const groups = new Map();
-    for (const entry of entries)
-        groups.set(entry.task.lane ?? 'unassigned', [...(groups.get(entry.task.lane ?? 'unassigned') ?? []), entry]);
-    const selected = [];
-    while (Array.from(groups.values()).some((group) => group.length > 0)) {
-        for (const group of groups.values()) {
-            const next = group.shift();
-            if (next)
-                selected.push(next);
-        }
-    }
-    return selected;
-}
-function summarizeTaskSelection(entries) {
-    return entries.reduce((summary, entry) => {
-        const lane = entry.task.lane ?? 'unassigned';
-        summary.total += 1;
-        summary.byLane[lane] = (summary.byLane[lane] ?? 0) + 1;
-        summary.byWorkKind[entry.task.workKind] = (summary.byWorkKind[entry.task.workKind] ?? 0) + 1;
-        summary.ownershipWarningCount += entry.ownershipWarnings.length;
-        return summary;
-    }, { total: 0, byLane: {}, byWorkKind: {}, ownershipWarningCount: 0 });
-}
-function createJob(compiled, task, options) {
-    const lane = task.lane ? compiled.lanesById.get(task.lane) : undefined;
-    const layer = task.layer ?? lane?.layer ?? compiled.manifest.policy.defaultLayer;
-    const compute = options.compute
-        ? readCompute(compiled, options.compute)
-        : resolveTaskCompute(compiled, task);
-    const evidencePrefix = lane?.evidencePrefix ? lane.evidencePrefix.replace(/\/?$/, '/') + slug(task.id) + '/' : undefined;
-    const allowedWrites = uniqueStrings([
-        ...(lane?.allowedWrites ?? []),
-        ...task.allowedWrites,
-        ...(evidencePrefix ? [evidencePrefix + '**'] : [])
-    ]);
-    const ownershipWarnings = task.targetRefs
-        .filter((file) => allowedWrites.length > 0 && !allowedWrites.some((glob) => matchesGlob(file, glob)))
-        .map((file) => `${file} is outside allowed write globs for ${lane?.id ?? 'unassigned'}`);
-    const capabilities = uniqueStrings([...(lane?.capabilities ?? []), ...task.capabilities]);
-    const resourceRequirements = mergeResourceRequirements(lane?.resourceRequirements, task.resourceRequirements, capabilities);
-    const ownershipRegions = mergeOwnershipRegions(lane?.ownershipRegions ?? [], task.ownershipRegions);
-    const ownedRegions = uniqueStrings([...task.ownedRegions, ...ownershipRegions.map((region) => region.id)]);
-    return {
-        id: `${lane?.id ?? 'unassigned'}-${slug(task.id)}`,
-        taskId: task.id,
-        title: task.title,
-        lane: lane?.id ?? 'unassigned',
-        ...(layer ? { layer } : {}),
-        compute,
-        status: 'planned',
-        priority: task.priority,
-        task,
-        allowedWrites,
-        sharedReadOnly: uniqueStrings([...(compiled.manifest.policy.sharedReadOnly ?? []), ...(lane?.sharedReadOnly ?? [])]),
-        neverEdit: uniqueStrings([...(compiled.manifest.policy.neverEditWithoutParent ?? []), ...(lane?.neverEdit ?? [])]),
-        ownershipRegions,
-        ownedRegions,
-        changedRegions: uniqueStrings(task.changedRegions),
-        capabilities,
-        ...(resourceRequirements ? { resourceRequirements } : {}),
-        ...(lane?.worktreePath ? { worktreePath: lane.worktreePath } : {}),
-        ...(evidencePrefix ? { evidencePrefix } : {}),
-        concurrencyKey: task.concurrencyKey ?? lane?.concurrencyKey ?? task.lane ?? compute.id,
-        ownershipWarnings,
-        verification: task.verification.length ? task.verification : (lane?.handoffCommands ?? []),
-        acceptance: [...task.acceptance],
-        dependsOn: resolveJobDependencies(task),
-        ...(task.budget ? { budget: task.budget } : {}),
-        review: task.review ?? normalizeReviewPolicy(),
-        tags: uniqueStrings([...task.tags, ...(lane?.tags ?? []), ...(layer ? [layer] : []), compute.id]),
-        ...(task.metadata ? { metadata: task.metadata } : {})
-    };
-}
-function resolveJobDependencies(task) {
-    return uniqueStrings([
-        ...(task.parentTaskId ? [task.parentTaskId] : []),
-        ...task.dependsOn
-    ]);
-}
-function resolveTaskCompute(compiled, task) {
-    if (task.compute)
-        return readCompute(compiled, task.compute);
-    const lane = task.lane ? compiled.lanesById.get(task.lane) : undefined;
-    if (lane?.compute)
-        return readCompute(compiled, lane.compute);
-    const layerId = task.layer ?? lane?.layer ?? compiled.manifest.policy.defaultLayer;
-    const layered = layerId ? resolveLayerCompute(compiled, layerId) : undefined;
-    return layered ?? readCompute(compiled, compiled.manifest.policy.defaultCompute);
-}
-function resolveLayerCompute(compiled, layerId) {
-    const layer = compiled.layersById.get(layerId);
-    if (!layer)
-        return undefined;
-    let childId = layer.id;
-    let parentId = layer.parentId;
-    while (parentId) {
-        const parent = compiled.layersById.get(parentId);
-        if (!parent)
-            break;
-        const selected = parent.childCompute[childId] ?? parent.childCompute['*'];
-        if (selected)
-            return readCompute(compiled, selected);
-        childId = parent.id;
-        parentId = parent.parentId;
-    }
-    const own = layer.compute ?? layer.defaultCompute;
-    return own ? readCompute(compiled, own) : undefined;
-}
-function readCompute(compiled, id) {
-    return compiled.computeById.get(id) ?? compiled.computeById.get(compiled.manifest.policy.defaultCompute) ?? compiled.manifest.compute[0];
-}
-function validateTasksForManifest(compiled, tasks, graph) {
-    const issues = [...compiled.validation.issues, ...(graph?.issues ?? [])];
-    const taskIds = new Set(tasks.map((task) => task.id));
-    for (const task of tasks) {
-        if (task.lane && !compiled.lanesById.has(task.lane)) {
-            addIssue(issues, 'missing-task-lane', 'error', `tasks.${task.id}.lane`, `Task lane is not declared: ${task.lane}`);
-        }
-        if (task.layer && !compiled.layersById.has(task.layer)) {
-            addIssue(issues, 'missing-task-layer', 'error', `tasks.${task.id}.layer`, `Task layer is not declared: ${task.layer}`);
-        }
-        if (task.compute && !compiled.computeById.has(task.compute)) {
-            addIssue(issues, 'missing-task-compute', 'error', `tasks.${task.id}.compute`, `Task compute is not declared: ${task.compute}`);
-        }
-        for (const dependency of task.dependsOn) {
-            if (!taskIds.has(dependency)) {
-                addIssue(issues, 'missing-task-dependency', 'warning', `tasks.${task.id}.dependsOn`, `Task dependency is not declared in the task set: ${dependency}`);
-            }
-        }
-        if (task.parentTaskId && !taskIds.has(task.parentTaskId)) {
-            addIssue(issues, 'missing-parent-task', 'warning', `tasks.${task.id}.parentTaskId`, `Task parent is not declared in the task set: ${task.parentTaskId}`);
-        }
-    }
-    return { valid: issues.every((issue) => issue.severity !== 'error'), issues };
-}
-function normalizeEvent(input) {
-    const at = input.at ?? Date.now();
-    return {
-        kind: FRONTIER_SWARM_EVENT_KIND,
-        version: FRONTIER_SWARM_EVENT_VERSION,
-        id: input.id ?? 'swarm-event:' + stableHash([input.type, input.runId, input.jobId, at, input.data]),
-        type: input.type,
-        ...(input.runId ? { runId: input.runId } : {}),
-        ...(input.jobId ? { jobId: input.jobId } : {}),
-        ...(input.taskId ? { taskId: input.taskId } : {}),
-        ...(input.lane ? { lane: input.lane } : {}),
-        ...(input.layer ? { layer: input.layer } : {}),
-        ...(input.compute ? { compute: input.compute } : {}),
-        at,
-        ...(input.message ? { message: input.message } : {}),
-        ...(input.data !== undefined ? { data: toJsonValue(input.data) } : {}),
-        ...(toJsonObject(input.metadata) ? { metadata: toJsonObject(input.metadata) } : {})
-    };
-}
-function normalizeQueueJob(input) {
-    return {
-        jobId: input.jobId,
-        ...(input.taskId ? { taskId: input.taskId } : {}),
-        ...(input.runId ? { runId: input.runId } : {}),
-        status: input.status ?? 'ready',
-        ...(input.lane ? { lane: input.lane } : {}),
-        ...(input.compute ? { compute: input.compute } : {}),
-        ...(input.concurrencyKey ? { concurrencyKey: input.concurrencyKey } : {}),
-        priority: input.priority ?? 100,
-        attempts: Math.max(0, Math.floor(input.attempts ?? 0)),
-        maxAttempts: Math.max(1, Math.floor(input.maxAttempts ?? 1)),
-        ...(input.availableAt !== undefined ? { availableAt: input.availableAt } : {}),
-        ...(input.lease ? { lease: cloneJsonValue(input.lease) } : {}),
-        ...(input.lastError ? { lastError: input.lastError } : {}),
-        ...(toJsonObject(input.metadata) ? { metadata: toJsonObject(input.metadata) } : {})
-    };
-}
-function queueJobsFromPlan(plan, run, leases) {
-    const resultsByJob = new Map((run?.results ?? []).map((result) => [result.jobId, result]));
-    const activeLeases = new Map(leases.filter((lease) => lease.status === 'active').map((lease) => [lease.jobId, lease]));
-    return plan.jobs.map((job) => {
-        const result = resultsByJob.get(job.id);
-        const lease = activeLeases.get(job.id);
-        const failed = result?.status === 'failed' || result?.exitCode !== undefined && result.exitCode !== 0;
-        const completed = result?.status === 'completed' || result?.status === 'verified';
-        const status = completed
-            ? 'completed'
-            : failed
-                ? 'failed'
-                : lease
-                    ? 'leased'
-                    : job.status === 'running'
-                        ? 'running'
-                        : 'ready';
-        return normalizeQueueJob({
-            jobId: job.id,
-            taskId: job.taskId,
-            runId: run?.id ?? plan.runId,
-            status,
-            lane: job.lane,
-            compute: job.compute.id,
-            concurrencyKey: job.concurrencyKey,
-            priority: job.priority,
-            attempts: result?.metadata && typeof result.metadata.attempts === 'number' ? result.metadata.attempts : undefined,
-            maxAttempts: job.budget?.maxRetries !== undefined ? job.budget.maxRetries + 1 : 1,
-            lease,
-            lastError: result?.error
-        });
-    });
-}
-function normalizeSemanticImportSummary(input) {
-    const object = toJsonObject(input);
-    if (!object)
-        return undefined;
-    const metadata = toJsonObject(object.metadata);
-    return {
-        total: nonNegativeCount(object.total),
-        selected: nonNegativeCount(object.selected),
-        eligible: nonNegativeCount(object.eligible),
-        omitted: nonNegativeCount(object.omitted),
-        imported: nonNegativeCount(object.imported),
-        skipped: nonNegativeCount(object.skipped),
-        errors: nonNegativeCount(object.errors),
-        sourceMapCount: nonNegativeCount(object.sourceMapCount),
-        sourceMapMappingCount: nonNegativeCount(object.sourceMapMappingCount),
-        lossCount: nonNegativeCount(object.lossCount),
-        lossesBySeverity: normalizeCounterRecord(object.lossesBySeverity),
-        semanticIndex: normalizeSemanticIndexSummary(object.semanticIndex),
-        semanticSidecars: normalizeSemanticSidecarSummary(object.semanticSidecars),
-        proofSpec: normalizeProofSpecSummary(object.proofSpec),
-        paradigmSemantics: normalizeParadigmSemanticsSummary(object.paradigmSemantics),
-        sourceProjections: normalizeSourceProjectionSummary(object.sourceProjections),
-        nativeCompiles: normalizeNativeCompileSummary(object.nativeCompiles),
-        readiness: normalizeCounterRecord(object.readiness),
-        ...(metadata ? { metadata } : {})
-    };
-}
-const paradigmSemanticsSummaryGroups = [
-    'bindingScopes',
-    'bindings',
-    'patterns',
-    'typeConstraints',
-    'evaluationModels',
-    'memoryLocations',
-    'effectRegions',
-    'controlRegions',
-    'logicPrograms',
-    'actorSystems',
-    'stackEffects',
-    'arrayShapes',
-    'numericKernels',
-    'dataflowNetworks',
-    'clockModels',
-    'objectModels',
-    'macroExpansions',
-    'reflectionBoundaries',
-    'loweringRecords'
-];
-function normalizeParadigmSemanticsSummary(input) {
-    const object = toJsonObject(input);
-    const counts = Object.fromEntries(paradigmSemanticsSummaryGroups.map((group) => [
-        group,
-        nonNegativeCount(object?.[group])
-    ]));
-    const total = nonNegativeCount(object?.total) || Object.values(counts).reduce((sum, count) => sum + count, 0);
-    const byGroup = normalizeCounterRecord(object?.byGroup);
-    const byKind = normalizeCounterRecord(object?.byKind);
-    const hasRuntimeSemantics = object?.hasRuntimeSemantics === true
-        || counts.evaluationModels > 0
-        || counts.memoryLocations > 0
-        || counts.effectRegions > 0
-        || counts.controlRegions > 0
-        || counts.actorSystems > 0
-        || counts.clockModels > 0;
-    const hasLogicSemantics = object?.hasLogicSemantics === true || counts.logicPrograms > 0;
-    const hasStackSemantics = object?.hasStackSemantics === true || counts.stackEffects > 0;
-    const hasArraySemantics = object?.hasArraySemantics === true || counts.arrayShapes > 0 || counts.numericKernels > 0;
-    const hasMacroOrReflection = object?.hasMacroOrReflection === true || counts.macroExpansions > 0 || counts.reflectionBoundaries > 0;
-    const hasLowering = object?.hasLowering === true || counts.loweringRecords > 0;
-    return {
-        total,
-        ids: uniqueStrings(stringArray(object?.ids)),
-        groups: uniqueStrings(stringArray(object?.groups)),
-        kinds: uniqueStrings(stringArray(object?.kinds)),
-        evidence: nonNegativeCount(object?.evidence),
-        ...counts,
-        byGroup,
-        byKind,
-        hasRuntimeSemantics,
-        hasLogicSemantics,
-        hasStackSemantics,
-        hasArraySemantics,
-        hasMacroOrReflection,
-        hasLowering,
-        empty: object?.empty === true || total === 0
-    };
-}
-function normalizeProofSpecSummary(input) {
-    const object = toJsonObject(input);
-    const total = nonNegativeCount(object?.total);
-    return {
-        total,
-        ids: uniqueStrings(stringArray(object?.ids)),
-        contracts: nonNegativeCount(object?.contracts),
-        refinements: nonNegativeCount(object?.refinements),
-        invariants: nonNegativeCount(object?.invariants),
-        termination: nonNegativeCount(object?.termination),
-        temporal: nonNegativeCount(object?.temporal),
-        obligations: nonNegativeCount(object?.obligations),
-        artifacts: nonNegativeCount(object?.artifacts),
-        assumptions: nonNegativeCount(object?.assumptions),
-        evidence: nonNegativeCount(object?.evidence),
-        discharged: nonNegativeCount(object?.discharged),
-        failed: nonNegativeCount(object?.failed),
-        open: nonNegativeCount(object?.open),
-        unknown: nonNegativeCount(object?.unknown),
-        stale: nonNegativeCount(object?.stale),
-        assumed: nonNegativeCount(object?.assumed),
-        contractKinds: uniqueStrings(stringArray(object?.contractKinds)),
-        artifactKinds: uniqueStrings(stringArray(object?.artifactKinds)),
-        byStatus: normalizeCounterRecord(object?.byStatus),
-        byContractKind: normalizeCounterRecord(object?.byContractKind),
-        byArtifactKind: normalizeCounterRecord(object?.byArtifactKind),
-        empty: object?.empty === true || total === 0
-    };
-}
-function normalizeSemanticIndexSummary(input) {
-    const object = toJsonObject(input);
-    return {
-        documents: nonNegativeCount(object?.documents),
-        symbols: nonNegativeCount(object?.symbols),
-        occurrences: nonNegativeCount(object?.occurrences),
-        relations: nonNegativeCount(object?.relations),
-        facts: nonNegativeCount(object?.facts)
-    };
-}
-function normalizeSemanticSidecarSummary(input) {
-    const object = toJsonObject(input);
-    return {
-        total: nonNegativeCount(object?.total),
-        symbols: nonNegativeCount(object?.symbols),
-        ownershipRegions: nonNegativeCount(object?.ownershipRegions),
-        patchHints: nonNegativeCount(object?.patchHints),
-        empty: nonNegativeCount(object?.empty)
-    };
-}
-function normalizeSourceProjectionSummary(input) {
-    const object = toJsonObject(input);
-    return {
-        total: nonNegativeCount(object?.total),
-        preserved: nonNegativeCount(object?.preserved),
-        stubs: nonNegativeCount(object?.stubs),
-        ready: nonNegativeCount(object?.ready),
-        needsReview: nonNegativeCount(object?.needsReview),
-        blocked: nonNegativeCount(object?.blocked)
-    };
-}
-function normalizeNativeCompileSummary(input) {
-    const object = toJsonObject(input);
-    return {
-        total: nonNegativeCount(object?.total),
-        emitted: nonNegativeCount(object?.emitted),
-        preserved: nonNegativeCount(object?.preserved),
-        targetStubs: nonNegativeCount(object?.targetStubs),
-        ready: nonNegativeCount(object?.ready),
-        needsReview: nonNegativeCount(object?.needsReview),
-        blocked: nonNegativeCount(object?.blocked)
-    };
-}
-function normalizeCounterRecord(input) {
-    const object = toJsonObject(input);
-    if (!object)
-        return {};
-    const entries = Object.entries(object)
-        .map(([key, value]) => [key, nonNegativeCount(value)])
-        .filter(([, value]) => value > 0)
-        .sort(([left], [right]) => left.localeCompare(right));
-    return Object.fromEntries(entries);
-}
-function nonNegativeCount(value) {
-    const number = typeof value === 'number' ? value : Number(value);
-    return Number.isFinite(number) && number > 0 ? Math.floor(number) : 0;
-}
-function normalizeResult(input) {
-    const startedAt = input.startedAt;
-    const finishedAt = input.finishedAt;
-    const status = input.status ?? (input.exitCode === 0 || input.exitCode === undefined ? 'completed' : 'failed');
-    const inputMetadata = toJsonObject(input.metadata);
-    const semanticImport = normalizeSemanticImportSummary(input.semanticImport ?? inputMetadata?.semanticImport);
-    return {
-        jobId: input.jobId,
-        status,
-        mergeReadiness: classifySwarmMergeReadiness({ ...input, status }),
-        ...(startedAt !== undefined ? { startedAt } : {}),
-        ...(finishedAt !== undefined ? { finishedAt } : {}),
-        ...(startedAt !== undefined && finishedAt !== undefined ? { durationMs: Math.max(0, finishedAt - startedAt) } : {}),
-        ...(input.exitCode !== undefined ? { exitCode: input.exitCode } : {}),
-        ...(input.signal ? { signal: input.signal } : {}),
-        changedPaths: uniqueStrings(input.changedPaths ?? []),
-        changedRegions: uniqueStrings(input.changedRegions ?? []),
-        ownershipViolations: uniqueStrings(input.ownershipViolations ?? []),
-        evidencePaths: uniqueStrings(input.evidencePaths ?? []),
-        ...(input.patchPath ? { patchPath: input.patchPath } : {}),
-        queueItemIds: uniqueStrings(input.queueItemIds ?? []),
-        riskLevel: input.riskLevel ?? 'unknown',
-        mergeDisposition: input.mergeDisposition ?? classifySwarmMergeDisposition({ ...input, status }),
-        verification: (input.verification ?? []).map(normalizeVerificationResult),
-        ...(semanticImport ? { semanticImport } : {}),
-        ...(input.lastMessage ? { lastMessage: input.lastMessage } : {}),
-        ...(input.error !== undefined ? { error: stringifyError(input.error) } : {}),
-        ...(inputMetadata ? { metadata: inputMetadata } : {})
-    };
-}
-function isSwarmJobResult(value) {
-    return Array.isArray(value.changedPaths)
-        && Array.isArray(value.changedRegions)
-        && Array.isArray(value.verification)
-        && Array.isArray(value.queueItemIds)
-        && typeof value.riskLevel === 'string'
-        && typeof value.mergeDisposition === 'string';
-}
-function mergeBundleReasons(result, disposition, staleAgainstHead) {
-    const reasons = [];
-    if (staleAgainstHead)
-        reasons.push('stale-against-head');
-    if (result.status === 'blocked')
-        reasons.push('blocked');
-    if (result.status === 'failed')
-        reasons.push('failed');
-    if (result.ownershipViolations.length)
-        reasons.push('ownership-violations');
-    if (result.verification.some((entry) => entry.required !== false && entry.status !== 0))
-        reasons.push('failed-verification');
-    if (disposition === 'needs-port')
-        reasons.push('needs-human-port');
-    if (disposition === 'rejected')
-        reasons.push('rejected');
-    return uniqueStrings(reasons);
-}
-function inferMergeRisk(result, disposition) {
-    if (disposition === 'discovery-only')
-        return 'low';
-    if (disposition === 'rejected' || disposition === 'blocked' || disposition === 'stale-against-head')
-        return 'high';
-    if (result.changedPaths.length <= 2 && result.ownershipViolations.length === 0)
-        return 'low';
-    if (result.changedPaths.length <= 8)
-        return 'medium';
-    return 'high';
-}
-function normalizeVerificationResult(input) {
-    return {
-        name: input.name ?? ((input.command ?? []).join(' ') || 'verification'),
-        command: [...(input.command ?? [])],
-        ...(input.status !== undefined ? { status: input.status } : {}),
-        ...(input.durationMs !== undefined ? { durationMs: input.durationMs } : {}),
-        stdoutTail: [...(input.stdoutTail ?? [])],
-        stderrTail: [...(input.stderrTail ?? [])],
-        required: input.required ?? true,
-        ...(toJsonObject(input.metadata) ? { metadata: toJsonObject(input.metadata) } : {})
-    };
-}
-function summarizeJobs(jobs) {
-    return {
-        computeCount: new Set(jobs.map((job) => job.compute.id)).size,
-        layerCount: new Set(jobs.map((job) => job.layer).filter((layer) => !!layer)).size,
-        laneCount: new Set(jobs.map((job) => job.lane)).size,
-        taskCount: jobs.length,
-        jobCount: jobs.length,
-        ownershipViolationCount: jobs.reduce((total, job) => total + job.ownershipWarnings.length, 0)
-    };
-}
-function summarizeRun(jobs, results) {
-    const ownershipViolationCount = results.reduce((total, result) => total + result.ownershipViolations.length, 0);
-    return {
-        ...summarizeJobs(jobs),
-        completedCount: results.filter((result) => result.status === 'completed' || result.status === 'verified').length,
-        blockedCount: results.filter((result) => result.status === 'blocked').length,
-        failedCount: results.filter((result) => result.status === 'failed' || result.exitCode !== undefined && result.exitCode !== 0).length,
-        ownershipViolationCount
-    };
-}
-function taskLayer(manifest, task) {
-    if (task.layer)
-        return task.layer;
-    const lane = task.lane ? manifest.lanes.find((entry) => entry.id === task.lane) : undefined;
-    return lane?.layer ?? manifest.policy.defaultLayer;
-}
-function searchableTask(task) {
-    return [
-        task.id,
-        task.title,
-        task.objective,
-        task.description,
-        task.workKind,
-        task.status,
-        task.lane,
-        task.layer,
-        task.compute,
-        ...task.sourceRefs,
-        ...task.targetRefs,
-        ...task.tags
-    ].filter(Boolean).join(' ').toLowerCase();
-}
-function addIssue(issues, code, severity, path, message) {
-    issues.push({ code, severity, path, message });
-}
-function hasLayerCycle(layerId, layers) {
-    const byId = new Map(layers.map((layer) => [layer.id, layer]));
-    const seen = new Set();
-    let cursor = layerId;
-    while (cursor) {
-        if (seen.has(cursor))
-            return true;
-        seen.add(cursor);
-        cursor = byId.get(cursor)?.parentId;
-    }
-    return false;
-}
-function isSwarmManifest(value) {
-    return !!value && typeof value === 'object' && value.kind === FRONTIER_SWARM_MANIFEST_KIND;
-}
-function isSwarmTask(value) {
-    return !!value && typeof value === 'object' && value.kind === FRONTIER_SWARM_TASK_KIND;
-}
-function isSwarmEvent(value) {
-    return !!value && typeof value === 'object' && value.kind === FRONTIER_SWARM_EVENT_KIND;
-}
-function readLaneId(value) {
-    return typeof value === 'string' ? value : value.id;
-}
-function joinPathParts(...parts) {
-    const first = parts[0] ? String(parts[0]) : '';
-    const prefix = first.startsWith('/') ? '/' : '';
-    return prefix + parts
-        .map((part, index) => String(part).replace(index === 0 ? /\/+$/g : /^\/+|\/+$/g, ''))
-        .filter(Boolean)
-        .join('/');
-}
-function normalizeId(value, label) {
-    const id = String(value || '').trim();
-    if (!id)
-        throw new Error(`Missing ${label}`);
-    return id;
-}
-function titleFromId(id) {
-    const parts = String(id).split(/[.:/_-]+/).filter(Boolean);
-    return parts.length ? parts.map((part) => part[0]?.toUpperCase() + part.slice(1)).join(' ') : String(id);
-}
-function slug(value) {
-    return String(value).toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '') || 'item';
-}
-function uniqueStrings(values) {
-    return Array.from(new Set(values.map((value) => String(value ?? '').trim()).filter(Boolean)));
-}
-function stringArray(value) {
-    return Array.isArray(value) ? value.map((entry) => String(entry ?? '').trim()).filter(Boolean) : [];
-}
-function positiveNumber(value) {
-    return typeof value === 'number' && Number.isFinite(value) && value > 0;
-}
-function toJsonObject(value) {
-    if (!value || typeof value !== 'object' || Array.isArray(value))
-        return undefined;
-    return cloneJsonValue(value);
-}
-function toJsonValue(value) {
-    if (value === undefined)
-        return null;
-    return cloneJsonValue(value);
-}
-function cloneJsonValue(value) {
-    return JSON.parse(JSON.stringify(value));
-}
-function stringifyError(error) {
-    return error instanceof Error ? error.message : String(error);
-}
-function stableHash(value) {
-    const text = stableStringify(value);
-    let hash = 2166136261;
-    for (let index = 0; index < text.length; index += 1) {
-        hash ^= text.charCodeAt(index);
-        hash = Math.imul(hash, 16777619);
-    }
-    return 'fnv1a32:' + (hash >>> 0).toString(16).padStart(8, '0');
-}
-function stableStringify(value) {
-    if (value === null || typeof value !== 'object')
-        return JSON.stringify(value);
-    if (Array.isArray(value))
-        return '[' + value.map(stableStringify).join(',') + ']';
-    const object = value;
-    return '{' + Object.keys(object).sort().map((key) => JSON.stringify(key) + ':' + stableStringify(object[key])).join(',') + '}';
-}
+export * from './constants.js';
+export { compileSwarm, createSwarmManifest, defineSwarmManifest, defineSwarmTasks, validateSwarmManifest } from './manifest.js';
+export * from './plan.js';
+export * from './scheduler.js';
+export * from './leases.js';
+export { completeSwarmJob, createSwarmEventStream, createSwarmMailbox, createSwarmRun, recordSwarmEvent, routeSwarmEventToMailboxes } from './run-records.js';
+export { matchesGlob } from './internal.js';
+export { classifySwarmMergeDisposition, classifySwarmMergeReadiness } from './merge-bundles.js';
+export { createSwarmMergeAdmission } from './merge-admission.js';
+export { createSwarmMergeIndex } from './merge-index.js';
+export { createSwarmReviewerLanePlan } from './merge-review.js';
+export { deriveSwarmQueueStatus } from './queue-overlays.js';
+export { createSwarmBlackboard, querySwarmBlackboard } from './blackboard.js';
+export { createSwarmFixtureCatalog } from './fixtures.js';
+export { createSwarmProgressModel } from './progress.js';
+export { createSwarmAutoReviewReport } from './auto-review.js';
+export { createSwarmUsageGovernor, checkSwarmUsageGovernor } from './usage-governor.js';
+export { createSwarmAdaptiveLoadPlan, createSwarmScheduleInputFromAdaptiveLoadPlan } from './adaptive-load.js';
+export { createSwarmCoordinatorDashboard, querySwarmCoordinatorDashboard } from './coordinator-dashboard.js';
+export * from './ownership-runtime.js';
+export * from './run-store-shards-runtime.js';
+export * from './merge-wrappers.js';
+export * from './context-pack-runtime.js';
+export * from './oracle-runtime.js';
+export * from './trace-runtime.js';
+export * from './debug-runtime.js';
+export * from './instrumentation-runtime.js';
+export * from './evidence-index.js';
+export * from './reference-oracle-runtime.js';
+export * from './artifact-routing-runtime.js';
+export * from './rebase-report.js';
+export * from './patch-stack-runtime.js';
+export * from './proof-runtime.js';
+export * from './merge-plans-runtime.js';
 //# sourceMappingURL=index.js.map