@shapeshift-labs/frontier-swarm 0.5.4 → 0.5.6

package/dist/index.js

@@ -88,6 +88,10 @@ 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';
@@ -1606,6 +1610,235 @@ export function createSwarmPatchStackPlan(input) {
         ...(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);
@@ -2121,6 +2354,577 @@ function schedulerPriorityForReason(reason) {
         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 (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 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;
+}
+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 } : {}),
@@ -2637,6 +3441,172 @@ function patchStackKey(entry) {
     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;