@shapeshift-labs/frontier-swarm-codex 0.5.31 → 0.5.33

package/dist/index.js

@@ -10,7 +10,7 @@ import { spawn } from 'node:child_process';
 import fs from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
-import { FRONTIER_SWARM_DEFAULT_MODEL, FRONTIER_SWARM_DEFAULT_REASONING_EFFORT, checkSwarmOwnership, completeSwarmJob, FRONTIER_SWARM_MERGE_BUNDLE_KIND, FRONTIER_SWARM_MERGE_BUNDLE_VERSION, createSwarmMergeBundle, createSwarmMergeIndex, createSwarmQueueOverlay, matchesGlob, createSwarmEventStream, createSwarmLeases, createSwarmPlan, createSwarmProof, createSwarmRun, createSwarmSchedule, recordSwarmEvent, routeSwarmEventToMailboxes } from '@shapeshift-labs/frontier-swarm';
+import { FRONTIER_SWARM_DEFAULT_MODEL, FRONTIER_SWARM_DEFAULT_REASONING_EFFORT, checkSwarmOwnership, completeSwarmJob, createSwarmCoordinatorDashboard, createSwarmAdaptiveLoadPlan, createSwarmEvidenceIndex, createSwarmMergeAdmission, FRONTIER_SWARM_MERGE_BUNDLE_KIND, FRONTIER_SWARM_MERGE_BUNDLE_VERSION, createSwarmMergeBundle, createSwarmMergeIndex, createSwarmQueueOverlay, matchesGlob, createSwarmEventStream, createSwarmLeases, createSwarmPlan, createSwarmProof, createSwarmRun, createSwarmSchedule, createSwarmScheduleInputFromAdaptiveLoadPlan, recordSwarmEvent, routeSwarmEventToMailboxes } from '@shapeshift-labs/frontier-swarm';
 export const FRONTIER_SWARM_CODEX_DEFAULT_MODEL = FRONTIER_SWARM_DEFAULT_MODEL;
 export const FRONTIER_SWARM_CODEX_DEFAULT_REASONING_EFFORT = FRONTIER_SWARM_DEFAULT_REASONING_EFFORT;
 export const FRONTIER_SWARM_CODEX_WORKSPACE_MANIFEST_KIND = 'frontier.swarm-codex.workspace-manifest';
@@ -27,6 +27,12 @@ export const FRONTIER_SWARM_CODEX_PATCH_SCORE_KIND = 'frontier.swarm-codex.patch
 export const FRONTIER_SWARM_CODEX_PATCH_SCORE_VERSION = 1;
 export const FRONTIER_SWARM_CODEX_SEMANTIC_IMPORT_KIND = 'frontier.swarm-codex.semantic-imports';
 export const FRONTIER_SWARM_CODEX_SEMANTIC_IMPORT_VERSION = 1;
+export const FRONTIER_SWARM_CODEX_JOB_EVIDENCE_KIND = 'frontier.swarm-codex.job-evidence';
+export const FRONTIER_SWARM_CODEX_JOB_EVIDENCE_VERSION = 1;
+export const FRONTIER_SWARM_CODEX_PATCH_INTENT_KIND = 'frontier.swarm-codex.patch-intent';
+export const FRONTIER_SWARM_CODEX_PATCH_INTENT_VERSION = 1;
+export const FRONTIER_SWARM_CODEX_COMPACT_DASHBOARD_KIND = 'frontier.swarm-codex.compact-dashboard';
+export const FRONTIER_SWARM_CODEX_COMPACT_DASHBOARD_VERSION = 1;
 const DEFAULT_WORKSPACE_INCLUDES = ['AGENTS.md', 'package.json', 'package-lock.json', 'pnpm-lock.yaml', 'yarn.lock', 'config'];
 const DEFAULT_WORKSPACE_EXCLUDES = [
     '.git',
@@ -133,7 +139,12 @@ export async function runCodexSwarm(plan, options) {
     run = recordSwarmEvent(run, startedEvent);
     await appendFileSwarmEvent(eventStream, startedEvent);
     const runOptions = { ...options, eventStream, pidManifestPath };
-    const results = await runScheduledJobPool(plan, Math.max(1, options.maxConcurrency ?? 1), (job, lease) => runCodexJob(job, runOptions, outDir, lease));
+    const results = await runScheduledJobPool(plan, {
+        concurrency: Math.max(1, options.maxConcurrency ?? 1),
+        adaptive: options.adaptiveConcurrency,
+        outDir,
+        eventStream
+    }, (job, lease) => runCodexJob(job, runOptions, outDir, lease));
     for (const result of results) {
         const job = plan.jobs.find((entry) => entry.id === result.jobId);
         if (job) {
@@ -229,8 +240,12 @@ export async function runCodexJob(job, options, outDir, lease) {
             paths,
             resourceAllocation,
             env: resourceAllocation.env,
-            timeoutMs: job.compute.timeoutMs ?? options.jobTimeoutMs ?? 7200000
+            timeoutMs: job.compute.timeoutMs ?? options.jobTimeoutMs ?? 7200000,
+            compactLogs: normalizeCompactLogOptions(options.compactLogs)
         });
+    const logSummary = execution.logSummary ?? createEmptyCodexLogSummary(paths);
+    if (!execution.logSummary)
+        await fs.writeFile(paths.logSummaryPath, JSON.stringify(logSummary, null, 2) + '\n');
     const collected = execution.changedPaths
         ? filterWorkspaceChangedPaths(execution.changedPaths, workspacePlan)
         : options.collectGitStatus === false
@@ -259,13 +274,17 @@ export async function runCodexJob(job, options, outDir, lease) {
         options: options.semanticImport
     });
     const handoffArtifacts = await discoverCodexHandoffArtifacts({ root: paths.jobDir });
+    const evidenceSummaryPath = path.join(paths.evidenceDir, 'evidence.json');
     const evidencePaths = uniqueStrings([
         paths.evidenceDir,
+        evidenceSummaryPath,
         paths.resourceAllocationPath,
         paths.workspaceProofPath,
         paths.mergeBundlePath,
         ...(patchPath ? [patchPath] : []),
         ...(semanticImport ? [semanticImport.path] : []),
+        paths.patchIntentPath,
+        paths.logSummaryPath,
         ...handoffArtifacts.map((artifact) => artifact.path)
     ]);
     const result = {
@@ -288,6 +307,7 @@ export async function runCodexJob(job, options, outDir, lease) {
         metadata: {
             ...(lease ? { leaseId: lease.id, leaseToken: lease.token, fencingToken: lease.fencingToken } : {}),
             resourceAllocation,
+            logSummary,
             ...(semanticImport ? { semanticImport: semanticImport.sidecar.summary } : {}),
             codexHandoffArtifacts: handoffArtifacts
         }
@@ -299,8 +319,11 @@ export async function runCodexJob(job, options, outDir, lease) {
         ...(patchPath ? { patchPath } : {}),
         evidencePaths: uniqueStrings([
             paths.evidenceDir,
+            evidenceSummaryPath,
             paths.resourceAllocationPath,
             paths.workspaceProofPath,
+            paths.patchIntentPath,
+            paths.logSummaryPath,
             ...(semanticImport ? [semanticImport.path] : []),
             ...handoffArtifacts.map((artifact) => artifact.path)
         ]),
@@ -309,13 +332,174 @@ export async function runCodexJob(job, options, outDir, lease) {
         ...(semanticImport ? { metadata: { semanticImport: semanticImport.sidecar.summary } } : {})
     });
     await fs.writeFile(paths.mergeBundlePath, JSON.stringify(mergeBundle, null, 2) + '\n');
+    await writeCodexPatchIntent({
+        file: paths.patchIntentPath,
+        job,
+        result,
+        mergeBundle,
+        patchPath,
+        semanticImport: semanticImport?.sidecar,
+        semanticImportExpected: options.semanticImportExpected ?? semanticImportEnabled(options.semanticImport),
+        evidencePaths
+    });
+    await writeCodexJobEvidenceSummary({
+        file: evidenceSummaryPath,
+        job,
+        result,
+        mergeBundle,
+        mergeBundlePath: paths.mergeBundlePath,
+        patchPath,
+        patchIntentPath: paths.patchIntentPath,
+        logSummary,
+        semanticImportPath: semanticImport?.path,
+        semanticImport: semanticImport?.sidecar,
+        handoffArtifacts
+    });
     return result;
 }
+async function writeCodexJobEvidenceSummary(input) {
+    const patchHunks = input.patchPath ? await readPatchHunks(input.patchPath) : [];
+    const sourceCitations = createCodexEvidenceSourceCitations(input.mergeBundle, input.semanticImport);
+    const evidence = {
+        kind: FRONTIER_SWARM_CODEX_JOB_EVIDENCE_KIND,
+        version: FRONTIER_SWARM_CODEX_JOB_EVIDENCE_VERSION,
+        generatedAt: Date.now(),
+        jobId: input.job.id,
+        taskId: input.job.taskId,
+        lane: input.job.lane,
+        status: input.result.status ?? 'unknown',
+        mergeReadiness: input.mergeBundle.mergeReadiness,
+        disposition: input.mergeBundle.disposition,
+        riskLevel: input.mergeBundle.riskLevel,
+        changedPaths: [...input.mergeBundle.changedPaths],
+        changedRegions: [...input.mergeBundle.changedRegions],
+        ownershipViolations: [...input.mergeBundle.ownershipViolations],
+        ...(input.patchPath ? { patchPath: input.patchPath } : {}),
+        mergeBundlePath: input.mergeBundlePath,
+        ...(input.patchIntentPath ? { patchIntentPath: input.patchIntentPath } : {}),
+        ...(input.semanticImportPath ? { semanticImportPath: input.semanticImportPath } : {}),
+        evidencePaths: uniqueStrings(input.mergeBundle.evidencePaths),
+        handoffArtifacts: input.handoffArtifacts.map((artifact) => ({ ...artifact })),
+        commands: {
+            passed: input.mergeBundle.commandsPassed.map((command) => ({
+                name: command.name,
+                command: [...command.command],
+                ...(command.status !== undefined ? { status: command.status } : {})
+            })),
+            failed: input.mergeBundle.commandsFailed.map((command) => ({
+                name: command.name,
+                command: [...command.command],
+                ...(command.status !== undefined ? { status: command.status } : {})
+            }))
+        },
+        patchHunks,
+        readyToPortHunkCount: input.mergeBundle.disposition === 'needs-port' || input.mergeBundle.disposition === 'auto-mergeable' ? patchHunks.length : 0,
+        ...(input.semanticImport ? { semanticImport: input.semanticImport.summary } : {}),
+        sourceCitations,
+        metadata: {
+            autoMergeable: input.mergeBundle.autoMergeable,
+            staleAgainstHead: input.mergeBundle.staleAgainstHead,
+            ...(input.logSummary ? { logSummary: input.logSummary } : {}),
+            reasons: input.mergeBundle.reasons
+        }
+    };
+    await fs.writeFile(input.file, JSON.stringify(evidence, null, 2) + '\n');
+}
+async function writeCodexPatchIntent(input) {
+    const patchHunks = input.patchPath ? await readPatchHunks(input.patchPath) : [];
+    const semanticImportQuality = summarizeCodexSemanticImportQuality(input.semanticImport?.summary, input.semanticImportExpected);
+    const warnings = uniqueStrings([
+        ...semanticImportQuality.warnings,
+        ...(input.mergeBundle.staleAgainstHead ? ['stale against coordinator head'] : []),
+        ...(input.mergeBundle.ownershipViolations.length ? ['ownership violations present'] : []),
+        ...(input.mergeBundle.commandsFailed.length ? ['verification commands failed'] : []),
+        ...(input.mergeBundle.disposition === 'discovery-only' ? ['discovery-only output'] : [])
+    ]);
+    const intent = {
+        kind: FRONTIER_SWARM_CODEX_PATCH_INTENT_KIND,
+        version: FRONTIER_SWARM_CODEX_PATCH_INTENT_VERSION,
+        generatedAt: Date.now(),
+        jobId: input.job.id,
+        taskId: input.job.taskId,
+        lane: input.job.lane,
+        changedPaths: [...input.mergeBundle.changedPaths],
+        changedRegions: [...input.mergeBundle.changedRegions],
+        intent: input.mergeBundle.changedPaths.length
+            ? `Patch ${input.mergeBundle.changedPaths.slice(0, 5).join(', ')}`
+            : 'No source patch produced',
+        why: input.result.lastMessage ? firstNonEmptyLine(input.result.lastMessage) ?? input.job.task.objective : input.job.task.objective,
+        riskLevel: input.mergeBundle.riskLevel,
+        mergeReadiness: input.mergeBundle.mergeReadiness,
+        disposition: input.mergeBundle.disposition,
+        safeToPortManually: input.mergeBundle.commandsFailed.length === 0
+            && input.mergeBundle.ownershipViolations.length === 0
+            && !input.mergeBundle.staleAgainstHead
+            && input.mergeBundle.disposition !== 'rejected'
+            && input.mergeBundle.disposition !== 'blocked',
+        verification: input.mergeBundle.commandsPassed.concat(input.mergeBundle.commandsFailed).map((command) => ({
+            name: command.name,
+            command: [...command.command],
+            ...(command.status !== undefined ? { status: command.status } : {}),
+            required: command.required
+        })),
+        evidencePaths: uniqueStrings(input.evidencePaths),
+        semanticImportQuality,
+        patchHunks,
+        warnings
+    };
+    await fs.writeFile(input.file, JSON.stringify(intent, null, 2) + '\n');
+}
+async function readPatchHunks(file) {
+    const text = await fs.readFile(file, 'utf8').catch(() => '');
+    if (!text.trim())
+        return [];
+    const hunks = [];
+    let currentFile;
+    for (const line of text.split(/\r?\n/)) {
+        if (line.startsWith('+++ ')) {
+            currentFile = line.slice(4).replace(/^b\//, '').trim();
+            continue;
+        }
+        if (!line.startsWith('@@'))
+            continue;
+        const match = /^@@\s+-(\d+)(?:,(\d+))?\s+\+(\d+)(?:,(\d+))?/.exec(line);
+        hunks.push({
+            ...(currentFile ? { file: currentFile } : {}),
+            header: line,
+            ...(match ? {
+                oldStart: Number(match[1]),
+                oldLines: Number(match[2] ?? '1'),
+                newStart: Number(match[3]),
+                newLines: Number(match[4] ?? '1')
+            } : {})
+        });
+    }
+    return hunks;
+}
+function createCodexEvidenceSourceCitations(bundle, semanticImport) {
+    const citations = [
+        ...bundle.changedPaths.map((file) => ({ path: file, kind: 'changed-source' })),
+        ...(semanticImport?.records ?? []).map((record) => ({
+            path: record.path,
+            kind: 'semantic-import',
+            ...(record.language ? { language: record.language } : {}),
+            ...(record.universalAstHash ? { hash: record.universalAstHash } : {})
+        }))
+    ];
+    const seen = new Set();
+    return citations.filter((citation) => {
+        const key = `${citation.kind}:${citation.path}:${citation.language ?? ''}:${citation.hash ?? ''}`;
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    });
+}
 async function createCodexSemanticImportSidecar(input) {
     const options = normalizeSemanticImportOptions(input.options);
     if (!options)
         return undefined;
-    const selection = selectSemanticImportPaths(input.changedPaths, options);
+    const selection = selectSemanticImportPaths(semanticImportCandidatePaths(input.job, input.changedPaths), options);
     const selected = selection.selected;
     const records = [];
     const importPath = path.join(input.evidenceDir, 'semantic-imports.json');
@@ -648,6 +832,19 @@ export function renderCodexPrompt(job, input) {
 export async function spawnCodexExecutor(input) {
     await fs.writeFile(input.paths.eventsPath, '');
     await fs.writeFile(input.paths.stderrPath, '');
+    const logOptions = normalizeCompactLogOptions(input.compactLogs);
+    const eventLimit = logOptions.enabled === false ? Number.POSITIVE_INFINITY : logOptions.maxEventBytes ?? 1_000_000;
+    const stderrLimit = logOptions.enabled === false ? Number.POSITIVE_INFINITY : logOptions.maxStderrBytes ?? 256_000;
+    const logSummary = {
+        eventsPath: input.paths.eventsPath,
+        stderrPath: input.paths.stderrPath,
+        eventBytes: 0,
+        stderrBytes: 0,
+        eventBytesWritten: 0,
+        stderrBytesWritten: 0,
+        eventBytesTruncated: 0,
+        stderrBytesTruncated: 0
+    };
     return new Promise((resolve) => {
         const child = spawn(input.codexPath, input.args, {
             cwd: input.cwd,
@@ -664,23 +861,52 @@ export async function spawnCodexExecutor(input) {
             }).catch(() => { });
         }
         const timer = setTimeout(() => child.kill('SIGTERM'), input.timeoutMs);
-        child.stdout.on('data', (chunk) => fs.appendFile(input.paths.eventsPath, chunk).catch(() => { }));
-        child.stderr.on('data', (chunk) => fs.appendFile(input.paths.stderrPath, chunk).catch(() => { }));
+        child.stdout.on('data', (chunk) => appendLimitedLogChunk(input.paths.eventsPath, chunk, eventLimit, logSummary, 'event').catch(() => { }));
+        child.stderr.on('data', (chunk) => appendLimitedLogChunk(input.paths.stderrPath, chunk, stderrLimit, logSummary, 'stderr').catch(() => { }));
         child.stdin.end(input.prompt);
         child.on('close', async (code, signal) => {
             clearTimeout(timer);
+            await fs.writeFile(input.paths.logSummaryPath, JSON.stringify(logSummary, null, 2) + '\n').catch(() => { });
             resolve({
                 exitCode: code ?? 1,
                 ...(signal ? { signal } : {}),
-                lastMessage: await readOptionalText(input.paths.lastMessagePath)
+                lastMessage: await readOptionalText(input.paths.lastMessagePath),
+                logSummary
             });
         });
         child.on('error', (error) => {
             clearTimeout(timer);
-            resolve({ exitCode: 1, error });
+            fs.writeFile(input.paths.logSummaryPath, JSON.stringify(logSummary, null, 2) + '\n').catch(() => { });
+            resolve({ exitCode: 1, logSummary, error });
         });
     });
 }
+async function appendLimitedLogChunk(file, chunk, limit, summary, kind) {
+    const bytes = chunk.byteLength;
+    if (kind === 'event')
+        summary.eventBytes += bytes;
+    else
+        summary.stderrBytes += bytes;
+    const written = kind === 'event' ? summary.eventBytesWritten : summary.stderrBytesWritten;
+    const available = Math.max(0, limit - written);
+    if (available <= 0) {
+        if (kind === 'event')
+            summary.eventBytesTruncated += bytes;
+        else
+            summary.stderrBytesTruncated += bytes;
+        return;
+    }
+    const slice = bytes > available ? chunk.subarray(0, available) : chunk;
+    await fs.appendFile(file, slice);
+    if (kind === 'event') {
+        summary.eventBytesWritten += slice.byteLength;
+        summary.eventBytesTruncated += bytes - slice.byteLength;
+    }
+    else {
+        summary.stderrBytesWritten += slice.byteLength;
+        summary.stderrBytesTruncated += bytes - slice.byteLength;
+    }
+}
 async function createJobPaths(outDir, job, options) {
     const jobDir = path.join(outDir, job.id);
     const paths = {
@@ -694,6 +920,8 @@ async function createJobPaths(outDir, job, options) {
         workspaceProofPath: path.join(jobDir, 'evidence', 'workspace-proof.json'),
         patchPath: path.join(jobDir, 'evidence', 'changes.patch'),
         mergeBundlePath: path.join(jobDir, 'evidence', 'merge.json'),
+        patchIntentPath: path.join(jobDir, 'evidence', 'patch-intent.json'),
+        logSummaryPath: path.join(jobDir, 'evidence', 'log-summary.json'),
         pidManifestPath: path.resolve(options.cwd ?? process.cwd(), options.pidManifestPath ?? path.join(outDir, 'pids.json'))
     };
     await fs.mkdir(paths.evidenceDir, { recursive: true });
@@ -895,38 +1123,19 @@ export async function appendFileSwarmEvent(stream, event) {
     }));
 }
 export async function writeSwarmCoordinatorSnapshot(file, input) {
-    const byLane = input.run.jobs.reduce((acc, job) => {
-        const current = acc[job.lane] ?? { total: 0, completed: 0, failed: 0, blocked: 0 };
-        current.total += 1;
-        const result = input.run.results.find((entry) => entry.jobId === job.id);
-        if (result?.status === 'completed' || result?.status === 'verified')
-            current.completed += 1;
-        else if (result?.status === 'failed')
-            current.failed += 1;
-        else if (result?.status === 'blocked')
-            current.blocked += 1;
-        acc[job.lane] = current;
-        return acc;
-    }, {});
-    const mergeReadiness = input.run.results.reduce((acc, result) => {
-        acc[result.mergeReadiness] = (acc[result.mergeReadiness] ?? 0) + 1;
-        return acc;
-    }, {});
-    const dashboard = {
-        kind: 'frontier.swarm-codex.coordinator-dashboard',
-        version: 1,
-        generatedAt: new Date().toISOString(),
-        ok: input.ok,
-        outDir: input.outDir,
-        runId: input.run.id,
-        planId: input.plan.id,
-        summary: input.run.summary,
-        byLane,
-        mergeReadiness,
-        eventStream: input.eventStream ?? null,
-        pidManifestPath: input.pidManifestPath ?? null,
-        proof: input.proof
-    };
+    const processes = input.pidManifestPath ? await readCodexPidProcesses(input.pidManifestPath).catch(() => []) : [];
+    const dashboard = createSwarmCoordinatorDashboard({
+        plan: input.plan,
+        run: input.run,
+        processes,
+        metadata: {
+            ok: input.ok,
+            outDir: input.outDir,
+            eventStream: input.eventStream ?? null,
+            pidManifestPath: input.pidManifestPath ?? null,
+            proof: input.proof
+        }
+    });
     await fs.mkdir(path.dirname(file), { recursive: true });
     await fs.writeFile(file, JSON.stringify(dashboard, null, 2) + '\n');
 }
@@ -993,7 +1202,9 @@ export async function collectCodexSwarmRun(input) {
         'stale-against-head': []
     };
     const collectedBundles = [];
+    const evidenceEntries = [];
     const patchStatuses = {};
+    const processes = await readCodexPidProcesses(path.join(runDir, 'pids.json')).catch(() => []);
     const mergePaths = (await findFilesByName(runDir, 'merge.json'))
         .filter((mergePath) => !pathHasIgnoredSegment(path.relative(runDir, mergePath), [
         'collected',
@@ -1015,23 +1226,38 @@ export async function collectCodexSwarmRun(input) {
     for (const { mergePath, bundle } of mergeRecords) {
         const patchPath = resolveBundlePatchPath(bundle, mergePath);
         const patchExists = !!patchPath && await pathExists(patchPath);
-        const staleAgainstHead = input.checkStale === false ? false : await bundlePatchIsStale(bundle, mergePath, cwd);
+        const staleness = input.checkStale === false
+            ? { stale: false, patchStatus: patchExists ? 'unknown' : 'missing', reasons: ['stale check disabled'] }
+            : await bundlePatchStaleness(bundle, mergePath, cwd);
+        const staleAgainstHead = staleness.stale;
         const bucket = classifyCodexCollectBucket(bundle, staleAgainstHead);
         const branchName = input.branchPrefix ? `${input.branchPrefix}/${slug(bundle.jobId)}` : bundle.branchName;
+        const outputDir = path.join(outDir, bucket, slug(bundle.jobId));
+        const collectedEvidencePath = path.join(outputDir, 'evidence.json');
         const nextBundle = {
             ...bundle,
             ...(branchName ? { branchName } : {}),
             staleAgainstHead: bundle.staleAgainstHead || staleAgainstHead,
             disposition: staleAgainstHead ? 'stale-against-head' : bundle.disposition,
-            autoMergeable: bucket === 'ready-to-apply' && bundle.autoMergeable
+            autoMergeable: bucket === 'ready-to-apply' && bundle.autoMergeable,
+            evidencePaths: uniqueStrings([...bundle.evidencePaths, collectedEvidencePath])
         };
         collectedBundles.push(nextBundle);
-        patchStatuses[nextBundle.jobId] = staleAgainstHead ? 'stale' : patchExists ? input.checkStale === false ? 'unknown' : 'applies' : 'missing';
-        const outputDir = path.join(outDir, bucket, slug(bundle.jobId));
+        patchStatuses[nextBundle.jobId] = staleness.patchStatus;
         await fs.mkdir(outputDir, { recursive: true });
         await fs.writeFile(path.join(outputDir, 'merge.json'), JSON.stringify(nextBundle, null, 2) + '\n');
         if (patchPath && await pathExists(patchPath))
             await fs.copyFile(patchPath, path.join(outputDir, 'changes.patch')).catch(() => { });
+        await copyOrWriteCollectedEvidenceSummary({
+            file: collectedEvidencePath,
+            bundle: nextBundle,
+            bucket,
+            mergePath,
+            patchPath,
+            patchStatus: patchStatuses[nextBundle.jobId],
+            staleReasons: staleness.reasons
+        });
+        evidenceEntries.push(...createCollectedEvidenceEntries(nextBundle, collectedEvidencePath, bucket));
         buckets[bucket].push({ bucket, jobId: bundle.jobId, mergePath, outputDir, bundle: nextBundle });
     }
     const mergeIndex = createSwarmMergeIndex({
@@ -1043,6 +1269,33 @@ export async function collectCodexSwarmRun(input) {
         runId: path.basename(runDir),
         bundles: collectedBundles
     });
+    const evidenceIndex = createSwarmEvidenceIndex({
+        id: `codex-evidence-index:${path.basename(runDir)}`,
+        entries: evidenceEntries,
+        generatedAt
+    });
+    const admission = createSwarmMergeAdmission({
+        index: mergeIndex,
+        maxReady: Math.max(mergeIndex.summary.readyToApplyCount, 1),
+        allowRisks: ['low', 'medium', 'unknown'],
+        generatedAt
+    });
+    const dashboard = createSwarmCoordinatorDashboard({
+        bundles: collectedBundles,
+        mergeIndex,
+        queueOverlay,
+        evidenceIndex,
+        admission,
+        processes,
+        generatedAt,
+        metadata: { runDir, outDir }
+    });
+    const compactDashboard = createCodexCompactDashboard({
+        runDir,
+        dashboard,
+        semanticImportExpected: input.semanticImportExpected ?? false,
+        generatedAt
+    });
     const summary = {
         total: mergeRecords.length,
         'ready-to-apply': buckets['ready-to-apply'].length,
@@ -1060,14 +1313,181 @@ export async function collectCodexSwarmRun(input) {
         buckets,
         mergeIndex,
         queueOverlay,
+        evidenceIndex,
+        admission,
+        dashboard,
+        compactDashboard,
         summary
     };
     await fs.mkdir(outDir, { recursive: true });
     await fs.writeFile(path.join(outDir, 'collection.json'), JSON.stringify(result, null, 2) + '\n');
     await fs.writeFile(path.join(outDir, 'merge-index.json'), JSON.stringify(mergeIndex, null, 2) + '\n');
     await fs.writeFile(path.join(outDir, 'queue-overlay.json'), JSON.stringify(queueOverlay, null, 2) + '\n');
+    await fs.writeFile(path.join(outDir, 'evidence-index.json'), JSON.stringify(evidenceIndex, null, 2) + '\n');
+    await fs.writeFile(path.join(outDir, 'merge-admission.json'), JSON.stringify(admission, null, 2) + '\n');
+    await fs.writeFile(path.join(outDir, 'coordinator-query.json'), JSON.stringify(dashboard, null, 2) + '\n');
+    await fs.writeFile(path.join(outDir, 'compact-dashboard.json'), JSON.stringify(compactDashboard, null, 2) + '\n');
     return result;
 }
+async function readCodexPidProcesses(file) {
+    const manifest = await readCodexPidManifest(file);
+    return Promise.all(manifest.entries.map(async (entry) => ({
+        pid: entry.pid,
+        role: entry.role,
+        ...(entry.jobId ? { jobId: entry.jobId } : {}),
+        ...(entry.runId ? { runId: entry.runId } : {}),
+        status: await pidIsAlive(entry.pid) ? 'running' : 'missing',
+        startedAt: entry.startedAt,
+        ...(entry.command ? { command: entry.command } : {})
+    })));
+}
+async function pidIsAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function copyOrWriteCollectedEvidenceSummary(input) {
+    const existing = input.bundle.evidencePaths.find((entry) => path.basename(entry) === 'evidence.json' && entry !== input.file);
+    await fs.mkdir(path.dirname(input.file), { recursive: true });
+    if (existing && await pathExists(existing)) {
+        await fs.copyFile(existing, input.file).catch(() => { });
+        if (await pathExists(input.file))
+            return;
+    }
+    const patchHunks = input.patchPath ? await readPatchHunks(input.patchPath) : [];
+    const evidence = {
+        kind: FRONTIER_SWARM_CODEX_JOB_EVIDENCE_KIND,
+        version: FRONTIER_SWARM_CODEX_JOB_EVIDENCE_VERSION,
+        generatedAt: Date.now(),
+        jobId: input.bundle.jobId,
+        taskId: input.bundle.taskId ?? input.bundle.jobId,
+        lane: input.bundle.lane ?? 'unknown',
+        status: input.bundle.status,
+        mergeReadiness: input.bundle.mergeReadiness,
+        disposition: input.bundle.disposition,
+        riskLevel: input.bundle.riskLevel,
+        changedPaths: [...input.bundle.changedPaths],
+        changedRegions: [...input.bundle.changedRegions],
+        ownershipViolations: [...input.bundle.ownershipViolations],
+        ...(input.patchPath ? { patchPath: input.patchPath } : {}),
+        mergeBundlePath: input.mergePath,
+        evidencePaths: uniqueStrings(input.bundle.evidencePaths),
+        handoffArtifacts: input.bundle.evidencePaths.map((entry) => ({ path: entry, kind: classifyCodexHandoffArtifact(entry) ?? 'evidence' })),
+        commands: {
+            passed: input.bundle.commandsPassed.map((command) => ({ name: command.name, command: [...command.command], ...(command.status !== undefined ? { status: command.status } : {}) })),
+            failed: input.bundle.commandsFailed.map((command) => ({ name: command.name, command: [...command.command], ...(command.status !== undefined ? { status: command.status } : {}) }))
+        },
+        patchHunks,
+        readyToPortHunkCount: input.bucket === 'needs-human-port' || input.bucket === 'ready-to-apply' ? patchHunks.length : 0,
+        ...(input.bundle.semanticImport ? { semanticImport: input.bundle.semanticImport } : {}),
+        sourceCitations: createCodexEvidenceSourceCitations(input.bundle),
+        metadata: {
+            bucket: input.bucket,
+            patchStatus: input.patchStatus,
+            staleReasons: input.staleReasons ?? [],
+            autoMergeable: input.bundle.autoMergeable,
+            staleAgainstHead: input.bundle.staleAgainstHead,
+            reasons: input.bundle.reasons
+        }
+    };
+    await fs.writeFile(input.file, JSON.stringify(evidence, null, 2) + '\n');
+}
+function createCollectedEvidenceEntries(bundle, collectedEvidencePath, bucket) {
+    const confidence = bucket === 'ready-to-apply' ? 0.95 : bucket === 'needs-human-port' ? 0.7 : bucket === 'failed-evidence' ? 0.25 : 0.2;
+    const entries = [{
+            jobId: bundle.jobId,
+            queueItemId: bundle.queueItemIds[0],
+            lane: bundle.lane,
+            topic: 'merge-admission',
+            path: collectedEvidencePath,
+            kind: 'evidence',
+            status: bucket,
+            confidence,
+            tags: ['coordinator-query', bucket],
+            facets: {
+                bucket,
+                disposition: bundle.disposition,
+                riskLevel: bundle.riskLevel,
+                autoMergeable: bundle.autoMergeable,
+                staleAgainstHead: bundle.staleAgainstHead,
+                semanticSymbols: bundle.semanticImport?.semanticIndex.symbols ?? 0,
+                semanticRegions: bundle.semanticImport?.semanticSidecars.ownershipRegions ?? 0
+            }
+        }];
+    for (const file of bundle.evidencePaths) {
+        if (file === collectedEvidencePath)
+            continue;
+        entries.push({
+            jobId: bundle.jobId,
+            queueItemId: bundle.queueItemIds[0],
+            lane: bundle.lane,
+            topic: path.basename(file),
+            path: file,
+            kind: classifyCodexHandoffArtifact(file) ?? 'evidence',
+            status: bucket,
+            confidence,
+            tags: [bucket],
+            facets: { bucket, disposition: bundle.disposition }
+        });
+    }
+    return entries;
+}
+function createCodexCompactDashboard(input) {
+    const qualities = new Map(input.dashboard.jobs.map((job) => [
+        job.jobId,
+        summarizeCodexSemanticImportQuality(job.semanticImport, input.semanticImportExpected)
+    ]));
+    const semanticQualities = Array.from(qualities.values());
+    const usefulPatchJobs = input.dashboard.jobs.filter((job) => ((job.disposition === 'auto-mergeable' || job.disposition === 'needs-port')
+        && job.changedPaths.length > 0
+        && job.tests.requiredFailed === 0));
+    const topJobs = [...input.dashboard.jobs]
+        .filter((job) => job.changedPaths.length > 0 || job.evidencePaths.length > 0)
+        .sort((left, right) => right.mergeScore - left.mergeScore || left.jobId.localeCompare(right.jobId))
+        .slice(0, 20)
+        .map((job) => ({
+        jobId: job.jobId,
+        ...(job.lane ? { lane: job.lane } : {}),
+        disposition: job.disposition,
+        mergeScore: job.mergeScore,
+        changedPaths: job.changedPaths.slice(0, 12),
+        semanticImportQuality: qualities.get(job.jobId),
+        staleAgainstHead: job.staleAgainstHead,
+        ...(job.duplicateGroupId ? { duplicateGroupId: job.duplicateGroupId } : {}),
+        evidencePaths: job.evidencePaths.slice(0, 12)
+    }));
+    return {
+        kind: FRONTIER_SWARM_CODEX_COMPACT_DASHBOARD_KIND,
+        version: FRONTIER_SWARM_CODEX_COMPACT_DASHBOARD_VERSION,
+        generatedAt: input.generatedAt,
+        runDir: input.runDir,
+        total: input.dashboard.summary.jobCount,
+        activeJobs: input.dashboard.jobs.filter((job) => job.liveness === 'running').length,
+        usefulPatchCount: usefulPatchJobs.length,
+        stalePatchCount: input.dashboard.summary.staleAgainstHeadCount,
+        duplicateDiscoveryCount: input.dashboard.duplicateGroups.length,
+        semanticImport: {
+            expected: input.semanticImportExpected,
+            presentCount: semanticQualities.filter((entry) => entry.present).length,
+            emptyCount: semanticQualities.filter((entry) => entry.empty).length,
+            weakCount: semanticQualities.filter((entry) => entry.present && entry.warnings.length > 0).length,
+            symbolCount: semanticQualities.reduce((sum, entry) => sum + entry.symbols, 0),
+            ownershipRegionCount: semanticQualities.reduce((sum, entry) => sum + entry.ownershipRegions, 0),
+            patchHintCount: semanticQualities.reduce((sum, entry) => sum + entry.patchHints, 0)
+        },
+        evidence: {
+            readyToApply: input.dashboard.summary.readyToApplyCount,
+            needsHumanPort: input.dashboard.summary.needsHumanPortCount,
+            failedEvidence: input.dashboard.summary.failedEvidenceCount,
+            averageMergeScore: input.dashboard.summary.averageMergeScore
+        },
+        topJobs
+    };
+}
 export async function applyCodexSwarmCollection(input) {
     const generatedAt = Date.now();
     const cwd = path.resolve(input.cwd ?? process.cwd());
@@ -1388,12 +1808,132 @@ function summarizePatchScoreSemanticEvidence(bundle) {
         reasons: uniqueStrings(reasons)
     };
 }
+function summarizeCodexSemanticImportQuality(summary, expected = false) {
+    const selected = nonNegativeNumber(summary?.selected);
+    const eligible = nonNegativeNumber(summary?.eligible);
+    const imported = nonNegativeNumber(summary?.imported);
+    const symbols = nonNegativeNumber(summary?.semanticIndex?.symbols);
+    const ownershipRegions = nonNegativeNumber(summary?.semanticSidecars?.ownershipRegions);
+    const patchHints = nonNegativeNumber(summary?.semanticSidecars?.patchHints);
+    const sourceMapMappings = nonNegativeNumber(summary?.sourceMapMappingCount);
+    const present = !!summary;
+    const empty = present && (nonNegativeNumber(summary?.total) === 0 || selected === 0 && eligible === 0 && imported === 0 && symbols === 0);
+    const warnings = [];
+    if (expected && !present)
+        warnings.push('semantic import expected but missing');
+    if (expected && empty)
+        warnings.push('semantic import expected but empty');
+    if (present && imported === 0)
+        warnings.push('semantic import imported no files');
+    if (present && selected > 0 && symbols === 0)
+        warnings.push('semantic import has no symbols');
+    if (present && selected > 0 && ownershipRegions === 0)
+        warnings.push('semantic import has no ownership regions');
+    if (present && selected > 0 && sourceMapMappings === 0)
+        warnings.push('semantic import has no source-map mappings');
+    return {
+        expected,
+        present,
+        empty,
+        selected,
+        eligible,
+        imported,
+        symbols,
+        ownershipRegions,
+        patchHints,
+        sourceMapMappings,
+        warnings: uniqueStrings(warnings)
+    };
+}
 function semanticImportSummaryFromBundle(bundle) {
     if (bundle.semanticImport)
         return bundle.semanticImport;
     const metadata = bundle.metadata;
     return metadata?.semanticImport;
 }
+function semanticImportEnabled(input) {
+    if (input === true)
+        return true;
+    if (!input)
+        return false;
+    return input.enabled !== false;
+}
+function normalizeCompactLogOptions(input) {
+    if (input === false)
+        return { enabled: false };
+    if (input === true || input === undefined)
+        return { enabled: true, maxEventBytes: 1_000_000, maxStderrBytes: 256_000 };
+    return {
+        enabled: input.enabled ?? true,
+        maxEventBytes: positiveInteger(input.maxEventBytes, 1_000_000),
+        maxStderrBytes: positiveInteger(input.maxStderrBytes, 256_000)
+    };
+}
+function normalizeAdaptiveConcurrencyOptions(input, maxConcurrency) {
+    if (input === false || input === undefined) {
+        return { enabled: false, mode: 'balanced', minConcurrency: 1, maxConcurrency, writePlan: true };
+    }
+    if (input === true) {
+        return { enabled: true, mode: 'balanced', minConcurrency: 1, maxConcurrency, writePlan: true };
+    }
+    return {
+        enabled: input.enabled ?? true,
+        mode: input.mode ?? 'balanced',
+        minConcurrency: Math.max(1, Math.min(maxConcurrency, Math.floor(input.minConcurrency ?? 1))),
+        maxConcurrency: Math.max(1, Math.min(maxConcurrency, Math.floor(input.maxConcurrency ?? maxConcurrency))),
+        writePlan: input.writePlan ?? true
+    };
+}
+function createCodexAdaptiveObservations(results) {
+    const observations = [];
+    for (const result of results) {
+        const metadata = result.metadata && typeof result.metadata === 'object' ? result.metadata : {};
+        const logSummary = metadata.logSummary;
+        if (logSummary && (logSummary.eventBytesTruncated > 0 || logSummary.stderrBytesTruncated > 0 || logSummary.eventBytes > 1_000_000 || logSummary.stderrBytes > 256_000)) {
+            observations.push({
+                kind: 'log-noise',
+                severity: logSummary.eventBytesTruncated > 0 || logSummary.stderrBytesTruncated > 0 ? 'warning' : 'info',
+                jobId: result.jobId,
+                value: logSummary.eventBytes + logSummary.stderrBytes,
+                reason: 'worker output exceeded compact log threshold',
+                metadata: logSummary
+            });
+        }
+        if (result.mergeDisposition === 'stale-against-head') {
+            observations.push({ kind: 'stale-patch', severity: 'warning', jobId: result.jobId, reason: 'worker result is stale against head' });
+        }
+        if (result.mergeDisposition === 'discovery-only' || result.mergeReadiness === 'discovery-only') {
+            observations.push({ kind: 'discovery-only-output', severity: 'info', jobId: result.jobId, reason: 'worker produced discovery-only output' });
+        }
+        const semanticQuality = summarizeCodexSemanticImportQuality(result.semanticImport ?? metadata.semanticImport, false);
+        if (semanticQuality.present && semanticQuality.empty) {
+            observations.push({ kind: 'semantic-empty', severity: 'warning', jobId: result.jobId, reason: 'worker semantic sidecar is empty' });
+        }
+        else if (semanticQuality.present && semanticQuality.warnings.length > 0) {
+            observations.push({ kind: 'semantic-weak', severity: 'info', jobId: result.jobId, reasons: semanticQuality.warnings });
+        }
+    }
+    return observations;
+}
+function createEmptyCodexLogSummary(paths) {
+    return {
+        eventsPath: paths.eventsPath,
+        stderrPath: paths.stderrPath,
+        eventBytes: 0,
+        stderrBytes: 0,
+        eventBytesWritten: 0,
+        stderrBytesWritten: 0,
+        eventBytesTruncated: 0,
+        stderrBytesTruncated: 0
+    };
+}
+function positiveInteger(value, fallback) {
+    const number = Number(value);
+    return Number.isFinite(number) && number > 0 ? Math.floor(number) : fallback;
+}
+function firstNonEmptyLine(text) {
+    return text.split(/\r?\n/).map((line) => line.trim()).find(Boolean);
+}
 function numberRecord(value) {
     if (!value || typeof value !== 'object')
         return {};
@@ -1709,24 +2249,65 @@ async function runVerification(commands, cwd) {
     }
     return results;
 }
-async function runScheduledJobPool(plan, concurrency, worker) {
+async function runScheduledJobPool(plan, input, worker) {
+    const concurrency = Math.max(1, Math.floor(input.concurrency));
+    const adaptiveOptions = normalizeAdaptiveConcurrencyOptions(input.adaptive, concurrency);
     const results = [];
     const active = new Map();
     const leases = [];
     const completed = new Set();
     const resultByJob = new Map();
+    const adaptiveHistory = [];
+    let currentAdaptiveLimits;
     while (resultByJob.size < plan.jobs.length) {
         const run = createSwarmRun({ plan, status: 'running', results });
         run.jobs = run.jobs.map((job) => active.has(job.id) ? { ...job, status: 'running' } : job);
-        const schedule = createSwarmSchedule({
+        const adaptivePlan = adaptiveOptions.enabled ? createSwarmAdaptiveLoadPlan({
             plan,
             run,
-            maxReadyJobs: Math.max(0, concurrency - active.size)
+            mode: adaptiveOptions.mode,
+            maxLimits: { maxReadyJobs: adaptiveOptions.maxConcurrency },
+            minLimits: { maxReadyJobs: adaptiveOptions.minConcurrency },
+            currentLimits: currentAdaptiveLimits ?? { maxReadyJobs: adaptiveOptions.maxConcurrency },
+            observations: createCodexAdaptiveObservations(results)
+        }) : undefined;
+        if (adaptivePlan) {
+            currentAdaptiveLimits = adaptivePlan.effectiveLimits;
+            adaptiveHistory.push(adaptivePlan);
+            if (adaptiveOptions.writePlan !== false && input.outDir) {
+                await writeJsonAtomic(path.join(input.outDir, 'adaptive-load.json'), {
+                    latest: adaptivePlan,
+                    history: adaptiveHistory.slice(-50)
+                }).catch(() => { });
+            }
+            await appendFileSwarmEvent(input.eventStream, {
+                type: 'swarm.adaptive-load',
+                runId: run.id,
+                data: {
+                    mode: adaptivePlan.mode,
+                    effectiveMaxReadyJobs: adaptivePlan.effectiveLimits.maxReadyJobs,
+                    bottleneckCount: adaptivePlan.summary.bottleneckCount,
+                    decisions: adaptivePlan.decisions.map((decision) => ({
+                        action: decision.action,
+                        target: decision.target,
+                        key: decision.key,
+                        previous: decision.previous,
+                        next: decision.next,
+                        reason: decision.reason
+                    }))
+                }
+            });
+        }
+        const effectiveConcurrency = Math.max(1, Math.min(concurrency, adaptivePlan?.effectiveLimits.maxReadyJobs ?? concurrency));
+        const readyWindow = Math.max(0, effectiveConcurrency - active.size);
+        const schedule = createSwarmSchedule({
+            ...(adaptivePlan ? createSwarmScheduleInputFromAdaptiveLoadPlan(plan, adaptivePlan, { run }) : { plan, run }),
+            maxReadyJobs: readyWindow
         });
         const nextLeases = createSwarmLeases({
             schedule,
             workerId: 'frontier-swarm-codex',
-            count: Math.max(0, concurrency - active.size),
+            count: readyWindow,
             existingLeases: leases
         });
         for (const lease of nextLeases) {
@@ -1882,6 +2463,15 @@ function selectSemanticImportPaths(changedPaths, options) {
         maxFiles
     };
 }
+function semanticImportCandidatePaths(job, changedPaths) {
+    const concreteRefs = job.task.sourceRefs.concat(job.task.targetRefs).filter((file) => {
+        const normalized = normalizeWorkspacePath(file);
+        return normalized
+            && !normalized.includes('*')
+            && path.extname(normalized).length > 0;
+    });
+    return uniqueWorkspacePaths([...changedPaths, ...concreteRefs]);
+}
 function inferSemanticImportLanguage(file, overrides) {
     const ext = path.extname(file).toLowerCase();
     return overrides?.[file] ?? overrides?.[ext] ?? {
@@ -2200,15 +2790,77 @@ async function findFilesByName(root, name) {
     await walk(root);
     return out;
 }
-async function bundlePatchIsStale(bundle, mergePath, cwd) {
+async function bundlePatchStaleness(bundle, mergePath, cwd) {
     const patchPath = resolveBundlePatchPath(bundle, mergePath);
     if (!patchPath || !await pathExists(patchPath))
-        return false;
+        return { stale: false, patchStatus: 'missing', reasons: ['missing patch'] };
     const patch = await fs.readFile(patchPath, 'utf8').catch(() => '');
     if (!patch.trim())
-        return false;
+        return { stale: false, patchStatus: 'missing', reasons: ['empty patch'] };
     const result = await runProcess('git', ['apply', '--check', patchPath], { cwd, allowFailure: true });
-    return result.status !== 0;
+    if (result.status === 0)
+        return { stale: false, patchStatus: 'applies', reasons: ['patch applies to working tree'] };
+    const cached = await runProcess('git', ['apply', '--check', '--cached', patchPath], { cwd, allowFailure: true });
+    if (cached.status === 0) {
+        return {
+            stale: false,
+            patchStatus: 'dirty-workspace-conflict',
+            reasons: ['patch applies to index but not dirty working tree']
+        };
+    }
+    const baseStatus = await patchBaseHashStatus(patch, cwd);
+    if (baseStatus.known && baseStatus.mismatched === 0) {
+        return {
+            stale: false,
+            patchStatus: 'needs-port',
+            reasons: ['patch base hashes match HEAD but textual apply failed', ...baseStatus.reasons]
+        };
+    }
+    return {
+        stale: true,
+        patchStatus: 'stale',
+        reasons: uniqueStrings(['git apply --check failed', ...baseStatus.reasons, ...tail(result.stderr || result.stdout, 3)])
+    };
+}
+async function patchBaseHashStatus(patch, cwd) {
+    const entries = parsePatchBaseHashes(patch);
+    if (entries.length === 0)
+        return { known: false, mismatched: 0, reasons: ['no patch base hashes available'] };
+    let mismatched = 0;
+    const reasons = [];
+    for (const entry of entries) {
+        const head = await runProcess('git', ['rev-parse', `HEAD:${entry.path}`], { cwd, allowFailure: true });
+        if (head.status !== 0) {
+            mismatched += 1;
+            reasons.push(`missing HEAD blob for ${entry.path}`);
+            continue;
+        }
+        const headHash = head.stdout.trim();
+        if (!headHash.startsWith(entry.oldHash)) {
+            mismatched += 1;
+            reasons.push(`base hash mismatch for ${entry.path}`);
+        }
+    }
+    return { known: true, mismatched, reasons };
+}
+function parsePatchBaseHashes(patch) {
+    const lines = patch.split(/\r?\n/);
+    const entries = [];
+    let currentPath;
+    for (const line of lines) {
+        if (line.startsWith('diff --git ')) {
+            const parts = line.split(/\s+/);
+            const right = parts[3] ?? parts[2];
+            currentPath = right?.startsWith('b/') ? right.slice(2) : right;
+            continue;
+        }
+        if (!currentPath || !line.startsWith('index '))
+            continue;
+        const match = /^index\s+([0-9a-f]+)\.\.([0-9a-f]+)/i.exec(line);
+        if (match?.[1] && match[1] !== '0000000')
+            entries.push({ path: currentPath, oldHash: match[1] });
+    }
+    return entries;
 }
 function resolveBundlePatchPath(bundle, mergePath) {
     if (!bundle.patchPath)
@@ -2256,7 +2908,9 @@ function normalizeCollectedMergeBundle(value, mergePath) {
         ...(typeof input.branchName === 'string' ? { branchName: input.branchName } : {}),
         ...(typeof input.commit === 'string' ? { commit: input.commit } : {}),
         staleAgainstHead: Boolean(input.staleAgainstHead),
-        reasons: stringArray(input.reasons)
+        reasons: stringArray(input.reasons),
+        ...(isObject(input.semanticImport) ? { semanticImport: input.semanticImport } : {}),
+        ...(isObject(input.metadata) ? { metadata: input.metadata } : {})
     };
 }
 function mergeRecordScore(record) {