@shapeshift-labs/frontier-swarm-codex 0.5.32 → 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, createSwarmCoordinatorDashboard, createSwarmEvidenceIndex, createSwarmMergeAdmission, 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';
@@ -29,6 +29,10 @@ export const FRONTIER_SWARM_CODEX_SEMANTIC_IMPORT_KIND = 'frontier.swarm-codex.s
 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',
@@ -135,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) {
@@ -231,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
@@ -270,6 +283,8 @@ export async function runCodexJob(job, options, outDir, lease) {
         paths.mergeBundlePath,
         ...(patchPath ? [patchPath] : []),
         ...(semanticImport ? [semanticImport.path] : []),
+        paths.patchIntentPath,
+        paths.logSummaryPath,
         ...handoffArtifacts.map((artifact) => artifact.path)
     ]);
     const result = {
@@ -292,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
         }
@@ -306,6 +322,8 @@ export async function runCodexJob(job, options, outDir, lease) {
             evidenceSummaryPath,
             paths.resourceAllocationPath,
             paths.workspaceProofPath,
+            paths.patchIntentPath,
+            paths.logSummaryPath,
             ...(semanticImport ? [semanticImport.path] : []),
             ...handoffArtifacts.map((artifact) => artifact.path)
         ]),
@@ -314,6 +332,16 @@ 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,
@@ -321,6 +349,8 @@ export async function runCodexJob(job, options, outDir, lease) {
         mergeBundle,
         mergeBundlePath: paths.mergeBundlePath,
         patchPath,
+        patchIntentPath: paths.patchIntentPath,
+        logSummary,
         semanticImportPath: semanticImport?.path,
         semanticImport: semanticImport?.sidecar,
         handoffArtifacts
@@ -346,6 +376,7 @@ async function writeCodexJobEvidenceSummary(input) {
         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 })),
@@ -368,11 +399,56 @@ async function writeCodexJobEvidenceSummary(input) {
         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())
@@ -423,7 +499,7 @@ 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');
@@ -756,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,
@@ -772,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 = {
@@ -802,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 });
@@ -1106,7 +1226,10 @@ 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));
@@ -1120,7 +1243,7 @@ export async function collectCodexSwarmRun(input) {
             evidencePaths: uniqueStrings([...bundle.evidencePaths, collectedEvidencePath])
         };
         collectedBundles.push(nextBundle);
-        patchStatuses[nextBundle.jobId] = staleAgainstHead ? 'stale' : patchExists ? input.checkStale === false ? 'unknown' : 'applies' : 'missing';
+        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))
@@ -1131,7 +1254,8 @@ export async function collectCodexSwarmRun(input) {
             bucket,
             mergePath,
             patchPath,
-            patchStatus: patchStatuses[nextBundle.jobId]
+            patchStatus: patchStatuses[nextBundle.jobId],
+            staleReasons: staleness.reasons
         });
         evidenceEntries.push(...createCollectedEvidenceEntries(nextBundle, collectedEvidencePath, bucket));
         buckets[bucket].push({ bucket, jobId: bundle.jobId, mergePath, outputDir, bundle: nextBundle });
@@ -1166,6 +1290,12 @@ export async function collectCodexSwarmRun(input) {
         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,
@@ -1186,6 +1316,7 @@ export async function collectCodexSwarmRun(input) {
         evidenceIndex,
         admission,
         dashboard,
+        compactDashboard,
         summary
     };
     await fs.mkdir(outDir, { recursive: true });
@@ -1195,6 +1326,7 @@ export async function collectCodexSwarmRun(input) {
     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) {
@@ -1256,6 +1388,7 @@ async function copyOrWriteCollectedEvidenceSummary(input) {
         metadata: {
             bucket: input.bucket,
             patchStatus: input.patchStatus,
+            staleReasons: input.staleReasons ?? [],
             autoMergeable: input.bundle.autoMergeable,
             staleAgainstHead: input.bundle.staleAgainstHead,
             reasons: input.bundle.reasons
@@ -1303,6 +1436,58 @@ function createCollectedEvidenceEntries(bundle, collectedEvidencePath, bucket) {
     }
     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());
@@ -1623,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 {};
@@ -1944,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) {
@@ -2117,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] ?? {
@@ -2435,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)