@shapeshift-labs/frontier-swarm-codex 0.5.32 → 0.5.34

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,12 @@ 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;
+export const FRONTIER_SWARM_CODEX_LINK_REPAIR_KIND = 'frontier.swarm-codex.link-repair';
+export const FRONTIER_SWARM_CODEX_LINK_REPAIR_VERSION = 1;
 const DEFAULT_WORKSPACE_INCLUDES = ['AGENTS.md', 'package.json', 'package-lock.json', 'pnpm-lock.yaml', 'yarn.lock', 'config'];
 const DEFAULT_WORKSPACE_EXCLUDES = [
     '.git',
@@ -118,6 +124,67 @@ export function coerceCodexSwarmTasksInput(value) {
         };
     }).filter((task) => task.id.length > 0);
 }
+export async function repairCodexWorkspacePackageLinks(input = {}) {
+    const root = path.resolve(input.root ?? process.cwd());
+    const scope = input.scope ?? '@shapeshift-labs';
+    const write = input.write ?? false;
+    const replace = input.replace ?? false;
+    const packageRoots = (input.packageRoots?.length ? input.packageRoots : [path.join(root, 'packages'), path.dirname(root)])
+        .map((entry) => path.resolve(root, entry));
+    const excludes = new Set(input.excludePackages ?? []);
+    const dependencies = input.packages?.length
+        ? new Map(input.packages.map((name) => [name, undefined]))
+        : await readWorkspaceScopedDependencies(root, scope);
+    const localPackages = await discoverLocalWorkspacePackages(packageRoots, scope);
+    const entries = [];
+    for (const [packageName, dependencyRange] of Array.from(dependencies.entries()).sort(([a], [b]) => a.localeCompare(b))) {
+        const linkPath = path.join(root, 'node_modules', ...packageName.split('/'));
+        if (excludes.has(packageName)) {
+            entries.push({ packageName, dependencyRange, linkPath, status: 'excluded', reason: 'package excluded from local repair' });
+            continue;
+        }
+        const targetPath = localPackages.get(packageName);
+        if (!targetPath) {
+            entries.push({ packageName, dependencyRange, linkPath, status: 'missing-local-package', reason: 'no matching local package was found' });
+            continue;
+        }
+        entries.push(await planOrRepairWorkspacePackageLink({
+            packageName,
+            dependencyRange,
+            linkPath,
+            targetPath,
+            write,
+            replace
+        }));
+    }
+    const result = {
+        kind: FRONTIER_SWARM_CODEX_LINK_REPAIR_KIND,
+        version: FRONTIER_SWARM_CODEX_LINK_REPAIR_VERSION,
+        generatedAt: Date.now(),
+        root,
+        scope,
+        packageRoots,
+        write,
+        replace,
+        entries,
+        summary: {
+            total: entries.length,
+            planned: entries.filter((entry) => entry.status === 'planned').length,
+            linked: entries.filter((entry) => entry.status === 'linked').length,
+            replaced: entries.filter((entry) => entry.status === 'replaced').length,
+            alreadyLinked: entries.filter((entry) => entry.status === 'already-linked').length,
+            excluded: entries.filter((entry) => entry.status === 'excluded').length,
+            missingLocalPackage: entries.filter((entry) => entry.status === 'missing-local-package').length,
+            conflicts: entries.filter((entry) => entry.status === 'conflict').length
+        },
+        ...(input.outFile ? { outFile: path.resolve(root, input.outFile) } : {})
+    };
+    if (result.outFile) {
+        await fs.mkdir(path.dirname(result.outFile), { recursive: true });
+        await fs.writeFile(result.outFile, JSON.stringify(result, null, 2) + '\n');
+    }
+    return result;
+}
 export async function runCodexSwarm(plan, options) {
     const outDir = path.resolve(options.cwd ?? process.cwd(), options.outDir);
     await fs.mkdir(outDir, { recursive: true });
@@ -135,7 +202,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 +303,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 +346,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 +370,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 +385,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 +395,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 +412,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 +439,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 +462,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 +562,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 +895,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 +924,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 +983,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,21 +1289,35 @@ 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 collectReasons = staleness.patchStatus === 'applies'
+            ? bundle.reasons
+            : uniqueStrings([...bundle.reasons, ...staleness.reasons]);
         const nextBundle = {
             ...bundle,
             ...(branchName ? { branchName } : {}),
             staleAgainstHead: bundle.staleAgainstHead || staleAgainstHead,
             disposition: staleAgainstHead ? 'stale-against-head' : bundle.disposition,
             autoMergeable: bucket === 'ready-to-apply' && bundle.autoMergeable,
+            reasons: collectReasons,
+            metadata: {
+                ...(isObject(bundle.metadata) ? bundle.metadata : {}),
+                collect: {
+                    patchStatus: staleness.patchStatus,
+                    staleReasons: staleness.reasons
+                }
+            },
             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 +1328,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 +1364,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 +1390,7 @@ export async function collectCodexSwarmRun(input) {
         evidenceIndex,
         admission,
         dashboard,
+        compactDashboard,
         summary
     };
     await fs.mkdir(outDir, { recursive: true });
@@ -1195,6 +1400,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 +1462,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 +1510,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 +1882,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 +2323,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 +2537,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] ?? {
@@ -2398,6 +2827,95 @@ async function pathExists(file) {
         return false;
     }
 }
+async function readWorkspaceScopedDependencies(root, scope) {
+    const packageJson = await readJsonObject(path.join(root, 'package.json'));
+    const dependencies = new Map();
+    for (const section of ['dependencies', 'devDependencies', 'optionalDependencies', 'peerDependencies']) {
+        const value = packageJson?.[section];
+        if (!isObject(value))
+            continue;
+        for (const [name, range] of Object.entries(value)) {
+            if (name === scope || name.startsWith(scope + '/'))
+                dependencies.set(name, typeof range === 'string' ? range : undefined);
+        }
+    }
+    return dependencies;
+}
+async function discoverLocalWorkspacePackages(packageRoots, scope) {
+    const packages = new Map();
+    for (const root of uniqueStrings(packageRoots)) {
+        await addLocalWorkspacePackage(packages, root, scope);
+        const entries = await fs.readdir(root, { withFileTypes: true }).catch(() => []);
+        for (const entry of entries) {
+            if (!entry.isDirectory() || entry.name === 'node_modules' || entry.name === '.git')
+                continue;
+            const child = path.join(root, entry.name);
+            if (entry.name.startsWith('@')) {
+                const scopedEntries = await fs.readdir(child, { withFileTypes: true }).catch(() => []);
+                for (const scopedEntry of scopedEntries) {
+                    if (scopedEntry.isDirectory())
+                        await addLocalWorkspacePackage(packages, path.join(child, scopedEntry.name), scope);
+                }
+            }
+            else {
+                await addLocalWorkspacePackage(packages, child, scope);
+            }
+        }
+    }
+    return packages;
+}
+async function addLocalWorkspacePackage(packages, packageDir, scope) {
+    const packageJson = await readJsonObject(path.join(packageDir, 'package.json'));
+    const name = typeof packageJson?.name === 'string' ? packageJson.name : undefined;
+    if (!name || name !== scope && !name.startsWith(scope + '/'))
+        return;
+    if (!packages.has(name))
+        packages.set(name, path.resolve(packageDir));
+}
+async function readJsonObject(file) {
+    try {
+        const parsed = JSON.parse(await fs.readFile(file, 'utf8'));
+        return isObject(parsed) ? parsed : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+async function planOrRepairWorkspacePackageLink(input) {
+    const base = {
+        packageName: input.packageName,
+        dependencyRange: input.dependencyRange,
+        linkPath: input.linkPath,
+        targetPath: input.targetPath
+    };
+    const stat = await fs.lstat(input.linkPath).catch(() => undefined);
+    const relativeTarget = path.relative(path.dirname(input.linkPath), input.targetPath) || '.';
+    if (stat?.isSymbolicLink()) {
+        const currentTarget = path.resolve(path.dirname(input.linkPath), await fs.readlink(input.linkPath));
+        if (currentTarget === input.targetPath)
+            return { ...base, status: 'already-linked' };
+        if (!input.write)
+            return { ...base, status: 'planned', reason: 'existing symlink points at a different package' };
+        await fs.unlink(input.linkPath);
+        await fs.symlink(relativeTarget, input.linkPath, 'dir');
+        return { ...base, status: 'linked', reason: 'updated existing symlink' };
+    }
+    if (stat) {
+        if (!input.replace)
+            return { ...base, status: 'conflict', reason: 'existing node_modules entry is not a symlink' };
+        if (!input.write)
+            return { ...base, status: 'planned', reason: 'would replace existing node_modules entry' };
+        await fs.rm(input.linkPath, { recursive: true, force: true });
+        await fs.mkdir(path.dirname(input.linkPath), { recursive: true });
+        await fs.symlink(relativeTarget, input.linkPath, 'dir');
+        return { ...base, status: 'replaced', reason: 'replaced existing node_modules entry with a symlink' };
+    }
+    if (!input.write)
+        return { ...base, status: 'planned', reason: 'missing symlink' };
+    await fs.mkdir(path.dirname(input.linkPath), { recursive: true });
+    await fs.symlink(relativeTarget, input.linkPath, 'dir');
+    return { ...base, status: 'linked', reason: 'created symlink' };
+}
 async function resolvePidManifestPath(runPath) {
     const absolute = path.resolve(runPath);
     const stat = await fs.lstat(absolute).catch(() => undefined);
@@ -2435,15 +2953,99 @@ 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) {
+        return {
+            stale: false,
+            patchStatus: 'needs-port',
+            reasons: ['patch does not expose comparable base hashes; coordinator review must port it', ...baseStatus.reasons]
+        };
+    }
+    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, cwd);
+    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, cwd) {
+    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+/);
+            currentPath = normalizePatchBasePath(parts[2], cwd) ?? normalizePatchBasePath(parts[3], cwd);
+            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 normalizePatchBasePath(token, cwd) {
+    if (!token || token === '/dev/null')
+        return undefined;
+    let value = token;
+    if (value.startsWith('a/') || value.startsWith('b/'))
+        value = value.slice(2);
+    if (value === '/dev/null')
+        return undefined;
+    if (path.isAbsolute(value)) {
+        const relative = path.relative(cwd, value);
+        if (relative && !relative.startsWith('..') && !path.isAbsolute(relative))
+            return relative.replace(/\\/g, '/');
+        return undefined;
+    }
+    return value.replace(/\\/g, '/');
 }
 function resolveBundlePatchPath(bundle, mergePath) {
     if (!bundle.patchPath)