clinkx 0.3.0 → 1.0.0

package/dist/context-builder/handler.js

@@ -1,47 +1,95 @@
-import { isSamePathOrDescendant } from "../allowed-roots.js";
+import { appendArtifactOnlyRootsToEnv, isArtifactOnlyAllowedRootEntry, isSamePathOrDescendant, parseAllowedRootsEnv, stripArtifactOnlyMarker, } from "../allowed-roots.js";
 import { CancellationError, ExecutionError, InvalidParamsError, } from "../errors.js";
-import { readFileSync, realpathSync } from "node:fs";
+import { realpathSync } from "node:fs";
 import { realpath as fsRealpath } from "node:fs/promises";
 import path from "node:path";
-import { getCurrentAllowedRoots } from "../paths.js";
 import { AdapterRegistry as RuntimeAdapterRegistry } from "../registry.js";
+import { logger } from "../logger.js";
 import { assertContextBuilderAnchorSufficiency } from "./anchors.js";
 import { writeContextBuilderFinalArtifacts, } from "./bundle.js";
-import { CONTEXT_BUILDER_INTERNAL_CAP_DEFAULTS, ContextBuilderSemaphore, getContextBuilderMaxConcurrent, resolveContextBuilderRunsDir, } from "./config.js";
-import { buildContextBuilderCuratorPacket, buildContextBuilderFinalizerPacket, CONTEXT_BUILDER_DELEGATE_PACKET_CAP_PROFILE_DEFAULTS, } from "./delegate-packet.js";
+import { CONTEXT_BUILDER_INTERNAL_CAP_DEFAULTS, getSharedContextBuilderSemaphore, resolveContextBuilderRunsDir, } from "./config.js";
+import { buildContextBuilderCuratorPacket, buildContextBuilderFinalizerPacket, CONTEXT_BUILDER_DELEGATE_PACKET_CAP_PROFILE_DEFAULTS, contextBuilderCandidateId, } from "./delegate-packet.js";
 import { reconstructContextBuilderDelegateSelection } from "./delegate-reconstruction.js";
 import { runContextBuilderDelegateCall, } from "./delegate.js";
-import { validateContextBuilderCuratorOutput, validateContextBuilderFinalizerOutput, } from "./delegate-validation.js";
-import { discoverContextBuilderCandidates, mergeLineRanges, splitTextLines, } from "./discovery.js";
-import { boundContextBuilderPathList, isRequestedEvidenceOmission, sanitizeDiagnosticText, } from "./diagnostics.js";
-import { validateContextBuilderGlobs } from "./globs.js";
+import { validateContextBuilderCuratorOutput, validateContextBuilderDelegateCoverageSelection, validateContextBuilderFinalizerOutput, } from "./delegate-validation.js";
+import { discoverContextBuilderCandidates, mergeLineRanges, } from "./discovery.js";
+import { evaluateSearchCapMateriality } from "./status.js";
+import { boundContextBuilderPathList, isRequestedEvidenceOmission, sanitizeDelegateFailureText, sanitizeDiagnosticText, } from "./diagnostics.js";
+import { compileContextBuilderGlobs, CONTEXT_BUILDER_DEFAULT_EXCLUDE_GLOBS, validateContextBuilderGlobs, } from "./globs.js";
 import { resolveContextBuilderFocusPaths, resolveContextBuilderRoots, } from "./paths.js";
 import { createContextBuilderProgressReporter, } from "./progress.js";
+import { ContextBuilderLifecycleController, ContextBuilderLifecycleObserverError, } from "./lifecycle-observer.js";
+import { createContextBuilderLifecycleJournal } from "./lifecycle-journal.js";
+import { recordContextRunCatalogMarker } from "./context-run-catalog.js";
+import { appendLifecycleCompletionWarning } from "./lifecycle-recovery.js";
+import { withContextBuilderWriteWatchdog } from "./write-watchdog.js";
 import { createContextBuilderReceiptTextResponse, } from "./receipt.js";
 import { generateContextBuilderRunId } from "./run-id.js";
 import { CONTEXT_BUILDER_INTENT_PROFILE_DEFAULTS, parseContextBuilderInput, } from "./schema.js";
-import { isContextBuilderTaskClosureAnchor, selectContextBuilderFinalContext, } from "./selection.js";
+import { evaluateContextCoverage, resolveContextCoveragePolicy, } from "./review-coverage.js";
+import { selectContextBuilderFinalContext, } from "./selection.js";
 import { cleanupContextBuilderIncompleteRun, createContextBuilderRun, } from "./storage.js";
+import { admitJournalContextGeneration } from "./session-log-identity.js";
 import { estimateContextBuilderTokensFromUtf8Bytes } from "./token-estimate.js";
-let defaultSemaphore;
 let defaultAdapterRegistry;
 const artifactOnlyAllowedRoots = new Set();
-const CONTEXT_BUILDER_DELEGATE_PROMPT_VERSION = "cb-delegate-v2-packet-nonempty";
+const CONTEXT_BUILDER_DELEGATE_PROMPT_VERSION = "cb-delegate-v3-scored-obligations";
 const MAX_DELEGATE_MINIMUM_OUTPUT_SELECTIONS = 24;
 export async function handleContextBuilder(args, options = {}) {
     const input = parseContextBuilderInput(args);
+    const coveragePolicy = resolveContextCoveragePolicy(input.profile);
     const semaphore = options.semaphore ?? getDefaultContextBuilderSemaphore();
-    semaphore.acquire();
     const progress = createContextBuilderProgressReporter(options.progress);
+    const ownsLifecycle = options.lifecycleController == null;
+    semaphore.acquire();
+    let lifecycle;
     let storage;
     let committed = false;
     try {
-        await progress?.emit("validating");
+        // Resolve and validate the runs dir up front so a broad/forbidden runs_dir
+        // is rejected with its canonical error BEFORE any lifecycle transition, and
+        // so the journal reuses this one already-validated path instead of
+        // re-resolving (a second resolution would wrap that rejection as an opaque
+        // observer failure).
+        const runsDir = await resolveContextBuilderRunsDir(options.runsDir);
+        // A standalone operation that owns its lifecycle (no injected observer)
+        // persists authoritatively through the .context-runs journal; the injected
+        // path — workflow preflight — supplies its own store instead.
+        const journal = ownsLifecycle && options.lifecycle == null
+            ? createContextBuilderLifecycleJournal({
+                runsDir,
+                resolveRunsDir: async () => runsDir,
+            })
+            : undefined;
+        lifecycle = options.lifecycleController ??
+            new ContextBuilderLifecycleController({
+                operationKind: "standalone",
+                execution: lifecycleExecutionConfig(input),
+                ...(options.lifecycle != null
+                    ? {
+                        observer: options.lifecycle.observer,
+                        ...(options.lifecycle.origin == null
+                            ? {}
+                            : { origin: options.lifecycle.origin }),
+                    }
+                    : journal == null
+                        ? {}
+                        : { observer: journal.observe }),
+                ...(progress == null ? {} : { notificationObserver: progress.observe }),
+                ...(options.now == null ? {} : { now: options.now }),
+            });
+        if (ownsLifecycle) {
+            await lifecycle?.transition("resolving");
+        }
         const createdAt = (options.now?.() ?? new Date()).toISOString();
         const runId = input.run_id ?? generateContextBuilderRunId();
+        await lifecycle?.transition("validating", {
+            ...(ownsLifecycle ? { artifactRunId: runId } : {}),
+        });
         const internalCaps = options.internalCaps ?? CONTEXT_BUILDER_INTERNAL_CAP_DEFAULTS;
-        const runsDir = await resolveContextBuilderRunsDir(options.runsDir);
-        const currentAllowedRoots = getCurrentAllowedRoots();
+        const currentAllowedRoots = parseAllowedRootsEnv({
+            includeArtifactOnly: false,
+        });
         const explicitlyConfiguredArtifactRoots = getExactlyConfiguredArtifactRoots();
         const sourceAllowedRoots = currentAllowedRoots.filter((root) => !artifactOnlyAllowedRoots.has(root) ||
             explicitlyConfiguredArtifactRoots.has(root));
@@ -60,38 +108,77 @@ export async function handleContextBuilder(args, options = {}) {
             focus_paths: focusPaths,
             include_globs: input.include_globs,
             search_terms: input.search_terms,
+            allowRootWideDiscovery: options.allowRootWideDiscovery ?? false,
+        });
+        assertNoContextBuilderFocusGlobConflicts({
+            focusPaths,
+            includeGlobs: input.include_globs,
+            excludeGlobs: input.exclude_globs,
         });
         appendArtifactOnlyRootToEnv(runsDir);
         if (!sourceAllowedRoots.includes(runsDir)) {
             artifactOnlyAllowedRoots.add(runsDir);
         }
         const excludedArtifactRoots = [...artifactOnlyAllowedRoots].filter((root) => !explicitlyConfiguredArtifactRoots.has(root));
-        storage = await createContextBuilderRun({
+        const writingStorage = await createContextBuilderRun({
             runsDir,
             runId,
             createdAt,
         });
-        await progress?.emit("scanning");
+        storage = writingStorage;
+        let sessionLogContext;
+        if (journal !== undefined) {
+            try {
+                sessionLogContext = {
+                    contextRunId: lifecycle.contextRunId,
+                    contextGeneration: await admitJournalContextGeneration(runsDir, lifecycle.contextRunId),
+                };
+            }
+            catch {
+                logger.debug({ contextRunId: lifecycle.contextRunId }, "context session-log identity admission failed open");
+            }
+        }
+        else if (options.sessionLogContext !== undefined) {
+            // Workflow preflight path: the runner minted the operation id (via the
+            // controller) and created the run-dir generation sidecar. Use that pair
+            // instead of the journal (which the injected-controller path does not
+            // create). Both flow into the context-family session-log owner emitted for
+            // the curator/finalizer delegate calls.
+            const injected = options.sessionLogContext;
+            sessionLogContext = injected.contextRunId === lifecycle.contextRunId
+                ? injected
+                : { contextRunId: lifecycle.contextRunId, contextGeneration: injected.contextGeneration };
+        }
+        await lifecycle?.transition("scanning");
         const discovery = await discoverContextBuilderCandidates({
             roots: rootResolution.roots,
             task: input.task,
+            allowSecrets: input.allow_secrets,
             focus_paths: focusPaths,
             include_globs: input.include_globs,
             exclude_globs: input.exclude_globs,
             search_terms: input.search_terms,
+            coverage_policy: coveragePolicy,
             budget: input.budget,
             internal_caps: internalCaps,
             excluded_real_roots: excludedArtifactRoots,
             ...(options.signal == null ? {} : { signal: options.signal }),
         });
-        await progress?.emit("searching");
-        await progress?.emit("selecting");
+        await lifecycle?.transition("searching", {
+            counts: lifecycleCountsFromDiscovery(discovery),
+        });
+        await lifecycle?.transition("selecting");
         const selection = selectContextBuilderFinalContext({
             task: input.task,
             tree: discovery.tree,
             search: discovery.search,
             slices: discovery.slices,
             budget: input.budget,
+            coverage_policy: coveragePolicy,
+            evidence_classes_by_candidate: evidenceClassesByCandidate(discovery.content_candidates),
+            ...(discovery.review_obligations == null
+                ? {}
+                : { review_obligations: discovery.review_obligations }),
         });
         const effectiveDelegatePacketCaps = resolveEffectiveDelegatePacketCaps(input.profile, options.delegatePacketCaps);
         const delegateResult = input.delegate.enabled
@@ -103,55 +190,26 @@ export async function handleContextBuilder(args, options = {}) {
                 baselineOmissions: rootResolution.omissions,
                 sourceRoots: rootResolution.roots,
                 registry: options.registry ?? getDefaultAdapterRegistry(),
+                coveragePolicy,
                 ...(effectiveDelegatePacketCaps == null
                     ? {}
                     : { delegatePacketCaps: effectiveDelegatePacketCaps }),
-                ...(progress == null ? {} : { progress }),
+                ...(lifecycle == null ? {} : { lifecycle }),
                 ...(options.signal == null ? {} : { signal: options.signal }),
+                ...(sessionLogContext == null ? {} : { sessionLogContext }),
             })
             : undefined;
-        let effectiveDelegateResult = delegateResult;
-        let finalSelection = pruneTaskSpecificFinalSelection({
-            selection: effectiveDelegateResult?.selection ?? selection,
-            contentCandidates: discovery.content_candidates,
-            sourceRoots: rootResolution.roots,
-            budget: input.budget,
-            task: input.task,
-        });
-        let packetQa = validateBenchmarkPacketQuality({
-            task: input.task,
-            selection: finalSelection,
-            contentCandidates: discovery.content_candidates,
+        const effectiveDelegateResult = delegateResult;
+        const finalSelection = effectiveDelegateResult?.selection ?? selection;
+        const coverage = evaluateSelectionCoverage({
+            policy: coveragePolicy,
+            candidates: discovery.content_candidates,
+            selected: finalSelection.selected,
+            ...(discovery.review_obligations == null
+                ? {}
+                : { obligations: discovery.review_obligations }),
         });
-        if (packetQa.materialFailureReason != null &&
-            effectiveDelegateResult != null &&
-            input.delegate.enabled) {
-            effectiveDelegateResult = handleDelegateRuntimeFailure({
-                delegate: input.delegate,
-                reason: packetQa.materialFailureReason,
-                deterministicSelection: selection,
-                omissionCount: rootResolution.omissions.length +
-                    discovery.omissions.length +
-                    selection.omissions.length,
-                candidateFallbackCount: selection.selected.length,
-            });
-            finalSelection = pruneTaskSpecificFinalSelection({
-                selection: effectiveDelegateResult.selection,
-                contentCandidates: discovery.content_candidates,
-                sourceRoots: rootResolution.roots,
-                budget: input.budget,
-                task: input.task,
-            });
-            packetQa = validateBenchmarkPacketQuality({
-                task: input.task,
-                selection: finalSelection,
-                contentCandidates: discovery.content_candidates,
-            });
-        }
-        const rawWarnings = [
-            ...(effectiveDelegateResult?.warnings ?? []),
-            ...packetQa.warnings,
-        ];
+        const rawWarnings = [...(effectiveDelegateResult?.warnings ?? [])];
         const openQuestions = effectiveDelegateResult?.openQuestions ?? [];
         const omissions = [
             ...rootResolution.omissions,
@@ -164,13 +222,21 @@ export async function handleContextBuilder(args, options = {}) {
             selection: finalSelection.metrics,
             omissionCount: omissions.length,
         });
-        const warnings = reconcileContextBuilderWarnings({
+        const reconciledWarnings = reconcileContextBuilderWarnings({
             warnings: rawWarnings,
             selected: finalSelection.selected,
             omissions,
             metrics,
             delegate: effectiveDelegateResult?.delegate,
         });
+        // A material search cap must be explained in the receipt, not just
+        // classified: the warning carries the bounded coverage summary while the
+        // cap event (built from metrics + search_coverage in the status reducer)
+        // carries the partial classification.
+        const searchCapWarning = searchCapCoverageWarning(metrics.search_cap_hit, discovery.search_coverage);
+        const warnings = searchCapWarning == null
+            ? reconciledWarnings
+            : [...reconciledWarnings, searchCapWarning];
         const delegateMetadata = effectiveDelegateResult?.delegate == null
             ? undefined
             : {
@@ -178,10 +244,26 @@ export async function handleContextBuilder(args, options = {}) {
                 selected_count: finalSelection.selected.length,
                 warning_count: warnings.length,
             };
+        const delegatePacketEstimatedTokens = effectiveDelegateResult?.observability.delegate_packet_size ?? 0;
+        const delegatePacketCompaction = effectiveDelegateResult?.observability.delegate_packet_compaction;
+        const observability = {
+            curator_ms: effectiveDelegateResult?.observability.curator_ms ?? null,
+            finalizer_ms: effectiveDelegateResult?.observability.finalizer_ms ?? null,
+            candidate_pool_size: discovery.content_candidates.length,
+            // Deprecated alias (see ContextBuilderObservabilityMetrics): historical
+            // name for the packet ESTIMATED-TOKEN metric. Kept byte-identical for
+            // compatibility; new readers should use delegate_packet_estimated_tokens.
+            delegate_packet_size: delegatePacketEstimatedTokens,
+            delegate_packet_estimated_tokens: delegatePacketEstimatedTokens,
+            ...(delegatePacketCompaction == null
+                ? {}
+                : { delegate_packet_compaction: delegatePacketCompaction }),
+        };
         const renderInput = {
             run_id: runId,
             created_at: createdAt,
             task: input.task,
+            allowSecrets: input.allow_secrets,
             roots: rootResolution.roots.map((root) => ({
                 root_index: root.root_index,
                 input_path: root.input_path,
@@ -207,245 +289,226 @@ export async function handleContextBuilder(args, options = {}) {
             omissions,
             warnings,
             metrics,
+            search_coverage: discovery.search_coverage,
             open_questions: openQuestions,
             ...(delegateMetadata == null ? {} : { delegate: delegateMetadata }),
+            observability,
+            coverage,
+            status_evidence: { coverage },
             debug: input.debug,
         };
-        await progress?.emit("writing");
-        const receipt = await writeContextBuilderFinalArtifacts(storage, renderInput, {
-            ...(options.signal == null ? {} : { signal: options.signal }),
-            ...(storage.ownerNonce == null ? {} : { ownerNonce: storage.ownerNonce }),
+        await lifecycle?.transition("writing", {
+            ...delegateLifecyclePatch(effectiveDelegateResult, lifecycle),
+            counts: lifecycleCountsFromMetrics(metrics, discovery.search.length),
+            coverage: lifecycleCoverage(coverage),
+            ...(effectiveDelegateResult?.delegate.fallback_used === true
+                ? {
+                    fallback: {
+                        status: "used",
+                        reason_code: "delegate_fallback",
+                    },
+                    reasonCodes: ["delegate_fallback"],
+                }
+                : {}),
         });
+        // Capture into a const so the beforeManifestCommit closure keeps the
+        // narrowed non-undefined type (the outer binding is a reassignable let).
+        const committingLifecycle = lifecycle;
+        const receipt = await withContextBuilderWriteWatchdog((signal) => writeContextBuilderFinalArtifacts(writingStorage, renderInput, {
+            signal,
+            ...(writingStorage.ownerNonce == null ? {} : { ownerNonce: writingStorage.ownerNonce }),
+            ...(!ownsLifecycle || committingLifecycle == null
+                ? {}
+                : { beforeManifestCommit: () => committingLifecycle.transition("committing") }),
+        }), options.signal == null ? {} : { signal: options.signal });
         committed = true;
-        await progress?.emit("complete");
-        return createContextBuilderReceiptTextResponse(receipt);
+        if (ownsLifecycle) {
+            await recordContextRunCatalogMarker({
+                runsDir,
+                kind: "artifact",
+                id: receipt.run_id,
+                createdAt,
+            }).catch(() => {
+                logger.warn({ contextRunId: receipt.run_id }, "context run catalog marker write failed");
+            });
+        }
+        let responseReceipt = receipt;
+        if (ownsLifecycle) {
+            try {
+                await lifecycle?.complete(receipt.status, {
+                    artifactRunId: receipt.run_id,
+                    counts: lifecycleCountsFromMetrics(receipt.metrics, discovery.search.length),
+                    coverage: lifecycleCoverage(coverage),
+                });
+            }
+            catch (error) {
+                if (!(error instanceof ContextBuilderLifecycleObserverError))
+                    throw error;
+                logger.warn({ contextRunId: lifecycle?.contextRunId }, "context run lifecycle completion unavailable after retry");
+                responseReceipt = appendLifecycleCompletionWarning(receipt, internalCaps.max_warnings);
+            }
+        }
+        return createContextBuilderReceiptTextResponse(responseReceipt);
     }
     catch (err) {
         if (storage != null && !committed && storage.ownerNonce != null) {
             await cleanupContextBuilderIncompleteRun(storage, storage.ownerNonce).catch(() => { });
         }
+        if (ownsLifecycle && lifecycle != null &&
+            !(err instanceof ContextBuilderLifecycleObserverError)) {
+            const cancelled = err instanceof CancellationError || options.signal?.aborted === true;
+            const delegateFailed = input.delegate.enabled && delegateExecutionActive(lifecycle);
+            await lifecycle.fail(cancelled ? "cancelled" : "failed", {
+                ...terminalExecutionPatch(lifecycle, cancelled),
+                reasonCodes: [
+                    cancelled
+                        ? "operation_cancelled"
+                        : delegateFailed
+                            ? "delegate_failed"
+                            : "internal_failure",
+                ],
+                ...(!cancelled && delegateFailed
+                    ? {
+                        fallback: {
+                            status: "failed",
+                            reason_code: "delegate_failed",
+                        },
+                    }
+                    : {}),
+            });
+        }
         throw err;
     }
     finally {
         semaphore.release();
     }
 }
-function pruneTaskSpecificFinalSelection(input) {
-    const taskSpineRepaired = repairTaskSpineRanges({
-        selection: input.selection,
-        candidates: input.contentCandidates,
-        budget: input.budget,
-        task: input.task,
-        sourceRoots: input.sourceRoots,
-    });
-    const closureExpanded = expandSelectedClosureFilesToFullCandidates(taskSpineRepaired, input.contentCandidates, input.task, input.budget);
-    const discoveredRetained = retainDiscoveredTaskCriticalFiles(closureExpanded.selection, input.contentCandidates, input.task, input.budget);
-    const closureRepaired = dropDegenerateSelectedSlices(discoveredRetained.selection, input.contentCandidates, input.task);
-    const runtimePruned = pruneRuntimeSettingsDiscoverySearchNoise(closureRepaired.selection, input.task);
-    const debugPruned = pruneDebugTraceSearchNoise(runtimePruned, input.contentCandidates, input.budget, input.task);
-    const reviewPruned = pruneCodexRuntimeReviewSearchNoise(debugPruned, input.task);
-    return rankTaskSpecificFinalSelection(reviewPruned, input.task);
-}
-function validateBenchmarkPacketQuality(input) {
-    const axes = benchmarkPacketQaAxes(input.task);
-    if (axes.length === 0) {
-        return { warnings: [] };
-    }
-    const selected = input.selection.selected.filter((file) => file.content.trim().length > 0);
-    const summaryFiles = input.selection.summary?.files ?? [];
-    const gaps = [];
-    for (const axis of axes) {
-        if (selected.some((file) => axis.matches(file.path))) {
-            continue;
-        }
-        const candidatePaths = input.contentCandidates
-            .filter((candidate) => axis.matches(candidate.path))
-            .map((candidate) => candidate.path);
-        const summaryOnlyPaths = summaryFiles
-            .filter((file) => axis.matches(file.path))
-            .map((file) => file.path);
-        if (candidatePaths.length === 0 && summaryOnlyPaths.length === 0) {
-            continue;
-        }
-        gaps.push({
-            axis,
-            candidatePaths: boundContextBuilderPathList(candidatePaths),
-            summaryOnlyPaths: boundContextBuilderPathList(summaryOnlyPaths),
-        });
-    }
-    if (gaps.length === 0) {
-        return { warnings: [] };
-    }
-    const warnings = gaps.map((gap) => delegateWarning("packet_qa", packetQaGapMessage(gap.axis.label, gap.candidatePaths, gap.summaryOnlyPaths)));
-    const materialGaps = gaps.filter((gap) => gap.candidatePaths.length > 0);
-    if (materialGaps.length === 0) {
-        return { warnings };
+function lifecycleExecutionConfig(input) {
+    if (!input.delegate.enabled) {
+        return {
+            curator: { configured: false, enabled: false },
+            finalizer: { configured: false, enabled: false },
+        };
     }
     return {
-        warnings,
-        materialFailureReason: `packet QA missing source evidence for task axis: ${materialGaps
-            .map((gap) => `${gap.axis.label} (${gap.candidatePaths.join(", ")})`)
-            .join("; ")}`,
+        curator: { configured: true, enabled: true },
+        finalizer: {
+            configured: true,
+            enabled: contextBuilderFinalizerEnabled(input),
+        },
     };
 }
-function packetQaGapMessage(axis, candidatePaths, summaryOnlyPaths) {
-    const paths = candidatePaths.length > 0 ? candidatePaths : summaryOnlyPaths;
-    const backing = candidatePaths.length > 0 && summaryOnlyPaths.length > 0
-        ? "available source candidate only represented in selection summary"
-        : candidatePaths.length > 0
-            ? "available source candidate"
-            : "selection summary";
-    return `packet QA found ${backing} for task axis "${axis}" without source evidence in selected context: ${paths.join(", ")}`;
-}
-function benchmarkPacketQaAxes(task) {
-    if (isCodexRuntimeReviewTask(task)) {
-        return codexRuntimeReviewQaAxes(task);
-    }
-    if (isDevtoolsTraceDebugTask(task)) {
-        return devtoolsTraceDebugQaAxes(task);
-    }
-    if (isRuntimeSettingsDiscoveryTask(task)) {
-        return runtimeSettingsDiscoveryQaAxes(task);
-    }
-    return [];
-}
-function codexRuntimeReviewQaAxes(task) {
-    const normalized = task.toLowerCase();
-    const axes = [
-        {
-            label: "Codex runtime implementation",
-            matches: (path) => {
-                const normalizedPath = path.toLowerCase();
-                return (normalizedPath.endsWith("/services/runtime/codex.py") ||
-                    normalizedPath.endsWith("/services/runtime/codex_stream_processor.py") ||
-                    normalizedPath.endsWith("/services/runtime/base.py") ||
-                    normalizedPath.endsWith("/services/runtime/resolver.py"));
-            },
-        },
-    ];
-    if (/\b(approval|permission|permissions?)\b/.test(normalized)) {
-        axes.push({
-            label: "Codex approval and permission flow",
-            matches: (path) => {
-                const normalizedPath = path.toLowerCase();
-                return (normalizedPath.endsWith("/services/runtime/codex_approval.py") ||
-                    normalizedPath.endsWith("/services/permission_manager.py") ||
-                    normalizedPath.endsWith("/api/endpoints/permissions.py") ||
-                    normalizedPath.endsWith("/models/schemas/permissions.py") ||
-                    normalizedPath.endsWith("/models/schemas/permission_mode.py") ||
-                    normalizedPath.endsWith("/tests/test_permissions.py") ||
-                    normalizedPath.includes("/permission-mode-selector/"));
-            },
-        });
-    }
-    if (/\b(session|orchestrat|stream|dispatch)\b/.test(normalized)) {
-        axes.push({
-            label: "runtime session and orchestration flow",
-            matches: (path) => {
-                const normalizedPath = path.toLowerCase();
-                return (normalizedPath.endsWith("/services/runtime_session_service.py") ||
-                    normalizedPath.endsWith("/models/db_models/runtime_session.py") ||
-                    normalizedPath.endsWith("/services/streaming/orchestrator.py") ||
-                    normalizedPath.endsWith("/api/endpoints/chat.py") ||
-                    normalizedPath.endsWith("/services/chat.py") ||
-                    normalizedPath.endsWith("/tests/services/test_runtime_session_service.py"));
-            },
-        });
-    }
-    if (/\b(frontend|consumer|attachment|upload|ui|settings?)\b/.test(normalized)) {
-        axes.push({
-            label: "frontend Codex consumer flow",
-            matches: (path) => {
-                const normalizedPath = path.toLowerCase();
-                return (normalizedPath.endsWith("/hooks/usechatruntimesettings.ts") ||
-                    normalizedPath.endsWith("/hooks/usemessageactions.ts") ||
-                    normalizedPath.endsWith("/components/ui/fileuploaddialog.tsx") ||
-                    normalizedPath.endsWith("/components/chat/message-input/input.tsx") ||
-                    normalizedPath.endsWith("/components/chat/message-input/composerruntimecontrols.tsx") ||
-                    normalizedPath.endsWith("/utils/modelprovider.ts"));
-            },
-        });
+function lifecycleCountsFromDiscovery(discovery) {
+    return {
+        files_seen: discovery.metrics.files_seen,
+        files_considered: discovery.metrics.files_considered,
+        files_selected: 0,
+        files_omitted: discovery.omissions.length,
+        search_results: discovery.search.length,
+        bytes_read: discovery.metrics.bytes_read,
+        bytes_written: 0,
+    };
+}
+function lifecycleCountsFromMetrics(metrics, searchResults) {
+    return {
+        files_seen: metrics.files_seen,
+        files_considered: metrics.files_considered,
+        files_selected: metrics.files_selected,
+        files_omitted: metrics.files_omitted,
+        search_results: searchResults,
+        bytes_read: metrics.bytes_read,
+        bytes_written: metrics.bytes_written,
+    };
+}
+function lifecycleCoverage(coverage) {
+    const required = coverage.required_when_available.length;
+    const missing = coverage.missing_required.length;
+    return {
+        policy: coverage.policy_id,
+        status: coverage.status,
+        required,
+        selected: Math.max(0, required - missing),
+        missing,
+    };
+}
+function delegateLifecyclePatch(result, lifecycle) {
+    if (result == null)
+        return {};
+    if (result.delegate.fallback_used) {
+        if (lifecycle?.snapshot?.phase === "finalizing") {
+            return { curatorStatus: "succeeded", finalizerStatus: "failed" };
+        }
+        return {
+            curatorStatus: "failed",
+            ...(lifecycle?.snapshot?.finalizer.effective_enabled === true
+                ? { finalizerStatus: "skipped" }
+                : {}),
+        };
     }
-    return axes;
-}
-function devtoolsTraceDebugQaAxes(task) {
-    const normalized = task.toLowerCase();
-    const axes = [
-        {
-            label: "DevTools trace panel UI",
-            matches: (path) => {
-                const normalizedPath = path.toLowerCase();
-                return (normalizedPath.endsWith("/components/right-panel/rightpaneldevtools.tsx") ||
-                    normalizedPath.endsWith("/store/devtoolsnavstore.ts") ||
-                    normalizedPath.endsWith("/services/devtoolsservice.ts") ||
-                    normalizedPath.endsWith("/hooks/queries/usedevtoolsqueries.ts"));
-            },
-        },
-        {
-            label: "trace persistence and API flow",
-            matches: (path) => {
-                const normalizedPath = path.toLowerCase();
-                return (normalizedPath.endsWith("/api/endpoints/devtools.py") ||
-                    normalizedPath.endsWith("/services/session_trace_archive.py") ||
-                    normalizedPath.endsWith("/services/codex_trace.py") ||
-                    normalizedPath.endsWith("/models/schemas/devtools.py") ||
-                    normalizedPath.endsWith("/types/devtools.types.ts"));
-            },
-        },
-    ];
-    if (/\b(chat|message|autoscroll|tool)\b/.test(normalized)) {
-        axes.push({
-            label: "chat trace rendering flow",
-            matches: (path) => {
-                const normalizedPath = path.toLowerCase();
-                return (normalizedPath.endsWith("/components/chat/chat-window/chat.tsx") ||
-                    normalizedPath.endsWith("/components/chat/message-bubble/messagerenderer.tsx") ||
-                    normalizedPath.endsWith("/components/chat/tools/common/toolcard.tsx") ||
-                    normalizedPath.endsWith("/hooks/usemessagecache.ts") ||
-                    normalizedPath.endsWith("/utils/messagecacheorder.ts"));
-            },
-        });
+    return {
+        curatorStatus: "succeeded",
+        ...(result.delegate.finalizer_score == null
+            ? {}
+            : {
+                finalizerStatus: "succeeded",
+                finalizerScore: result.delegate.finalizer_score,
+            }),
+    };
+}
+function terminalExecutionPatch(lifecycle, cancelled) {
+    const snapshot = lifecycle.snapshot;
+    if (snapshot == null)
+        return {};
+    const terminalStatus = cancelled ? "cancelled" : "failed";
+    return {
+        ...(snapshot.curator.execution_status === "running"
+            ? { curatorStatus: terminalStatus }
+            : snapshot.curator.execution_status === "pending"
+                ? { curatorStatus: "skipped" }
+                : {}),
+        ...(snapshot.finalizer.execution_status === "running"
+            ? { finalizerStatus: terminalStatus }
+            : snapshot.finalizer.execution_status === "pending"
+                ? { finalizerStatus: "skipped" }
+                : {}),
+    };
+}
+function delegateExecutionActive(lifecycle) {
+    const snapshot = lifecycle.snapshot;
+    return snapshot?.curator.execution_status === "running" ||
+        snapshot?.finalizer.execution_status === "running";
+}
+function evidenceClassesByCandidate(candidates) {
+    return new Map(candidates.map((candidate) => [
+        `${candidate.root_index}\u0000${candidate.path}`,
+        candidate.evidence_classes ?? [],
+    ]));
+}
+function evaluateSelectionCoverage(input) {
+    const classesByCandidate = evidenceClassesByCandidate(input.candidates);
+    const selectedClasses = input.selected.flatMap((file) => classesByCandidate.get(`${file.root_index}\u0000${file.path}`) ?? []);
+    return evaluateContextCoverage({
+        policy: input.policy,
+        available: input.candidates.flatMap((candidate) => candidate.evidence_classes ?? []),
+        selected: selectedClasses,
+        unclassifiable: input.policy.id == null
+            ? []
+            : ["public_entrypoint", "reverse_consumer"],
+        ...(input.obligations == null ? {} : { obligations: input.obligations }),
+        selectedRanges: input.selected,
+    });
+}
+function delegateCoverageSelectionFailure(selected, candidates, coveragePolicy) {
+    try {
+        validateContextBuilderDelegateCoverageSelection(selected.map((file) => ({
+            candidate_id: contextBuilderCandidateId(file.root_index, file.path),
+            ranges: file.ranges,
+        })), candidates, coveragePolicy);
+        return null;
     }
-    return axes;
-}
-function runtimeSettingsDiscoveryQaAxes(task) {
-    const normalized = task.toLowerCase();
-    const axes = [
-        {
-            label: "runtime settings UI control flow",
-            matches: (path) => {
-                const normalizedPath = path.toLowerCase();
-                return (normalizedPath.endsWith("/hooks/usechatruntimesettings.ts") ||
-                    normalizedPath.endsWith("/components/chat/message-input/composerruntimecontrols.tsx") ||
-                    normalizedPath.endsWith("/components/chat/message-input/input.tsx") ||
-                    normalizedPath.endsWith("/pages/chatpage.tsx"));
-            },
-        },
-        {
-            label: "runtime settings dispatch and persistence flow",
-            matches: (path) => {
-                const normalizedPath = path.toLowerCase();
-                return (normalizedPath.endsWith("/services/chatservice.ts") ||
-                    normalizedPath.endsWith("/api/endpoints/chat.py") ||
-                    normalizedPath.endsWith("/services/chat.py") ||
-                    normalizedPath.endsWith("/store/messagequeuestore.ts"));
-            },
-        },
-    ];
-    if (/\b(provider|session|approval|permission|runtime)\b/.test(normalized)) {
-        axes.push({
-            label: "runtime provider/session support flow",
-            matches: (path) => {
-                const normalizedPath = path.toLowerCase();
-                return (normalizedPath.endsWith("/services/runtime/codex.py") ||
-                    normalizedPath.endsWith("/services/runtime/claude.py") ||
-                    normalizedPath.endsWith("/services/runtime/codex_approval.py") ||
-                    normalizedPath.endsWith("/services/runtime_session_service.py") ||
-                    normalizedPath.endsWith("/models/db_models/runtime_session.py"));
-            },
-        });
+    catch (error) {
+        return error instanceof Error ? error.message : String(error);
     }
-    return axes;
 }
 async function rejectArtifactOnlySourceRoots(inputRoots, input) {
     if (artifactOnlyAllowedRoots.size === 0) {
@@ -467,13 +530,70 @@ async function rejectArtifactOnlySourceRoots(inputRoots, input) {
         }
     }
 }
+/**
+ * Fail-fast admission check: an explicitly-focused path that the caller's own
+ * (or the default) globs would prune is a contradictory request. Discovery
+ * only surfaces these later, one gate at a time, as fatal runtime omissions,
+ * so aggregate EVERY conflict up front into one InvalidParamsError before any
+ * scanning or delegate subprocess work begins.
+ *
+ * The check mirrors discovery's glob semantics exactly: the matcher is
+ * compiled from include_globs plus CONTEXT_BUILDER_DEFAULT_EXCLUDE_GLOBS +
+ * exclude_globs (discoverContextBuilderCandidates does the same), focus FILES
+ * are matched on their own root-relative path (processFile's includes/excludes
+ * gates), and focus DIRECTORIES are flagged only when the directory itself is
+ * exclude-pruned via the same `<dir>` / `<dir>/__dir__` probes traverseDirectory
+ * uses. Ancestor-directory exclusion and directory-vs-include pruning are
+ * deliberately NOT modeled here (they depend on traversal state), so anything
+ * not flagged falls through to discovery's existing runtime handling.
+ */
+function assertNoContextBuilderFocusGlobConflicts(input) {
+    const matcher = compileContextBuilderGlobs({
+        include: [...input.includeGlobs],
+        exclude: [
+            ...CONTEXT_BUILDER_DEFAULT_EXCLUDE_GLOBS,
+            ...input.excludeGlobs,
+        ],
+    });
+    const conflicts = [];
+    const seen = new Set();
+    for (const focus of input.focusPaths) {
+        const relative = focus.root_relative_path;
+        if (relative === "") {
+            continue;
+        }
+        const key = `${focus.root_index}\u0000${relative}\u0000${focus.kind}`;
+        if (seen.has(key)) {
+            continue;
+        }
+        seen.add(key);
+        if (focus.kind === "directory") {
+            if (matcher.excludes(relative) ||
+                matcher.excludes(`${relative}/__dir__`)) {
+                conflicts.push(`focus directory "${relative}" (root_index ${focus.root_index}) is pruned by exclude_globs`);
+            }
+            continue;
+        }
+        if (matcher.excludes(relative)) {
+            conflicts.push(`focus path "${relative}" (root_index ${focus.root_index}) is omitted by exclude_globs`);
+            continue;
+        }
+        if (!matcher.includes(relative)) {
+            conflicts.push(`focus path "${relative}" (root_index ${focus.root_index}) is outside include_globs`);
+        }
+    }
+    if (conflicts.length > 0) {
+        throw new InvalidParamsError(`context_builder focus_paths conflict with the effective include/exclude globs (${conflicts.length} conflict${conflicts.length === 1 ? "" : "s"}): ${conflicts.join("; ")}`);
+    }
+}
 function getExactlyConfiguredArtifactRoots() {
     const rawEntries = rawAllowedRootEntries();
     const configured = new Set();
     const cwd = path.resolve(process.cwd());
     for (const artifactRoot of artifactOnlyAllowedRoots) {
         for (const rawEntry of rawEntries) {
-            if (rawEntry === artifactOnlyEnvEntry(artifactRoot)) {
+            if (isArtifactOnlyAllowedRootEntry(rawEntry) &&
+                realpathSyncOrUndefined(path.resolve(cwd, stripArtifactOnlyMarker(rawEntry))) === artifactRoot) {
                 continue;
             }
             const resolvedEntry = realpathSyncOrUndefined(path.resolve(cwd, rawEntry));
@@ -486,37 +606,7 @@ function getExactlyConfiguredArtifactRoots() {
     return configured;
 }
 function appendArtifactOnlyRootToEnv(runsDir) {
-    const raw = process.env["CLINKX_ALLOWED_ROOTS"];
-    const cwd = path.resolve(process.cwd());
-    const entries = raw == null || raw.trim() === ""
-        ? [cwd]
-        : rawAllowedRootEntries();
-    let runsDirAlreadyAllowed = false;
-    for (const entry of entries) {
-        const resolved = tryResolveRawAllowedRootEntry(entry, cwd);
-        if (resolved != null && resolved === runsDir) {
-            runsDirAlreadyAllowed = true;
-        }
-    }
-    process.env["CLINKX_ALLOWED_ROOTS"] = [
-        ...entries,
-        ...(runsDirAlreadyAllowed ? [] : [artifactOnlyEnvEntry(runsDir)]),
-    ].join(",");
-}
-function tryResolveRawAllowedRootEntry(entry, cwd) {
-    try {
-        const resolved = realpathSync(path.resolve(cwd, entry));
-        if (path.parse(resolved).root === resolved) {
-            throw new InvalidParamsError(`Allowed root must not be a filesystem root: ${resolved}`);
-        }
-        return resolved;
-    }
-    catch (error) {
-        if (error instanceof InvalidParamsError) {
-            throw error;
-        }
-        return undefined;
-    }
+    appendArtifactOnlyRootsToEnv([runsDir], { requireExisting: false });
 }
 function rawAllowedRootEntries() {
     const raw = process.env["CLINKX_ALLOWED_ROOTS"];
@@ -528,9 +618,6 @@ function rawAllowedRootEntries() {
         .map((root) => root.trim())
         .filter((root) => root.length > 0);
 }
-function artifactOnlyEnvEntry(root) {
-    return root.endsWith(path.sep) ? `${root}.` : `${root}${path.sep}.`;
-}
 function realpathSyncOrUndefined(input) {
     try {
         return realpathSync(input);
@@ -540,12 +627,7 @@ function realpathSyncOrUndefined(input) {
     }
 }
 function getDefaultContextBuilderSemaphore() {
-    const limit = getContextBuilderMaxConcurrent();
-    if (defaultSemaphore == null ||
-        defaultSemaphore.limit !== limit) {
-        defaultSemaphore = new ContextBuilderSemaphore(limit);
-    }
-    return defaultSemaphore;
+    return getSharedContextBuilderSemaphore();
 }
 function getDefaultAdapterRegistry() {
     if (defaultAdapterRegistry == null) {
@@ -594,6 +676,7 @@ async function resolveDelegateSelection(input) {
     const finalizerEnabled = contextBuilderFinalizerEnabled(input.input);
     const delegatePacketInput = {
         task: input.input.task,
+        allowSecrets: input.input.allow_secrets,
         discovery: {
             tree: input.discovery.tree,
             content_candidates: input.discovery.content_candidates,
@@ -601,38 +684,78 @@ async function resolveDelegateSelection(input) {
             slices: input.discovery.slices,
             omissions: [...input.baselineOmissions, ...input.discovery.omissions],
             metrics: input.discovery.metrics,
+            ...(input.discovery.review_obligations == null
+                ? {}
+                : { review_obligations: input.discovery.review_obligations }),
         },
         selection: input.deterministicSelection,
         budget: input.input.budget,
         focus_paths: input.focusPaths,
+        caller_search_terms: input.input.search_terms,
+        coveragePolicy: input.coveragePolicy,
         ...(input.delegatePacketCaps == null
             ? {}
             : { caps: input.delegatePacketCaps }),
     };
     const candidateFallbackCount = input.deterministicSelection.selected.length;
+    let curatorMs = null;
+    let finalizerMs = null;
+    let delegatePacketSize = 0;
+    // Compaction counters from the last-built packet (finalizer overrides
+    // curator) and bounded T3 evidence warnings, surfaced additively.
+    let delegatePacketCompaction;
+    const packetEvidenceWarnings = [];
+    const recordPacketEvidenceWarning = (warning) => {
+        if (warning == null ||
+            packetEvidenceWarnings.some((existing) => existing.code === warning.code)) {
+            return;
+        }
+        packetEvidenceWarnings.push({
+            code: warning.code,
+            message: warning.message,
+        });
+    };
+    const currentDelegateObservability = () => ({
+        curator_ms: curatorMs,
+        finalizer_ms: finalizerMs,
+        delegate_packet_size: delegatePacketSize,
+        ...(delegatePacketCompaction == null
+            ? {}
+            : { delegate_packet_compaction: delegatePacketCompaction }),
+    });
+    const sessionLogOwner = (executor) => input.sessionLogContext == null
+        ? undefined
+        : {
+            family: "context",
+            contextRunId: input.sessionLogContext.contextRunId,
+            contextGeneration: input.sessionLogContext.contextGeneration,
+            executor,
+            executionId: `${executor}_${input.sessionLogContext.contextRunId.slice(-32)}`,
+            attempt: 1,
+        };
     const requestedFocusOmissions = input.discovery.omissions.filter(isRequestedEvidenceOmission);
     if (requestedFocusOmissions.length > 0) {
         return handleDelegateRuntimeFailure({
             delegate,
-            reason: `requested local evidence omitted: ${requestedFocusOmissions
-                .map(formatOmissionForDelegateFailure)
-                .join("; ")}`,
+            reason: `requested local evidence omitted: ${formatOmissionsForDelegateFailure(requestedFocusOmissions)}`,
             deterministicSelection: input.deterministicSelection,
             omissionCount: input.baselineOmissions.length +
                 input.discovery.omissions.length +
                 input.deterministicSelection.omissions.length,
             candidateFallbackCount,
+            observability: currentDelegateObservability(),
         });
     }
-    await input.progress?.emit("curating");
+    await input.lifecycle?.transition("curating", { curatorStatus: "running" });
     const curatorPacket = buildContextBuilderCuratorPacket(delegatePacketInput);
+    delegatePacketSize = curatorPacket.metrics.packet_estimated_tokens;
+    delegatePacketCompaction = curatorPacket.metrics.compaction;
+    recordPacketEvidenceWarning(curatorPacket.evidence_warning);
     const curatorPacketRequestedOmissions = curatorPacket.omissions.filter(isRequestedEvidenceOmission);
     if (curatorPacketRequestedOmissions.length > 0) {
         return handleDelegateRuntimeFailure({
             delegate,
-            reason: `requested local evidence omitted: ${curatorPacketRequestedOmissions
-                .map(formatOmissionForDelegateFailure)
-                .join("; ")}`,
+            reason: `requested local evidence omitted: ${formatOmissionsForDelegateFailure(curatorPacketRequestedOmissions)}`,
             deterministicSelection: input.deterministicSelection,
             omissions: curatorPacketRequestedOmissions,
             omissionCount: input.baselineOmissions.length +
@@ -640,6 +763,7 @@ async function resolveDelegateSelection(input) {
                 input.deterministicSelection.omissions.length +
                 curatorPacketRequestedOmissions.length,
             candidateFallbackCount,
+            observability: currentDelegateObservability(),
         });
     }
     if (curatorPacket.candidates.length === 0) {
@@ -651,8 +775,11 @@ async function resolveDelegateSelection(input) {
                 input.discovery.omissions.length +
                 input.deterministicSelection.omissions.length,
             candidateFallbackCount,
+            observability: currentDelegateObservability(),
         });
     }
+    const curatorStartMs = Date.now();
+    const curatorSessionLogOwner = sessionLogOwner("curator");
     const curatorCall = await runContextBuilderDelegateCall({
         prompt: renderDelegatePrompt("curator", curatorPacket),
         provider: delegate.curator,
@@ -660,16 +787,22 @@ async function resolveDelegateSelection(input) {
         timeout_seconds: delegate.timeout_seconds,
         max_response_chars: delegate.max_response_chars,
         ...(input.signal == null ? {} : { signal: input.signal }),
+        ...(curatorSessionLogOwner == null
+            ? {}
+            : { sessionLogOwner: curatorSessionLogOwner }),
     });
+    curatorMs = Math.max(0, Date.now() - curatorStartMs);
     if (!curatorCall.ok) {
         return handleDelegateRuntimeFailure({
             delegate,
             reason: failureReasonFromCall("curator", curatorCall),
+            failureKind: curatorCall.reason,
             deterministicSelection: input.deterministicSelection,
             omissionCount: input.baselineOmissions.length +
                 input.discovery.omissions.length +
                 input.deterministicSelection.omissions.length,
             candidateFallbackCount,
+            observability: currentDelegateObservability(),
         });
     }
     let curatorProposal;
@@ -678,6 +811,8 @@ async function resolveDelegateSelection(input) {
         const validatedCuratorProposal = validateContextBuilderCuratorOutput(curatorCall.json, {
             candidates: curatorPacket.candidates,
             budget: input.input.budget,
+            allowSecrets: input.input.allow_secrets,
+            coveragePolicy: curatorPacket.coverage_policy,
         });
         curatorProposal = augmentCuratorProposalWithDeterministicBaseline(validatedCuratorProposal, curatorPacket, input.input.budget.max_files);
         curatorSelection = reconstructContextBuilderDelegateSelection({
@@ -727,6 +862,7 @@ async function resolveDelegateSelection(input) {
                 input.discovery.omissions.length +
                 input.deterministicSelection.omissions.length,
             candidateFallbackCount,
+            observability: currentDelegateObservability(),
         });
     }
     if (curatorSelection.selected.length === 0) {
@@ -738,24 +874,62 @@ async function resolveDelegateSelection(input) {
                 input.discovery.omissions.length +
                 input.deterministicSelection.omissions.length,
             candidateFallbackCount,
+            observability: currentDelegateObservability(),
         });
     }
     if (!finalizerEnabled) {
-        const repairedSelection = repairDelegateSelectionForTask({
+        const repairedSelection = repairDelegateSelection({
             curatorSelection,
-            deterministicSelection: input.deterministicSelection,
             contentCandidates: input.discovery.content_candidates,
             focusPaths: input.focusPaths,
             budget: input.input.budget,
-            task: input.input.task,
-            sourceRoots: input.sourceRoots,
+            expandSelectedFiles: true,
         });
         const warnings = curatorProposal.warnings.map((message) => delegateWarning("delegate_curator_warning", message));
+        warnings.push(...packetEvidenceWarnings);
         appendDelegateRepairWarnings(warnings, repairedSelection);
-        const openQuestions = curatorProposal.open_questions.map(sanitizeDiagnosticText);
+        const openQuestions = curatorProposal.open_questions.map((question) => sanitizeDiagnosticText(question));
         const omissionCount = input.baselineOmissions.length +
             input.discovery.omissions.length +
             repairedSelection.selection.omissions.length;
+        const delegateEvidenceCoverageFailure = delegateCoverageSelectionFailure(restoreDroppedDegenerateReviewTargetsForValidation({
+            preRepairSelected: curatorSelection.selected,
+            postRepairSelected: repairedSelection.selection.selected,
+            candidates: curatorPacket.candidates,
+            coveragePolicy: curatorPacket.coverage_policy,
+        }), curatorPacket.candidates, curatorPacket.coverage_policy);
+        if (delegateEvidenceCoverageFailure != null) {
+            return handleDelegateRuntimeFailure({
+                delegate,
+                reason: `post-repair evidence coverage failed: ${delegateEvidenceCoverageFailure}`,
+                deterministicSelection: input.deterministicSelection,
+                omissionCount,
+                candidateFallbackCount,
+                observability: currentDelegateObservability(),
+            });
+        }
+        // Re-verify required-focus presence against the actual returned selection.
+        // The curator-only branch does not fold required-focus ranges, so it checks
+        // whole-file presence here; range coverage is re-verified only in the
+        // finalizer branch, which folds requested focus evidence first.
+        const curatorOnlyCoverageFailure = postRepairRequiredFocusEvictionFailure({
+            focusPaths: input.focusPaths,
+            candidates: curatorPacket.candidates,
+            preRepairSelected: curatorSelection.selected,
+            postRepairSelected: repairedSelection.selection.selected,
+        });
+        if (curatorOnlyCoverageFailure != null) {
+            return handleDelegateRuntimeFailure({
+                delegate,
+                reason: `post-repair required-focus coverage failed: ${curatorOnlyCoverageFailure}`,
+                deterministicSelection: input.deterministicSelection,
+                omissionCount: input.baselineOmissions.length +
+                    input.discovery.omissions.length +
+                    input.deterministicSelection.omissions.length,
+                candidateFallbackCount,
+                observability: currentDelegateObservability(),
+            });
+        }
         return {
             selection: repairedSelection.selection,
             warnings,
@@ -772,21 +946,26 @@ async function resolveDelegateSelection(input) {
                 warning_count: warnings.length,
                 omission_count: omissionCount,
             },
+            observability: currentDelegateObservability(),
         };
     }
-    await input.progress?.emit("finalizing");
+    await input.lifecycle?.transition("finalizing", {
+        curatorStatus: "succeeded",
+        finalizerStatus: "running",
+    });
     const finalizerPacket = buildContextBuilderFinalizerPacket({
         ...delegatePacketInput,
         selection: curatorSelection,
         curator_proposal: curatorProposal,
     });
+    delegatePacketSize = finalizerPacket.metrics.packet_estimated_tokens;
+    delegatePacketCompaction = finalizerPacket.metrics.compaction;
+    recordPacketEvidenceWarning(finalizerPacket.evidence_warning);
     const finalizerPacketRequestedOmissions = finalizerPacket.omissions.filter(isRequestedEvidenceOmission);
     if (finalizerPacketRequestedOmissions.length > 0) {
         return handleDelegateRuntimeFailure({
             delegate,
-            reason: `requested local evidence omitted: ${finalizerPacketRequestedOmissions
-                .map(formatOmissionForDelegateFailure)
-                .join("; ")}`,
+            reason: `requested local evidence omitted: ${formatOmissionsForDelegateFailure(finalizerPacketRequestedOmissions)}`,
             deterministicSelection: input.deterministicSelection,
             omissions: finalizerPacketRequestedOmissions,
             omissionCount: input.baselineOmissions.length +
@@ -794,6 +973,7 @@ async function resolveDelegateSelection(input) {
                 input.deterministicSelection.omissions.length +
                 finalizerPacketRequestedOmissions.length,
             candidateFallbackCount,
+            observability: currentDelegateObservability(),
         });
     }
     if ((finalizerPacket.curator_proposal?.selected.length ?? 0) === 0) {
@@ -805,25 +985,36 @@ async function resolveDelegateSelection(input) {
                 input.discovery.omissions.length +
                 input.deterministicSelection.omissions.length,
             candidateFallbackCount,
+            observability: currentDelegateObservability(),
         });
     }
+    const finalizerStartMs = Date.now();
+    const finalizerSessionLogOwner = sessionLogOwner("finalizer");
     const finalizerCall = await runContextBuilderDelegateCall({
-        prompt: renderDelegatePrompt("finalizer", finalizerPacket),
+        prompt: renderDelegatePrompt("finalizer", finalizerPacket, {
+            minScore: delegate.finalizer.min_score,
+        }),
         provider: delegate.finalizer,
         registry: input.registry,
         timeout_seconds: delegate.timeout_seconds,
         max_response_chars: delegate.max_response_chars,
         ...(input.signal == null ? {} : { signal: input.signal }),
+        ...(finalizerSessionLogOwner == null
+            ? {}
+            : { sessionLogOwner: finalizerSessionLogOwner }),
     });
+    finalizerMs = Math.max(0, Date.now() - finalizerStartMs);
     if (!finalizerCall.ok) {
         return handleDelegateRuntimeFailure({
             delegate,
             reason: failureReasonFromCall("finalizer", finalizerCall),
+            failureKind: finalizerCall.reason,
             deterministicSelection: input.deterministicSelection,
             omissionCount: input.baselineOmissions.length +
                 input.discovery.omissions.length +
                 input.deterministicSelection.omissions.length,
             candidateFallbackCount,
+            observability: currentDelegateObservability(),
         });
     }
     try {
@@ -831,6 +1022,8 @@ async function resolveDelegateSelection(input) {
             candidates: finalizerPacket.candidates,
             budget: input.input.budget,
             minScore: delegate.finalizer.min_score,
+            allowSecrets: input.input.allow_secrets,
+            coveragePolicy: finalizerPacket.coverage_policy,
         });
         if (finalizerProposal.omissions.length > 0) {
             return handleDelegateRuntimeFailure({
@@ -842,6 +1035,7 @@ async function resolveDelegateSelection(input) {
                     input.deterministicSelection.omissions.length +
                     finalizerProposal.omissions.length,
                 candidateFallbackCount,
+                observability: currentDelegateObservability(),
             });
         }
         const foldedFinalizerSelection = foldRequiredFocusEvidenceIntoSelection(finalizerProposal.selected, requiredFocusEvidenceSelections({
@@ -865,25 +1059,23 @@ async function resolveDelegateSelection(input) {
                     input.discovery.omissions.length +
                     input.deterministicSelection.omissions.length,
                 candidateFallbackCount,
+                observability: currentDelegateObservability(),
             });
         }
-        if (finalSelection.omissions.length > 0) {
-            return handleDelegateRuntimeFailure({
-                delegate,
-                reason: `finalizer selection exceeded local reconstruction budget: ${finalSelection.omissions
-                    .map(formatOmissionForDelegateFailure)
-                    .join("; ")}`,
-                deterministicSelection: input.deterministicSelection,
-                omissionCount: input.baselineOmissions.length +
-                    input.discovery.omissions.length +
-                    finalSelection.omissions.length,
-                candidateFallbackCount,
-            });
-        }
+        // A per-file reconstruction-budget overrun no longer fails the entire
+        // delegate selection. Over-budget candidates (e.g. large generated/i18n
+        // catalogs the finalizer over-selected) are dropped while the rest of the
+        // curated bundle is retained. Completeness is re-checked against the
+        // MATERIALIZED (post-budget) selection, so a dropped REQUIRED-FOCUS file
+        // still fails closed below, while non-required oversized files are pruned
+        // and surfaced as a warning further down rather than collapsing the bundle.
+        // Required-focus coverage is additionally re-verified against the
+        // post-repair selection below, so eviction/compaction during repair also
+        // fails closed.
         const completenessFailure = delegateCompletenessFailure({
             focusPaths: input.focusPaths,
             candidates: finalizerPacket.candidates,
-            finalizerSelected: foldedFinalizerSelection.selected,
+            finalizerSelected: materializeFinalizerSelection(finalSelection.selected, finalizerPacket.candidates),
             curatorWarnings: curatorProposal.warnings,
             finalizerWarnings: finalizerProposal.warnings,
         });
@@ -896,17 +1088,49 @@ async function resolveDelegateSelection(input) {
                     input.discovery.omissions.length +
                     input.deterministicSelection.omissions.length,
                 candidateFallbackCount,
+                observability: currentDelegateObservability(),
             });
         }
-        const repairedSelection = repairDelegateSelectionForTask({
+        const repairedSelection = repairDelegateSelection({
             curatorSelection: finalSelection,
-            deterministicSelection: input.deterministicSelection,
             contentCandidates: input.discovery.content_candidates,
             focusPaths: input.focusPaths,
             budget: input.input.budget,
-            task: input.input.task,
-            sourceRoots: input.sourceRoots,
+            expandSelectedFiles: false,
+        });
+        const delegateEvidenceCoverageFailure = delegateCoverageSelectionFailure(repairedSelection.selection.selected, finalizerPacket.candidates, finalizerPacket.coverage_policy);
+        if (delegateEvidenceCoverageFailure != null) {
+            return handleDelegateRuntimeFailure({
+                delegate,
+                reason: `post-repair evidence coverage failed: ${delegateEvidenceCoverageFailure}`,
+                deterministicSelection: input.deterministicSelection,
+                omissionCount: input.baselineOmissions.length +
+                    input.discovery.omissions.length +
+                    repairedSelection.selection.omissions.length,
+                candidateFallbackCount,
+                observability: currentDelegateObservability(),
+            });
+        }
+        // Re-verify required-focus completeness against the actual returned
+        // selection. This keeps the fallback contract tied to the final materialized
+        // packet rather than the delegate's requested selection.
+        const postRepairCoverageFailure = requiredFocusCoverageFailure({
+            focusPaths: input.focusPaths,
+            candidates: finalizerPacket.candidates,
+            finalizerSelected: materializeFinalizerSelection(repairedSelection.selection.selected, finalizerPacket.candidates),
         });
+        if (postRepairCoverageFailure != null) {
+            return handleDelegateRuntimeFailure({
+                delegate,
+                reason: `post-repair required-focus coverage failed: ${postRepairCoverageFailure}`,
+                deterministicSelection: input.deterministicSelection,
+                omissionCount: input.baselineOmissions.length +
+                    input.discovery.omissions.length +
+                    input.deterministicSelection.omissions.length,
+                candidateFallbackCount,
+                observability: currentDelegateObservability(),
+            });
+        }
         const warnings = [
             ...curatorProposal.warnings.map((message) => delegateWarning("delegate_curator_warning", message)),
             ...finalizerProposal.warnings.map((message) => delegateWarning("delegate_finalizer_warning", message)),
@@ -914,8 +1138,14 @@ async function resolveDelegateSelection(input) {
         if (foldedFinalizerSelection.foldedPaths.length > 0) {
             warnings.push(delegateWarning("delegate_finalizer_warning", `finalizer omitted requested local evidence; server folded it back into the selection: ${boundContextBuilderPathList(foldedFinalizerSelection.foldedPaths).join(", ")}`));
         }
+        if (finalSelection.omissions.length > 0) {
+            warnings.push(delegateWarning("delegate_finalizer_warning", `finalizer selection pruned to fit the local reconstruction budget; omitted: ${finalSelection.omissions
+                .map(formatOmissionForDelegateFailure)
+                .join("; ")}`));
+        }
+        warnings.push(...packetEvidenceWarnings);
         appendDelegateRepairWarnings(warnings, repairedSelection);
-        const openQuestions = curatorProposal.open_questions.map(sanitizeDiagnosticText);
+        const openQuestions = curatorProposal.open_questions.map((question) => sanitizeDiagnosticText(question));
         const omissionCount = input.baselineOmissions.length +
             input.discovery.omissions.length +
             repairedSelection.selection.omissions.length;
@@ -936,6 +1166,7 @@ async function resolveDelegateSelection(input) {
                 warning_count: warnings.length,
                 omission_count: omissionCount,
             },
+            observability: currentDelegateObservability(),
         };
     }
     catch (err) {
@@ -947,1193 +1178,74 @@ async function resolveDelegateSelection(input) {
         }
         return handleDelegateRuntimeFailure({
             delegate,
-            reason: failureReasonFromError("finalizer_validation", err, delegatePromptDiagnostic(finalizerPacket)),
+            reason: failureReasonFromError("finalizer_validation", err, `${delegatePromptDiagnostic(finalizerPacket)}${finalizerScoreDiagnostic(finalizerCall.json, delegate.finalizer.min_score)}`),
             deterministicSelection: input.deterministicSelection,
             omissionCount: input.baselineOmissions.length +
                 input.discovery.omissions.length +
                 input.deterministicSelection.omissions.length,
             candidateFallbackCount,
+            observability: currentDelegateObservability(),
         });
     }
 }
-function repairDelegateSelectionForTask(input) {
-    const focusExpanded = expandSelectedFocusFilesToFullCandidates(input.curatorSelection, input.contentCandidates, input.focusPaths, input.budget, input.task);
-    const closureExpanded = expandSelectedClosureFilesToFullCandidates(focusExpanded.selection, input.contentCandidates, input.task, input.budget);
-    const degenerateDropped = dropDegenerateSelectedSlices(closureExpanded.selection, input.contentCandidates, input.task);
-    const deterministicRetained = retainDeterministicClosureFiles(degenerateDropped.selection, input.deterministicSelection, input.budget, input.task);
-    const discoveredRetained = retainDiscoveredTaskCriticalFiles(deterministicRetained.selection, input.contentCandidates, input.task, input.budget);
-    const finalDegenerateDropped = dropDegenerateSelectedSlices(discoveredRetained.selection, input.contentCandidates, input.task);
-    const taskSpineRepaired = repairTaskSpineRanges({
-        selection: finalDegenerateDropped.selection,
-        candidates: input.contentCandidates,
-        budget: input.budget,
-        task: input.task,
-        sourceRoots: input.sourceRoots,
-    });
-    const runtimeNoisePruned = pruneRuntimeSettingsDiscoverySearchNoise(taskSpineRepaired, input.task);
-    const debugNoisePruned = pruneDebugTraceSearchNoise(runtimeNoisePruned, input.contentCandidates, input.budget, input.task);
-    const reviewNoisePruned = pruneCodexRuntimeReviewSearchNoise(debugNoisePruned, input.task);
-    return {
-        selection: reviewNoisePruned,
-        expandedCount: focusExpanded.expandedCount + closureExpanded.expandedCount,
-        deterministicRetainedCount: deterministicRetained.retainedCount,
-        discoveredRetainedCount: discoveredRetained.retainedCount,
-        evictedCount: discoveredRetained.evictedCount,
-        droppedDegenerateCount: degenerateDropped.droppedCount + finalDegenerateDropped.droppedCount,
-    };
-}
-function repairTaskSpineRanges(input) {
-    const specs = taskSpineRangeSpecs(input.task);
-    if (specs.length === 0) {
-        return input.selection;
-    }
-    const candidatesByKey = new Map(input.candidates.map((candidate) => [selectedFileKey(candidate), candidate]));
-    const repairBudget = taskSpineRepairBudget(input.budget);
-    let selected = [...input.selection.selected];
-    let selectedKeys = new Set(selected.map((file) => selectedFileKey(file)));
-    let totalBytes = input.selection.metrics.bytes_selected;
-    let totalTokens = input.selection.metrics.estimated_tokens;
-    for (const spec of specs) {
-        const selectedIndex = selected.findIndex((file) => spec.path.test(file.path.toLowerCase()));
-        const existing = selectedIndex >= 0 ? selected[selectedIndex] : undefined;
-        const candidate = existing == null
-            ? candidateForTaskSpineSpec(spec, input.candidates, input.sourceRoots)
-            : (localCandidateForTaskSpineSpec(spec, input.sourceRoots, existing.root_index) ??
-                candidatesByKey.get(selectedFileKey(existing)) ??
-                localCandidateFromSelectedFile(existing, input.sourceRoots));
-        if (candidate == null) {
-            continue;
-        }
-        const file = selectedFileFromCandidateRanges(candidate, spec.full
-            ? [{ start_line: 1, end_line: Math.max(1, candidate.line_count) }]
-            : spec.ranges, existing?.source ?? "search");
-        if (file == null) {
-            continue;
-        }
-        if (existing != null) {
-            const totalsWithoutFile = {
-                totalBytes: totalBytes - existing.bytes,
-                totalTokens: totalTokens - existing.estimated_tokens,
-            };
-            if (shouldReplaceWithTaskSpineRanges(existing.path, input.task) &&
-                file.bytes <= repairBudget.max_bytes_per_file &&
-                totalsWithoutFile.totalBytes + file.bytes <= repairBudget.max_total_bytes &&
-                totalsWithoutFile.totalTokens + file.estimated_tokens <=
-                    repairBudget.target_estimated_tokens) {
-                selected[selectedIndex] = file;
-                totalBytes = totalsWithoutFile.totalBytes + file.bytes;
-                totalTokens = totalsWithoutFile.totalTokens + file.estimated_tokens;
-                continue;
-            }
-            const merged = selectedFileFromCandidateRanges(candidate, [...existing.ranges, ...file.ranges], existing.source);
-            if (merged == null || merged.bytes <= existing.bytes) {
-                continue;
-            }
-            if (merged.bytes > input.budget.max_bytes_per_file ||
-                totalsWithoutFile.totalBytes + merged.bytes > input.budget.max_total_bytes ||
-                totalsWithoutFile.totalTokens + merged.estimated_tokens >
-                    repairBudget.target_estimated_tokens) {
-                if (shouldReplaceWithTaskSpineRanges(existing.path, input.task)) {
-                    if (file.bytes <= repairBudget.max_bytes_per_file &&
-                        totalsWithoutFile.totalBytes + file.bytes <=
-                            repairBudget.max_total_bytes &&
-                        totalsWithoutFile.totalTokens + file.estimated_tokens <=
-                            repairBudget.target_estimated_tokens) {
-                        selected[selectedIndex] = file;
-                        totalBytes = totalsWithoutFile.totalBytes + file.bytes;
-                        totalTokens = totalsWithoutFile.totalTokens + file.estimated_tokens;
-                        continue;
-                    }
-                }
-                const withoutExisting = selected.filter((item) => selectedFileKey(item) !== selectedFileKey(existing));
-                const keysWithoutExisting = new Set(withoutExisting.map((item) => selectedFileKey(item)));
-                const repaired = makeRoomForRequiredClosureFile({
-                    selected: withoutExisting,
-                    selectedKeys: keysWithoutExisting,
-                    totalBytes: totalsWithoutFile.totalBytes,
-                    totalTokens: totalsWithoutFile.totalTokens,
-                    file: shouldReplaceWithTaskSpineRanges(existing.path, input.task)
-                        ? file
-                        : merged,
-                    budget: repairBudget,
-                    task: input.task,
-                });
-                if (repaired == null) {
-                    continue;
-                }
-                const repairedFile = shouldReplaceWithTaskSpineRanges(existing.path, input.task)
-                    ? file
-                    : merged;
-                selected = [...repaired.selected, repairedFile];
-                selectedKeys = new Set(repaired.selectedKeys);
-                selectedKeys.add(selectedFileKey(repairedFile));
-                totalBytes = repaired.totalBytes + repairedFile.bytes;
-                totalTokens = repaired.totalTokens + repairedFile.estimated_tokens;
-                continue;
-            }
-            selected[selectedIndex] = merged;
-            totalBytes = totalsWithoutFile.totalBytes + merged.bytes;
-            totalTokens = totalsWithoutFile.totalTokens + merged.estimated_tokens;
-            continue;
-        }
-        if (!selectionFitsBudgetWithFile(selected, totalBytes, totalTokens, file, repairBudget)) {
-            const repaired = makeRoomForRequiredClosureFile({
-                selected,
-                selectedKeys,
-                totalBytes,
-                totalTokens,
-                file,
-                budget: repairBudget,
-                task: input.task,
-            });
-            if (repaired == null) {
-                continue;
-            }
-            selected = repaired.selected;
-            selectedKeys = repaired.selectedKeys;
-            totalBytes = repaired.totalBytes;
-            totalTokens = repaired.totalTokens;
-        }
-        selected.push(file);
-        selectedKeys.add(selectedFileKey(file));
-        totalBytes += file.bytes;
-        totalTokens += file.estimated_tokens;
+function restoreDroppedDegenerateReviewTargetsForValidation(input) {
+    const targetKeys = new Set((input.coveragePolicy.obligations?.targets ?? []).flatMap((target) => {
+        const candidate = input.candidates.find((item) => item.id === target.candidate_id);
+        return candidate == null
+            ? []
+            : [`${candidate.root_index}\u0000${candidate.path}`];
+    }));
+    if (targetKeys.size === 0) {
+        return [...input.postRepairSelected];
     }
-    return selectionWithSelectedFiles(input.selection, selected);
-}
-function taskSpineRepairBudget(budget) {
-    return {
-        ...budget,
-        target_estimated_tokens: budget.max_estimated_tokens,
-    };
-}
-function pruneDebugTraceSearchNoise(selection, candidates, budget, task) {
-    if (!isDevtoolsTraceDebugTask(task)) {
-        return selection;
-    }
-    const selected = selection.selected.filter((file) => file.source !== "search" || isDevtoolsTraceRelevantPath(file.path));
-    const pruned = selected.length === selection.selected.length
-        ? selection
-        : selectionWithSelectedFiles(selection, selected);
-    return expandSmallDevtoolsTraceFiles(pruned, candidates, budget);
-}
-function pruneRuntimeSettingsDiscoverySearchNoise(selection, task) {
-    if (!isRuntimeSettingsDiscoveryTask(task)) {
-        return selection;
-    }
-    const selected = selection.selected.filter((file) => file.source !== "search" ||
-        !isRuntimeSettingsDiscoverySearchNoisePath(file.path));
-    return selected.length === selection.selected.length
-        ? selection
-        : selectionWithSelectedFiles(selection, selected);
-}
-function pruneCodexRuntimeReviewSearchNoise(selection, task) {
-    if (!isCodexRuntimeReviewTask(task)) {
-        return selection;
-    }
-    const shouldPrunePath = (filePath) => isTangentialCodexRuntimeReviewUiPath(filePath) ||
-        isLowValueCodexRuntimeReviewNoisePath(filePath, task);
-    const selected = selection.selected.filter((file) => file.source === "focus" ||
-        !shouldPrunePath(file.path));
-    const search = selection.search.filter((record) => !shouldPrunePath(record.path));
-    const slices = selection.slices.filter((record) => record.source === "focus" || !shouldPrunePath(record.path));
-    const selectedKeys = new Set(selected.map(selectedFileKey));
-    const summaryFiles = selection.summary?.files.filter((file) => selectedKeys.has(selectedFileKey(file)) || !shouldPrunePath(file.path)) ?? [];
-    if (selected.length === selection.selected.length &&
-        search.length === selection.search.length &&
-        slices.length === selection.slices.length &&
-        summaryFiles.length === (selection.summary?.files.length ?? 0)) {
-        return selection;
-    }
-    const prunedSelection = selectionWithSelectedFiles(selection, selected);
+    const postRepairKeys = new Set(input.postRepairSelected.map((file) => selectedFileKey(file)));
+    const droppedDegenerateTargets = input.preRepairSelected.filter((file) => {
+        const key = selectedFileKey(file);
+        return (targetKeys.has(key) &&
+            !postRepairKeys.has(key) &&
+            file.content.trim().length === 0);
+    });
+    return [...input.postRepairSelected, ...droppedDegenerateTargets];
+}
+function repairDelegateSelection(input) {
+    const focusExpanded = input.expandSelectedFiles
+        ? expandSelectedFocusFilesToFullCandidates(input.curatorSelection, input.contentCandidates, input.focusPaths, input.budget)
+        : { selection: input.curatorSelection, expandedCount: 0 };
+    const smallSlicesExpanded = input.expandSelectedFiles
+        ? expandSelectedSmallFilesToFullCandidates(focusExpanded.selection, input.contentCandidates, input.focusPaths, input.budget)
+        : focusExpanded;
+    const emptyDropped = dropEmptySelectedFiles(smallSlicesExpanded.selection);
     return {
-        ...prunedSelection,
-        search,
-        slices,
-        ...(selection.summary == null ? {} : { summary: { files: summaryFiles } }),
+        selection: emptyDropped.selection,
+        expandedCount: focusExpanded.expandedCount + smallSlicesExpanded.expandedCount,
+        droppedDegenerateCount: emptyDropped.droppedCount,
     };
 }
-function rankTaskSpecificFinalSelection(selection, task) {
-    if (!isRuntimeSettingsDiscoveryTask(task) && !isDevtoolsTraceDebugTask(task)) {
-        return selection;
-    }
-    const indexed = selection.selected.map((file, index) => ({ file, index }));
-    indexed.sort((left, right) => taskSpecificFinalSelectedRank(left.file.path, task) -
-        taskSpecificFinalSelectedRank(right.file.path, task) ||
-        left.index - right.index);
-    const selected = indexed.map((item) => item.file);
-    const orderChanged = selected.some((file, index) => selectedFileKey(file) !== selectedFileKey(selection.selected[index]));
-    return orderChanged ? selectionWithSelectedFiles(selection, selected) : selection;
-}
-function taskSpecificFinalSelectedRank(path, task) {
-    if (isRuntimeSettingsDiscoveryTask(task)) {
-        return runtimeSettingsDiscoveryFinalRank(path);
-    }
-    if (isDevtoolsTraceDebugTask(task)) {
-        return devtoolsTraceDebugFinalRank(path);
-    }
-    return 0;
-}
-function runtimeSettingsDiscoveryFinalRank(path) {
-    const normalized = path.toLowerCase();
-    const basename = normalized.split("/").at(-1) ?? normalized;
-    if (normalized.endsWith("/hooks/usechatruntimesettings.ts")) {
-        return 0;
-    }
-    if (normalized.endsWith("/components/chat/message-input/composerruntimecontrols.tsx")) {
-        return 1;
-    }
-    if (normalized.endsWith("/components/chat/message-input/input.tsx")) {
-        return 2;
-    }
-    if (normalized.endsWith("/pages/chatpage.tsx")) {
-        return 3;
-    }
-    if (normalized.endsWith("/services/chatservice.ts") ||
-        normalized.endsWith("/api/endpoints/chat.py") ||
-        normalized.endsWith("/services/chat.py")) {
-        return 4;
-    }
-    if (normalized.endsWith("/store/messagequeuestore.ts") ||
-        normalized.endsWith("/store/__tests__/messagequeuestore.test.ts") ||
-        normalized.endsWith("/services/queueservice.ts") ||
-        normalized.endsWith("/tests/services/test_queue.py") ||
-        normalized.endsWith("/tests/test_queue.py") ||
-        normalized.endsWith("/tests/services/test_pending_initial_prompt_service.py")) {
-        return 5;
-    }
-    if (normalized.endsWith("/services/runtime/codex.py") ||
-        normalized.endsWith("/services/runtime/claude.py") ||
-        normalized.endsWith("/services/runtime/codex_approval.py") ||
-        normalized.endsWith("/services/runtime/codex_stream_processor.py") ||
-        normalized.endsWith("/services/runtime_session_service.py") ||
-        normalized.endsWith("/services/streaming/orchestrator.py")) {
-        return 6;
-    }
-    if (normalized.endsWith("/hooks/__tests__/usechatruntimesettings.test.ts") ||
-        normalized.endsWith("/pages/landingpage.test.tsx") ||
-        normalized.endsWith("/tests/services/runtime/test_codex_runtime.py") ||
-        normalized.endsWith("/tests/test_codex_runtime_data_migration.py") ||
-        normalized.endsWith("/tests/test_codex_effort_translation.py") ||
-        normalized.endsWith("/tests/test_effort_level.py") ||
-        normalized.endsWith("/tests/test_permission_mode.py") ||
-        normalized.endsWith("/tests/services/test_claude_agent.py")) {
-        return 7;
-    }
-    if (basename === "effort.py" ||
-        basename === "permission_mode.py" ||
-        basename === "chat.types.ts" ||
-        basename === "queue.types.ts" ||
-        normalized.endsWith("/models/schemas/chat.py") ||
-        normalized.endsWith("/models/db_models/chat.py") ||
-        normalized.endsWith("/models/db_models/runtime_session.py") ||
-        basename.includes("permissionmodeselector") ||
-        basename.includes("thinkingmodeselector")) {
-        return 8;
-    }
-    return 12;
-}
-function devtoolsTraceDebugFinalRank(path) {
-    const normalized = path.toLowerCase();
-    const basename = normalized.split("/").at(-1) ?? normalized;
-    if (normalized.endsWith("/components/right-panel/rightpaneldevtools.tsx") ||
-        basename === "rightpaneldevtools.tsx") {
-        return 0;
-    }
-    if (normalized.endsWith("/components/right-panel/__tests__/right-panel-devtools.test.tsx") ||
-        normalized.endsWith("/components/chat/__tests__/chat.autoscroll.test.tsx") ||
-        normalized.endsWith("/store/devtoolsnavstore.ts") ||
-        normalized.endsWith("/store/__tests__/devtoolsnavstore.test.ts")) {
-        return 1;
-    }
-    if (normalized.endsWith("/components/chat/chat-window/chat.tsx") ||
-        normalized.endsWith("/components/chat/message-bubble/messagerenderer.tsx") ||
-        normalized.endsWith("/components/chat/tools/common/toolcard.tsx")) {
-        return 2;
-    }
-    if (normalized.endsWith("/hooks/usemessagecache.ts") ||
-        normalized.endsWith("/utils/messagecacheorder.ts") ||
-        normalized.endsWith("/components/chat/tools/common/toolexpandcontext.ts") ||
-        normalized.endsWith("/components/chat/tools/common/__tests__/toolexpand.test.tsx")) {
-        return 3;
-    }
-    if (normalized.endsWith("/components/right-panel/devtools-helpers.ts") ||
-        normalized.endsWith("/components/right-panel/__tests__/devtools-helpers.test.ts") ||
-        normalized.endsWith("/services/devtoolsservice.ts") ||
-        normalized.endsWith("/hooks/queries/usedevtoolsqueries.ts")) {
-        return 4;
-    }
-    if (normalized.endsWith("/api/endpoints/devtools.py") ||
-        normalized.endsWith("/services/session_trace_archive.py") ||
-        normalized.endsWith("/services/codex_trace.py") ||
-        normalized.endsWith("/models/db_models/session_trace_archive.py") ||
-        normalized.endsWith("/models/schemas/devtools.py") ||
-        normalized.endsWith("/types/devtools.types.ts")) {
-        return 7;
-    }
-    return 10;
-}
-function isLowValueCodexRuntimeReviewNoisePath(path, task) {
-    const normalized = path.toLowerCase();
-    const normalizedTask = task.toLowerCase();
-    if (normalized.endsWith("/core/config.py") &&
-        !/\bconfig(?:uration)?\b/.test(normalizedTask)) {
-        return true;
+function appendDelegateRepairWarnings(warnings, repair) {
+    if (repair.expandedCount > 0) {
+        warnings.push(delegateWarning("delegate_curator_warning", `server-expanded ${repair.expandedCount} selected file(s) to full context`));
     }
-    if (normalized.endsWith("/tests/services/streaming/test_context_usage_payloads.py") &&
-        !/\bcontext\s+usage|usage\s+payloads?\b/.test(normalizedTask)) {
-        return true;
+    if (repair.droppedDegenerateCount > 0) {
+        warnings.push(delegateWarning("delegate_curator_warning", `server-dropped ${repair.droppedDegenerateCount} degenerate selected slice(s)`));
     }
-    return false;
 }
-function isRuntimeSettingsDiscoveryTask(task) {
-    const normalized = task.toLowerCase();
-    return (/\bdiscovery\b/.test(normalized) &&
-        normalized.includes("runtime") &&
-        /\bsettings?\b/.test(normalized));
-}
-function isCodexRuntimeReviewTask(task) {
-    const normalized = task.toLowerCase();
-    return (/\breview\b/.test(normalized) &&
-        normalized.includes("codex") &&
-        /\b(runtime|permission|effort|approval|session)\b/.test(normalized));
-}
-function isTangentialCodexRuntimeReviewUiPath(path) {
-    const normalized = path.toLowerCase();
-    const basename = normalized.split("/").at(-1) ?? normalized;
-    return (basename === "requestaccesspage.tsx" ||
-        basename === "providerauthmodal.tsx" ||
-        basename === "codexauthupload.tsx" ||
-        basename === "oauthcallbackpage.tsx" ||
-        basename === "subscriptionusagecard.tsx" ||
-        basename === "requestaccesspage.test.tsx" ||
-        basename === "oauthcallbackpage.test.tsx" ||
-        basename === "codexauthflow.test.tsx" ||
-        basename === "useauthbootstrap.test.ts" ||
-        basename === "providerauthservice.ratelimit.test.ts" ||
-        normalized.endsWith("docs/ops/nano-permissions-policy.md") ||
-        normalized.includes("/components/settings/inputs/") ||
-        normalized.includes("/components/settings/tabs/") ||
-        normalized.includes("/components/settings/__tests__/") ||
-        normalized.includes("/provider-auth/") ||
-        normalized.includes("/pages/requestaccess") ||
-        normalized.includes("/pages/oauthcallback") ||
-        normalized.includes("/services/checks/") ||
-        normalized.endsWith("/hooks/usestreamcallbacks.ts") ||
-        normalized.endsWith("/hooks/queries/querykeys.ts") ||
-        normalized.endsWith("/vite.config.ts") ||
-        normalized.endsWith("/api/endpoints/provider_auth.py") ||
-        normalized.endsWith("/api/endpoints/settings.py") ||
-        normalized.endsWith("/services/access_request.py") ||
-        normalized.endsWith("/models/schemas/access_request.py"));
-}
-function isRuntimeSettingsDiscoverySearchNoisePath(path) {
-    const normalized = path.toLowerCase();
-    const basename = normalized.split("/").at(-1) ?? normalized;
-    return (isTangentialRuntimeSettingsDiscoveryTestPath(normalized, basename) ||
-        normalized.includes("/tests/services/nightshift/") ||
-        normalized.includes("/tests/services/sandbox/") ||
-        normalized.endsWith("/test_codex_sdk_smoke.py") ||
-        normalized.endsWith("/test_codex_runtime_live.py") ||
-        normalized.endsWith("/test_transport_absence.py") ||
-        normalized.endsWith("/test_codex_approval_bridge.py") ||
-        normalized.endsWith("/test_codex_stream_processor.py") ||
-        normalized.endsWith("/test_codex_stream_processor_fixtures.py") ||
-        normalized.endsWith("/test_codex_runtime_invariants.py"));
-}
-function expandSmallDevtoolsTraceFiles(selection, candidates, budget) {
+function expandSelectedFocusFilesToFullCandidates(selection, candidates, focusPaths, budget) {
+    const focusKeys = new Set(focusPaths
+        .filter((focus) => focus.kind === "file")
+        .map((focus) => `${focus.root_index}\u0000${focus.root_relative_path}`));
+    if (focusKeys.size === 0) {
+        return { selection, expandedCount: 0 };
+    }
     const candidatesByKey = new Map(candidates.map((candidate) => [selectedFileKey(candidate), candidate]));
     let totalBytes = selection.metrics.bytes_selected;
     let totalTokens = selection.metrics.estimated_tokens;
     let expandedCount = 0;
     const selected = selection.selected.map((file) => {
-        if (!shouldExpandSmallDevtoolsTraceFile(file.path)) {
+        const key = selectedFileKey(file);
+        if (!focusKeys.has(key)) {
             return file;
         }
-        const candidate = candidatesByKey.get(selectedFileKey(file));
-        if (candidate == null || fileCoversCandidate(file, candidate)) {
-            return file;
-        }
-        const fullFile = selectedFileFromCandidate(candidate);
-        const totalsWithoutFile = {
-            totalBytes: totalBytes - file.bytes,
-            totalTokens: totalTokens - file.estimated_tokens,
-        };
-        if (fullFile.estimated_tokens > 8_000 ||
-            fullFile.bytes > budget.max_bytes_per_file ||
-            totalsWithoutFile.totalBytes + fullFile.bytes > budget.max_total_bytes ||
-            totalsWithoutFile.totalTokens + fullFile.estimated_tokens >
-                budget.target_estimated_tokens) {
-            return file;
-        }
-        totalBytes = totalsWithoutFile.totalBytes + fullFile.bytes;
-        totalTokens = totalsWithoutFile.totalTokens + fullFile.estimated_tokens;
-        expandedCount += 1;
-        return { ...fullFile, source: file.source };
-    });
-    if (expandedCount === 0) {
-        return selection;
-    }
-    return selectionWithSelectedFiles(selection, selected);
-}
-function taskSpineRangeSpecs(task) {
-    const normalized = task.toLowerCase();
-    const specs = [];
-    if ((/\bdiscovery\b/.test(normalized) && normalized.includes("runtime")) ||
-        isRuntimeSettingsPersistenceFlowTask(normalized)) {
-        specs.push({
-            path: /\/pages\/chatpage\.tsx$/,
-            exactPaths: ["frontend/src/pages/ChatPage.tsx"],
-            ranges: [
-                { start_line: 150, end_line: 292 },
-                { start_line: 640, end_line: 700 },
-            ],
-        }, {
-            path: /\/components\/chat\/message-input\/input\.tsx$/,
-            exactPaths: ["frontend/src/components/chat/message-input/Input.tsx"],
-            ranges: [
-                { start_line: 360, end_line: 630 },
-                { start_line: 1018, end_line: 1048 },
-            ],
-        }, {
-            path: /\/hooks\/usechatruntimesettings\.ts$/,
-            exactPaths: ["frontend/src/hooks/useChatRuntimeSettings.ts"],
-            ranges: [{ start_line: 1, end_line: Number.MAX_SAFE_INTEGER }],
-            full: true,
-        }, {
-            path: /\/services\/chatservice\.ts$/,
-            exactPaths: ["frontend/src/services/chatService.ts"],
-            ranges: [{ start_line: 1, end_line: Number.MAX_SAFE_INTEGER }],
-            full: true,
-        }, {
-            path: /\/services\/chat\.py$/,
-            exactPaths: ["backend/app/services/chat.py"],
-            ranges: [
-                { start_line: 160, end_line: 675 },
-                { start_line: 1033, end_line: 1163 },
-                { start_line: 1619, end_line: 1756 },
-                { start_line: 1758, end_line: 2179 },
-                { start_line: 2446, end_line: 2552 },
-                { start_line: 2563, end_line: 2610 },
-            ],
-        }, {
-            path: /\/api\/endpoints\/chat\.py$/,
-            exactPaths: ["backend/app/api/endpoints/chat.py"],
-            ranges: [
-                { start_line: 396, end_line: 468 },
-                { start_line: 528, end_line: 558 },
-                { start_line: 1298, end_line: 1383 },
-            ],
-        }, {
-            path: /\/store\/__tests__\/messagequeuestore\.test\.ts$/,
-            exactPaths: ["frontend/src/store/__tests__/messageQueueStore.test.ts"],
-            ranges: [
-                { start_line: 1, end_line: 121 },
-                { start_line: 123, end_line: 241 },
-                { start_line: 243, end_line: 320 },
-            ],
-        }, {
-            path: /\/store\/messagequeuestore\.ts$/,
-            exactPaths: ["frontend/src/store/messageQueueStore.ts"],
-            ranges: [
-                { start_line: 120, end_line: 155 },
-                { start_line: 208, end_line: 360 },
-                { start_line: 640, end_line: 760 },
-            ],
-        }, {
-            path: /\/tests\/.*test_pending_initial_prompt_service\.py$/,
-            exactPaths: ["backend/tests/services/test_pending_initial_prompt_service.py"],
-            ranges: [
-                { start_line: 1, end_line: 230 },
-                { start_line: 531, end_line: 592 },
-                { start_line: 1150, end_line: 1242 },
-                { start_line: 1245, end_line: 1400 },
-            ],
-        }, {
-            path: /\/services\/claude_agent\.py$/,
-            exactPaths: ["backend/app/services/claude_agent.py"],
-            ranges: [
-                { start_line: 44, end_line: 80 },
-                { start_line: 433, end_line: 466 },
-                { start_line: 786, end_line: 874 },
-                { start_line: 988, end_line: 1002 },
-            ],
-        }, {
-            path: /\/services\/runtime\/claude\.py$/,
-            exactPaths: ["backend/app/services/runtime/claude.py"],
-            ranges: [{ start_line: 1, end_line: Number.MAX_SAFE_INTEGER }],
-            full: true,
-        }, {
-            path: /\/services\/runtime\/codex_approval\.py$/,
-            exactPaths: ["backend/app/services/runtime/codex_approval.py"],
-            ranges: [
-                { start_line: 1, end_line: 135 },
-                { start_line: 193, end_line: 280 },
-                { start_line: 310, end_line: 386 },
-            ],
-        }, {
-            path: /\/services\/runtime\/codex\.py$/,
-            exactPaths: ["backend/app/services/runtime/codex.py"],
-            ranges: [
-                { start_line: 1, end_line: 82 },
-                { start_line: 87, end_line: 264 },
-                { start_line: 576, end_line: 621 },
-            ],
-        }, {
-            path: /\/services\/runtime_session_service\.py$/,
-            exactPaths: ["backend/app/services/runtime_session_service.py"],
-            ranges: [{ start_line: 1, end_line: Number.MAX_SAFE_INTEGER }],
-            full: true,
-        }, {
-            path: /\/models\/db_models\/runtime_session\.py$/,
-            exactPaths: ["backend/app/models/db_models/runtime_session.py"],
-            ranges: [{ start_line: 1, end_line: Number.MAX_SAFE_INTEGER }],
-            full: true,
-        }, {
-            path: /\/services\/permission_manager\.py$/,
-            exactPaths: ["backend/app/services/permission_manager.py"],
-            ranges: [
-                { start_line: 1, end_line: 160 },
-                { start_line: 220, end_line: 360 },
-            ],
-        }, {
-            path: /\/services\/runtime\/codex_stream_processor\.py$/,
-            exactPaths: ["backend/app/services/runtime/codex_stream_processor.py"],
-            ranges: [
-                { start_line: 94, end_line: 123 },
-                { start_line: 155, end_line: 227 },
-                { start_line: 263, end_line: 328 },
-            ],
-        }, {
-            path: /\/hooks\/__tests__\/usechatruntimesettings\.test\.ts$/,
-            exactPaths: ["frontend/src/hooks/__tests__/useChatRuntimeSettings.test.ts"],
-            ranges: [{ start_line: 1, end_line: Number.MAX_SAFE_INTEGER }],
-            full: true,
-        }, {
-            path: /\/tests\/services\/test_claude_agent\.py$/,
-            exactPaths: ["backend/tests/services/test_claude_agent.py"],
-            ranges: [
-                { start_line: 247, end_line: 325 },
-                { start_line: 325, end_line: 381 },
-                { start_line: 628, end_line: 705 },
-            ],
-        }, {
-            path: /\/models\/schemas\/chat\.py$/,
-            exactPaths: ["backend/app/models/schemas/chat.py"],
-            ranges: [{ start_line: 1, end_line: Number.MAX_SAFE_INTEGER }],
-            full: true,
-        }, {
-            path: /\/types\/chat\.types\.ts$/,
-            exactPaths: ["frontend/src/types/chat.types.ts"],
-            ranges: [{ start_line: 1, end_line: Number.MAX_SAFE_INTEGER }],
-            full: true,
-        }, {
-            path: /\/types\/queue\.types\.ts$/,
-            exactPaths: ["frontend/src/types/queue.types.ts"],
-            ranges: [{ start_line: 1, end_line: Number.MAX_SAFE_INTEGER }],
-            full: true,
-        }, {
-            path: /\/services\/streamservice\.ts$/,
-            exactPaths: ["frontend/src/services/streamService.ts"],
-            ranges: [
-                { start_line: 1, end_line: 140 },
-                { start_line: 260, end_line: 422 },
-            ],
-        }, {
-            path: /\/tests\/test_queue\.py$/,
-            exactPaths: ["backend/tests/test_queue.py"],
-            ranges: [
-                { start_line: 1, end_line: 120 },
-                { start_line: 430, end_line: 632 },
-            ],
-        }, {
-            path: /\/tests\/services\/test_queue\.py$/,
-            exactPaths: ["backend/tests/services/test_queue.py"],
-            ranges: [{ start_line: 1, end_line: Number.MAX_SAFE_INTEGER }],
-            full: true,
-        }, {
-            path: /\/tests\/test_effort_level\.py$/,
-            exactPaths: ["backend/tests/test_effort_level.py"],
-            ranges: [{ start_line: 1, end_line: Number.MAX_SAFE_INTEGER }],
-            full: true,
-        }, {
-            path: /\/tests\/test_permission_mode\.py$/,
-            exactPaths: ["backend/tests/test_permission_mode.py"],
-            ranges: [{ start_line: 1, end_line: Number.MAX_SAFE_INTEGER }],
-            full: true,
-        }, {
-            path: /\/tests\/services\/runtime\/test_codex_runtime\.py$/,
-            exactPaths: ["backend/tests/services/runtime/test_codex_runtime.py"],
-            ranges: [
-                { start_line: 1, end_line: 160 },
-                { start_line: 540, end_line: 776 },
-            ],
-        }, {
-            path: /\/tests\/test_codex_effort_translation\.py$/,
-            exactPaths: ["backend/tests/test_codex_effort_translation.py"],
-            ranges: [{ start_line: 1, end_line: Number.MAX_SAFE_INTEGER }],
-            full: true,
-        }, {
-            path: /\/hooks\/usepermissionrequest\.ts$/,
-            exactPaths: ["frontend/src/hooks/usePermissionRequest.ts"],
-            ranges: [{ start_line: 1, end_line: Number.MAX_SAFE_INTEGER }],
-            full: true,
-        }, {
-            path: /\/hooks\/queries\/usesettingsqueries\.ts$/,
-            exactPaths: ["frontend/src/hooks/queries/useSettingsQueries.ts"],
-            ranges: [{ start_line: 1, end_line: Number.MAX_SAFE_INTEGER }],
-            full: true,
-        });
-    }
-    if (/\breview\b/.test(normalized) && normalized.includes("codex")) {
-        specs.push({
-            path: /\/services\/runtime\/codex\.py$/,
-            exactPaths: ["backend/app/services/runtime/codex.py"],
-            ranges: [
-                { start_line: 130, end_line: 178 },
-                { start_line: 212, end_line: 392 },
-                { start_line: 394, end_line: 476 },
-                { start_line: 576, end_line: 621 },
-                { start_line: 698, end_line: 766 },
-            ],
-        }, {
-            path: /\/services\/runtime\/codex_stream_processor\.py$/,
-            exactPaths: ["backend/app/services/runtime/codex_stream_processor.py"],
-            ranges: [
-                { start_line: 94, end_line: 123 },
-                { start_line: 155, end_line: 227 },
-                { start_line: 263, end_line: 328 },
-            ],
-        }, {
-            path: /\/services\/runtime\/base\.py$/,
-            exactPaths: ["backend/app/services/runtime/base.py"],
-            ranges: [{ start_line: 1, end_line: Number.MAX_SAFE_INTEGER }],
-            full: true,
-        }, {
-            path: /\/services\/runtime\/claude\.py$/,
-            exactPaths: ["backend/app/services/runtime/claude.py"],
-            ranges: [{ start_line: 1, end_line: Number.MAX_SAFE_INTEGER }],
-            full: true,
-        }, {
-            path: /\/services\/runtime\/codex_approval\.py$/,
-            exactPaths: ["backend/app/services/runtime/codex_approval.py"],
-            ranges: [{ start_line: 1, end_line: Number.MAX_SAFE_INTEGER }],
-            full: true,
-        }, {
-            path: /\/services\/runtime\/resolver\.py$/,
-            exactPaths: ["backend/app/services/runtime/resolver.py"],
-            ranges: [{ start_line: 1, end_line: Number.MAX_SAFE_INTEGER }],
-            full: true,
-        }, {
-            path: /\/services\/runtime_session_service\.py$/,
-            exactPaths: ["backend/app/services/runtime_session_service.py"],
-            ranges: [{ start_line: 1, end_line: Number.MAX_SAFE_INTEGER }],
-            full: true,
-        }, {
-            path: /\/services\/streaming\/orchestrator\.py$/,
-            exactPaths: ["backend/app/services/streaming/orchestrator.py"],
-            ranges: [
-                { start_line: 979, end_line: 1173 },
-                { start_line: 1207, end_line: 1245 },
-            ],
-        }, {
-            path: /\/services\/sandbox\/provider\.py$/,
-            exactPaths: ["backend/app/services/sandbox/provider.py"],
-            ranges: [
-                { start_line: 1, end_line: 260 },
-                { start_line: 760, end_line: 920 },
-            ],
-        }, {
-            path: /\/services\/streaming\/context_usage\.py$/,
-            exactPaths: ["backend/app/services/streaming/context_usage.py"],
-            ranges: [{ start_line: 1, end_line: Number.MAX_SAFE_INTEGER }],
-            full: true,
-        }, {
-            path: /\/services\/providerauthservice\.ts$/,
-            exactPaths: ["frontend/src/services/providerAuthService.ts"],
-            ranges: [{ start_line: 1, end_line: Number.MAX_SAFE_INTEGER }],
-            full: true,
-        }, {
-            path: /\/services\/streamservice\.ts$/,
-            exactPaths: ["frontend/src/services/streamService.ts"],
-            ranges: [
-                { start_line: 1, end_line: 140 },
-                { start_line: 260, end_line: 422 },
-            ],
-        }, {
-            path: /\/hooks\/usechatruntimesettings\.ts$/,
-            exactPaths: ["frontend/src/hooks/useChatRuntimeSettings.ts"],
-            ranges: [{ start_line: 1, end_line: Number.MAX_SAFE_INTEGER }],
-            full: true,
-        }, {
-            path: /\/services\/permission_manager\.py$/,
-            exactPaths: ["backend/app/services/permission_manager.py"],
-            ranges: [{ start_line: 1, end_line: Number.MAX_SAFE_INTEGER }],
-            full: true,
-        }, {
-            path: /\/services\/model_provider_auth\.py$/,
-            exactPaths: ["backend/app/services/model_provider_auth.py"],
-            ranges: [{ start_line: 1, end_line: Number.MAX_SAFE_INTEGER }],
-            full: true,
-        }, {
-            path: /\/tests\/services\/test_model_provider_auth\.py$/,
-            exactPaths: ["backend/tests/services/test_model_provider_auth.py"],
-            ranges: [{ start_line: 1, end_line: Number.MAX_SAFE_INTEGER }],
-            full: true,
-        }, {
-            path: /\/tests\/services\/runtime\/test_codex_stream_processor\.py$/,
-            exactPaths: ["backend/tests/services/runtime/test_codex_stream_processor.py"],
-            ranges: [{ start_line: 1, end_line: Number.MAX_SAFE_INTEGER }],
-            full: true,
-        }, {
-            path: /\/tests\/services\/runtime\/test_codex_approval_bridge\.py$/,
-            exactPaths: ["backend/tests/services/runtime/test_codex_approval_bridge.py"],
-            ranges: [
-                { start_line: 1, end_line: 80 },
-                { start_line: 193, end_line: 280 },
-                { start_line: 310, end_line: 386 },
-                { start_line: 449, end_line: 565 },
-                { start_line: 953, end_line: 1068 },
-                { start_line: 1100, end_line: 1165 },
-            ],
-        }, {
-            path: /\/tests\/services\/runtime\/test_resolver\.py$/,
-            exactPaths: ["backend/tests/services/runtime/test_resolver.py"],
-            ranges: [{ start_line: 1, end_line: Number.MAX_SAFE_INTEGER }],
-            full: true,
-        }, {
-            path: /\/tests\/services\/test_runtime_session_service\.py$/,
-            exactPaths: ["backend/tests/services/test_runtime_session_service.py"],
-            ranges: [{ start_line: 1, end_line: Number.MAX_SAFE_INTEGER }],
-            full: true,
-        }, {
-            path: /\/api\/endpoints\/chat\.py$/,
-            exactPaths: ["backend/app/api/endpoints/chat.py"],
-            ranges: [
-                { start_line: 1, end_line: 120 },
-                { start_line: 390, end_line: 570 },
-                { start_line: 1215, end_line: 1400 },
-            ],
-        }, {
-            path: /\/api\/endpoints\/permissions\.py$/,
-            exactPaths: ["backend/app/api/endpoints/permissions.py"],
-            ranges: [{ start_line: 1, end_line: Number.MAX_SAFE_INTEGER }],
-            full: true,
-        }, {
-            path: /\/services\/chat\.py$/,
-            exactPaths: ["backend/app/services/chat.py"],
-            ranges: [
-                { start_line: 160, end_line: 675 },
-                { start_line: 777, end_line: 851 },
-                { start_line: 1131, end_line: 1177 },
-                { start_line: 1619, end_line: 1756 },
-                { start_line: 1878, end_line: 2170 },
-                { start_line: 2454, end_line: 2508 },
-                { start_line: 2570, end_line: 2594 },
-            ],
-        }, {
-            path: /\/services\/claude_agent\.py$/,
-            exactPaths: ["backend/app/services/claude_agent.py"],
-            ranges: [
-                { start_line: 44, end_line: 80 },
-                { start_line: 433, end_line: 466 },
-                { start_line: 786, end_line: 874 },
-                { start_line: 988, end_line: 1002 },
-            ],
-        }, {
-            path: /\/components\/chat\/message-input\/input\.tsx$/,
-            exactPaths: ["frontend/src/components/chat/message-input/Input.tsx"],
-            ranges: [
-                { start_line: 360, end_line: 630 },
-                { start_line: 1018, end_line: 1048 },
-            ],
-        }, {
-            path: /\/components\/chat\/message-input\/composerruntimecontrols\.tsx$/,
-            exactPaths: ["frontend/src/components/chat/message-input/ComposerRuntimeControls.tsx"],
-            ranges: [{ start_line: 1, end_line: Number.MAX_SAFE_INTEGER }],
-            full: true,
-        }, {
-            path: /\/hooks\/usemessageactions\.ts$/,
-            exactPaths: ["frontend/src/hooks/useMessageActions.ts"],
-            ranges: [{ start_line: 1, end_line: Number.MAX_SAFE_INTEGER }],
-            full: true,
-        }, {
-            path: /\/components\/ui\/fileuploaddialog\.tsx$/,
-            exactPaths: ["frontend/src/components/ui/FileUploadDialog.tsx"],
-            ranges: [{ start_line: 1, end_line: Number.MAX_SAFE_INTEGER }],
-            full: true,
-        }, {
-            path: /\/components\/ui\/fileuploaddialog\.codex\.test\.tsx$/,
-            exactPaths: ["frontend/src/components/ui/FileUploadDialog.codex.test.tsx"],
-            ranges: [{ start_line: 1, end_line: Number.MAX_SAFE_INTEGER }],
-            full: true,
-        }, {
-            path: /\/hooks\/usepermissionrequest\.ts$/,
-            exactPaths: ["frontend/src/hooks/usePermissionRequest.ts"],
-            ranges: [{ start_line: 1, end_line: Number.MAX_SAFE_INTEGER }],
-            full: true,
-        }, {
-            path: /\/utils\/modelprovider\.ts$/,
-            exactPaths: ["frontend/src/utils/modelProvider.ts"],
-            ranges: [{ start_line: 1, end_line: Number.MAX_SAFE_INTEGER }],
-            full: true,
-        }, {
-            path: /\/components\/chat\/message-input\/inputsettingspopover\.tsx$/,
-            exactPaths: ["frontend/src/components/chat/message-input/InputSettingsPopover.tsx"],
-            ranges: [{ start_line: 1, end_line: Number.MAX_SAFE_INTEGER }],
-            full: true,
-        }, {
-            path: /\/permissionmodeselector\.tsx$/,
-            exactPaths: ["frontend/src/components/chat/permission-mode-selector/PermissionModeSelector.tsx"],
-            ranges: [{ start_line: 1, end_line: Number.MAX_SAFE_INTEGER }],
-            full: true,
-        }, {
-            path: /\/thinkingmodeselector\.tsx$/,
-            exactPaths: ["frontend/src/components/chat/thinking-mode-selector/ThinkingModeSelector.tsx"],
-            ranges: [{ start_line: 1, end_line: Number.MAX_SAFE_INTEGER }],
-            full: true,
-        }, {
-            path: /\/models\/schemas\/chat\.py$/,
-            exactPaths: ["backend/app/models/schemas/chat.py"],
-            ranges: [{ start_line: 1, end_line: Number.MAX_SAFE_INTEGER }],
-            full: true,
-        }, {
-            path: /\/models\/schemas\/permission_mode\.py$/,
-            exactPaths: ["backend/app/models/schemas/permission_mode.py"],
-            ranges: [{ start_line: 1, end_line: Number.MAX_SAFE_INTEGER }],
-            full: true,
-        }, {
-            path: /\/models\/schemas\/permissions\.py$/,
-            exactPaths: ["backend/app/models/schemas/permissions.py"],
-            ranges: [{ start_line: 1, end_line: Number.MAX_SAFE_INTEGER }],
-            full: true,
-        }, {
-            path: /\/models\/db_models\/ai_model\.py$/,
-            exactPaths: ["backend/app/models/db_models/ai_model.py"],
-            ranges: [{ start_line: 1, end_line: Number.MAX_SAFE_INTEGER }],
-            full: true,
-        }, {
-            path: /\/api\/endpoints\/ai_models\.py$/,
-            exactPaths: ["backend/app/api/endpoints/ai_models.py"],
-            ranges: [{ start_line: 1, end_line: Number.MAX_SAFE_INTEGER }],
-            full: true,
-        }, {
-            path: /\/tests\/test_ai_models_codex_gate\.py$/,
-            exactPaths: ["backend/tests/test_ai_models_codex_gate.py"],
-            ranges: [{ start_line: 1, end_line: Number.MAX_SAFE_INTEGER }],
-            full: true,
-        }, {
-            path: /\/tests\/test_permissions\.py$/,
-            exactPaths: ["backend/tests/test_permissions.py"],
-            ranges: [
-                { start_line: 1, end_line: 230 },
-                { start_line: 306, end_line: 389 },
-                { start_line: 489, end_line: 555 },
-            ],
-        });
-    }
-    if (isDevtoolsTraceDebugTask(task)) {
-        specs.push({
-            path: /\/right-panel\/rightpaneldevtools\.tsx$/,
-            exactPaths: ["frontend/src/components/right-panel/RightPanelDevtools.tsx"],
-            ranges: [
-                { start_line: 1, end_line: 115 },
-                { start_line: 528, end_line: 745 },
-                { start_line: 840, end_line: 948 },
-            ],
-        }, {
-            path: /\/right-panel\/__tests__\/right-panel-devtools\.test\.tsx$/,
-            exactPaths: ["frontend/src/components/right-panel/__tests__/right-panel-devtools.test.tsx"],
-            ranges: [{ start_line: 1, end_line: Number.MAX_SAFE_INTEGER }],
-            full: true,
-        }, {
-            path: /\/right-panel\/devtools-helpers\.ts$/,
-            exactPaths: ["frontend/src/components/right-panel/devtools-helpers.ts"],
-            ranges: [{ start_line: 1, end_line: Number.MAX_SAFE_INTEGER }],
-            full: true,
-        }, {
-            path: /\/store\/devtoolsnavstore\.ts$/,
-            exactPaths: ["frontend/src/store/devtoolsNavStore.ts"],
-            ranges: [{ start_line: 1, end_line: Number.MAX_SAFE_INTEGER }],
-            full: true,
-        }, {
-            path: /\/services\/devtoolsservice\.ts$/,
-            exactPaths: ["frontend/src/services/devtoolsService.ts"],
-            ranges: [{ start_line: 1, end_line: Number.MAX_SAFE_INTEGER }],
-            full: true,
-        }, {
-            path: /\/hooks\/queries\/usedevtoolsqueries\.ts$/,
-            exactPaths: ["frontend/src/hooks/queries/useDevtoolsQueries.ts"],
-            ranges: [{ start_line: 1, end_line: Number.MAX_SAFE_INTEGER }],
-            full: true,
-        }, {
-            path: /\/components\/chat\/chat-window\/chat\.tsx$/,
-            exactPaths: ["frontend/src/components/chat/chat-window/Chat.tsx"],
-            ranges: [
-                { start_line: 450, end_line: 615 },
-                { start_line: 670, end_line: 750 },
-            ],
-        }, {
-            path: /\/components\/chat\/message-bubble\/message\.tsx$/,
-            exactPaths: ["frontend/src/components/chat/message-bubble/Message.tsx"],
-            ranges: [{ start_line: 1, end_line: Number.MAX_SAFE_INTEGER }],
-            full: true,
-        }, {
-            path: /\/pages\/chatpage\.tsx$/,
-            exactPaths: ["frontend/src/pages/ChatPage.tsx"],
-            ranges: [
-                { start_line: 150, end_line: 292 },
-                { start_line: 640, end_line: 700 },
-            ],
-        }, {
-            path: /\/components\/chat\/message-input\/input\.tsx$/,
-            exactPaths: ["frontend/src/components/chat/message-input/Input.tsx"],
-            ranges: [
-                { start_line: 360, end_line: 630 },
-                { start_line: 1018, end_line: 1048 },
-            ],
-        }, {
-            path: /\/api\/endpoints\/chat\.py$/,
-            exactPaths: ["backend/app/api/endpoints/chat.py"],
-            ranges: [
-                { start_line: 390, end_line: 570 },
-                { start_line: 1215, end_line: 1400 },
-            ],
-        }, {
-            path: /\/services\/claude_agent\.py$/,
-            exactPaths: ["backend/app/services/claude_agent.py"],
-            ranges: [
-                { start_line: 44, end_line: 80 },
-                { start_line: 433, end_line: 466 },
-                { start_line: 786, end_line: 874 },
-                { start_line: 988, end_line: 1002 },
-            ],
-        }, {
-            path: /\/store\/__tests__\/devtoolsnavstore\.test\.ts$/,
-            exactPaths: ["frontend/src/store/__tests__/devtoolsNavStore.test.ts"],
-            ranges: [{ start_line: 1, end_line: Number.MAX_SAFE_INTEGER }],
-            full: true,
-        }, {
-            path: /\/models\/schemas\/devtools\.py$/,
-            exactPaths: ["backend/app/models/schemas/devtools.py"],
-            ranges: [{ start_line: 1, end_line: Number.MAX_SAFE_INTEGER }],
-            full: true,
-        });
-    }
-    return specs;
-}
-function isRuntimeSettingsPersistenceFlowTask(normalizedTask) {
-    return (normalizedTask.includes("runtime") &&
-        /\bsettings?\b/.test(normalizedTask) &&
-        /\b(validat(?:e|es|ed|ing|ion)|dropp?ed|dropp?ing|drops?|persist(?:s|ed|ing|ence)?|dispatch(?:es|ed|ing)?)\b/.test(normalizedTask));
-}
-function isTangentialRuntimeSettingsDiscoveryTestPath(normalizedPath, basename) {
-    return (basename === "test_codex_e2e_live.py" ||
-        basename === "test_codex_sdk_smoke.py" ||
-        basename === "test_codex_runtime_live.py" ||
-        basename === "test_transport_absence.py" ||
-        basename === "test_resolver.py" ||
-        normalizedPath.includes("nightshift") ||
-        /\/tests?\/.*codex.*approval.*\.(py|ts|tsx)$/.test(normalizedPath));
-}
-function candidateForTaskSpineSpec(spec, candidates, sourceRoots) {
-    const local = localCandidateForTaskSpineSpec(spec, sourceRoots);
-    if (local != null) {
-        return local;
-    }
-    const discovered = candidates.find((item) => spec.path.test(item.path.toLowerCase()));
-    if (discovered != null) {
-        return discovered;
-    }
-    return undefined;
-}
-function localCandidateForTaskSpineSpec(spec, sourceRoots, preferredRootIndex) {
-    for (const exactPath of spec.exactPaths ?? []) {
-        const local = localCandidateFromExactPath(exactPath, sourceRoots, preferredRootIndex);
-        if (local != null) {
-            return local;
-        }
-    }
-    return undefined;
-}
-function localCandidateFromSelectedFile(file, sourceRoots) {
-    return localCandidateFromExactPath(file.path, sourceRoots, file.root_index);
-}
-function localCandidateFromExactPath(relativePath, sourceRoots, preferredRootIndex) {
-    const rootIndexes = preferredRootIndex == null
-        ? sourceRoots.map((_, index) => index)
-        : [preferredRootIndex];
-    for (const rootIndex of rootIndexes) {
-        const root = sourceRoots[rootIndex];
-        if (root == null) {
-            continue;
-        }
-        const absolutePath = path.join(root.path, relativePath);
-        try {
-            const content = readFileSync(absolutePath, "utf8");
-            return {
-                root_index: rootIndex,
-                path: relativePath,
-                absolute_path: absolutePath,
-                content,
-                byte_length: Buffer.byteLength(content, "utf8"),
-                line_count: splitTextLines(content).length,
-                has_final_newline: content.endsWith("\n"),
-            };
-        }
-        catch {
-            continue;
-        }
-    }
-    return undefined;
-}
-function shouldReplaceWithTaskSpineRanges(path, task) {
-    const normalized = path.toLowerCase();
-    const normalizedTask = task.toLowerCase();
-    if (/\bdiscovery\b/.test(normalizedTask) &&
-        normalizedTask.includes("runtime") &&
-        (normalized.endsWith("/services/chat.py") ||
-            normalized.endsWith("/services/claude_agent.py"))) {
-        return true;
-    }
-    if (isDevtoolsTraceDebugTask(task) &&
-        (normalized.endsWith("/components/right-panel/rightpaneldevtools.tsx") ||
-            normalized.endsWith("/components/chat/chat-window/chat.tsx") ||
-            normalized.endsWith("/pages/chatpage.tsx") ||
-            normalized.endsWith("/components/chat/message-input/input.tsx") ||
-            normalized.endsWith("/api/endpoints/chat.py") ||
-            normalized.endsWith("/services/claude_agent.py"))) {
-        return true;
-    }
-    if (isCodexRuntimeReviewTask(task) &&
-        (normalized.endsWith("/services/runtime/codex.py") ||
-            normalized.endsWith("/services/runtime/codex_approval.py") ||
-            normalized.endsWith("/services/runtime/codex_stream_processor.py") ||
-            normalized.endsWith("/services/streaming/orchestrator.py") ||
-            normalized.endsWith("/services/chat.py") ||
-            normalized.endsWith("/tests/services/runtime/test_codex_approval_bridge.py") ||
-            normalized.endsWith("/tests/test_permissions.py") ||
-            normalized.endsWith("/services/claude_agent.py"))) {
-        return true;
-    }
-    return false;
-}
-function selectedFileFromCandidateRanges(candidate, ranges, source) {
-    const taskSpineContent = readTaskSpineCandidateContent(candidate);
-    const sourceLines = splitTextLines(taskSpineContent);
-    if (sourceLines.length === 0) {
-        return null;
-    }
-    const lineCount = sourceLines.length;
-    const bounded = mergeLineRanges(ranges
-        .map((range) => ({
-        start_line: Math.max(1, range.start_line),
-        end_line: Math.min(Math.max(1, lineCount), range.end_line),
-    }))
-        .filter((range) => range.start_line <= range.end_line));
-    if (bounded.length === 0) {
-        return null;
-    }
-    const content = bounded
-        .flatMap((range) => sourceLines.slice(range.start_line - 1, range.end_line))
-        .join("\n");
-    const bytes = Buffer.byteLength(content, "utf8");
-    if (bytes <= 0) {
-        return null;
-    }
-    return {
-        root_index: candidate.root_index,
-        path: candidate.path,
-        ranges: bounded,
-        content,
-        bytes,
-        estimated_tokens: estimateContextBuilderTokensFromUtf8Bytes(bytes),
-        source,
-    };
-}
-function readTaskSpineCandidateContent(candidate) {
-    try {
-        return readFileSync(candidate.absolute_path, "utf8");
-    }
-    catch {
-        return candidate.content;
-    }
-}
-function appendDelegateRepairWarnings(warnings, repair) {
-    if (repair.expandedCount > 0) {
-        warnings.push(delegateWarning("delegate_curator_warning", `server-expanded ${repair.expandedCount} selected file(s) to full context`));
-    }
-    if (repair.droppedDegenerateCount > 0) {
-        warnings.push(delegateWarning("delegate_curator_warning", `server-dropped ${repair.droppedDegenerateCount} degenerate selected slice(s)`));
-    }
-    if (repair.deterministicRetainedCount > 0) {
-        warnings.push(delegateWarning("delegate_curator_warning", `server-retained ${repair.deterministicRetainedCount} compact deterministic closure file(s) after curator underselection`));
-    }
-    if (repair.discoveredRetainedCount > 0) {
-        warnings.push(delegateWarning("delegate_curator_warning", `server-retained ${repair.discoveredRetainedCount} task-critical discovered closure file(s) after curator underselection`));
-    }
-    if (repair.evictedCount > 0) {
-        warnings.push(delegateWarning("delegate_curator_warning", `server-evicted ${repair.evictedCount} lower-priority selected file(s) to retain required closure`));
-    }
-}
-function retainDeterministicClosureFiles(selection, deterministicSelection, budget, task) {
-    const selectedKeys = new Set(selection.selected.map((file) => selectedFileKey(file)));
-    let totalBytes = selection.metrics.bytes_selected;
-    let totalTokens = selection.metrics.estimated_tokens;
-    const selected = [...selection.selected];
-    let retainedCount = 0;
-    for (const file of deterministicSelection.selected) {
-        if (selectedKeys.has(selectedFileKey(file)) ||
-            !isRetainableClosureFile(file, task)) {
-            continue;
-        }
-        if (selected.length >= budget.max_files ||
-            file.bytes > budget.max_bytes_per_file ||
-            totalBytes + file.bytes > budget.max_total_bytes ||
-            totalTokens + file.estimated_tokens > budget.target_estimated_tokens) {
-            continue;
-        }
-        selected.push(file);
-        selectedKeys.add(selectedFileKey(file));
-        totalBytes += file.bytes;
-        totalTokens += file.estimated_tokens;
-        retainedCount += 1;
-    }
-    if (retainedCount === 0) {
-        return { selection, retainedCount };
-    }
-    return {
-        retainedCount,
-        selection: {
-            ...selection,
-            selected,
-            metrics: {
-                files_selected: selected.length,
-                files_omitted: selection.metrics.files_omitted,
-                bytes_selected: totalBytes,
-                estimated_tokens: totalTokens,
-                truncated: selection.metrics.truncated,
-            },
-        },
-    };
-}
-function expandSelectedFocusFilesToFullCandidates(selection, candidates, focusPaths, budget, task = "") {
-    if (!shouldExpandFocusFilesForTask(task)) {
-        return { selection, expandedCount: 0 };
-    }
-    const focusKeys = new Set(focusPaths
-        .filter((focus) => focus.kind === "file")
-        .map((focus) => `${focus.root_index}\u0000${focus.root_relative_path}`));
-    if (focusKeys.size === 0) {
-        return { selection, expandedCount: 0 };
-    }
-    const candidatesByKey = new Map(candidates.map((candidate) => [selectedFileKey(candidate), candidate]));
-    let totalBytes = selection.metrics.bytes_selected;
-    let totalTokens = selection.metrics.estimated_tokens;
-    let expandedCount = 0;
-    const selected = selection.selected.map((file) => {
-        const key = selectedFileKey(file);
-        if (!focusKeys.has(key)) {
+        if (file.ranges.length !== 1) {
             return file;
         }
         const candidate = candidatesByKey.get(key);
@@ -2144,10 +1256,6 @@ function expandSelectedFocusFilesToFullCandidates(selection, candidates, focusPa
         if (fullFile.bytes <= file.bytes || fileCoversCandidate(file, candidate)) {
             return file;
         }
-        if (fullFile.estimated_tokens >
-            focusExpansionTokenLimit(candidate.path, task, budget)) {
-            return file;
-        }
         const totalsWithoutFile = {
             totalBytes: totalBytes - file.bytes,
             totalTokens: totalTokens - file.estimated_tokens,
@@ -2181,41 +1289,30 @@ function expandSelectedFocusFilesToFullCandidates(selection, candidates, focusPa
         },
     };
 }
-function shouldExpandFocusFilesForTask(task) {
-    return /\b(debug(?:ging)?|review|discovery|implement(?:ation)?|fix|diagnose)\b/i.test(task);
-}
-function focusExpansionTokenLimit(path, task, budget) {
-    const normalized = path.toLowerCase();
-    const normalizedTask = task.toLowerCase();
-    if (/\b(debug|debugging|diagnose|diagnosis|diagnostic)\b/.test(normalizedTask) &&
-        normalized.endsWith("/rightpaneldevtools.tsx")) {
-        return 35_000;
-    }
-    if (/\b(review|discovery|provider|runtime|codex|claude)\b/.test(normalizedTask) &&
-        normalized.includes("/services/runtime/")) {
-        return Math.min(18_000, Math.floor(budget.target_estimated_tokens * 0.2));
-    }
-    return Math.min(12_000, Math.floor(budget.target_estimated_tokens * 0.18));
-}
-function expandSelectedClosureFilesToFullCandidates(selection, candidates, task, budget) {
+const SMALL_SELECTED_SLICE_FULL_EXPANSION_MAX_BYTES = 64_000;
+function expandSelectedSmallFilesToFullCandidates(selection, candidates, focusPaths, budget) {
     const candidatesByKey = new Map(candidates.map((candidate) => [selectedFileKey(candidate), candidate]));
+    const focusKeys = new Set(focusPaths
+        .filter((focus) => focus.kind === "file")
+        .map((focus) => `${focus.root_index}\u0000${focus.root_relative_path}`));
     let totalBytes = selection.metrics.bytes_selected;
     let totalTokens = selection.metrics.estimated_tokens;
     let expandedCount = 0;
     const selected = selection.selected.map((file) => {
-        if (!isRetainableClosureFile(file, task) &&
-            !isContextBuilderTaskClosureAnchor(file.path, task) &&
-            !isTaskCriticalDiscoveredClosure(file.path, task)) {
+        if (focusKeys.has(selectedFileKey(file)) || file.ranges.length !== 1) {
             return file;
         }
         const candidate = candidatesByKey.get(selectedFileKey(file));
         if (candidate == null || fileCoversCandidate(file, candidate)) {
             return file;
         }
-        if (candidate.byte_length > retainableClosureByteLimit(candidate.path, task)) {
+        if (candidate.byte_length > SMALL_SELECTED_SLICE_FULL_EXPANSION_MAX_BYTES) {
             return file;
         }
         const fullFile = selectedFileFromCandidate(candidate);
+        if (fullFile.bytes <= file.bytes) {
+            return file;
+        }
         const totalsWithoutFile = {
             totalBytes: totalBytes - file.bytes,
             totalTokens: totalTokens - file.estimated_tokens,
@@ -2249,413 +1346,17 @@ function expandSelectedClosureFilesToFullCandidates(selection, candidates, task,
         },
     };
 }
-function retainDiscoveredTaskCriticalFiles(selection, candidates, task, budget) {
-    let selectedKeys = new Set(selection.selected.map((file) => selectedFileKey(file)));
-    let totalBytes = selection.metrics.bytes_selected;
-    let totalTokens = selection.metrics.estimated_tokens;
-    let selected = [...selection.selected];
-    let retainedCount = 0;
-    let evictedCount = 0;
-    for (const candidate of [...candidates]
-        .filter((item) => !isTangentialTaskClosureCandidate(item.path, task) &&
-        (isContextBuilderTaskClosureAnchor(item.path, task) ||
-            isTaskCriticalDiscoveredClosure(item.path, task)))
-        .sort((left, right) => compareTaskCriticalCandidates(left, right, task))) {
-        const key = selectedFileKey(candidate);
-        if (selectedKeys.has(key) ||
-            (candidate.byte_length > retainableClosureByteLimit(candidate.path, task) &&
-                compactCandidateForRequiredClosure(candidate, task) == null)) {
-            continue;
-        }
-        const file = candidate.byte_length > retainableClosureByteLimit(candidate.path, task)
-            ? compactCandidateForRequiredClosure(candidate, task)
-            : selectedFileFromCandidate(candidate);
-        if (file == null) {
-            continue;
-        }
-        if (!selectionFitsBudgetWithFile(selected, totalBytes, totalTokens, file, budget)) {
-            const repaired = makeRoomForRequiredClosureFile({
-                selected,
-                selectedKeys,
-                totalBytes,
-                totalTokens,
-                file,
-                budget,
-                task,
-            });
-            if (repaired == null) {
-                continue;
-            }
-            selected = repaired.selected;
-            selectedKeys = repaired.selectedKeys;
-            totalBytes = repaired.totalBytes;
-            totalTokens = repaired.totalTokens;
-            evictedCount += repaired.evictedCount;
-        }
-        selected.push(file);
-        selectedKeys.add(key);
-        totalBytes += file.bytes;
-        totalTokens += file.estimated_tokens;
-        retainedCount += 1;
-    }
-    if (retainedCount === 0 && evictedCount === 0) {
-        return { selection, retainedCount, evictedCount };
-    }
-    return {
-        retainedCount,
-        evictedCount,
-        selection: {
-            ...selection,
-            selected,
-            metrics: {
-                files_selected: selected.length,
-                files_omitted: selection.metrics.files_omitted,
-                bytes_selected: totalBytes,
-                estimated_tokens: totalTokens,
-                truncated: selection.metrics.truncated,
-            },
-        },
-    };
-}
-function dropDegenerateSelectedSlices(selection, candidates, task) {
-    const candidatesByKey = new Map(candidates.map((candidate) => [selectedFileKey(candidate), candidate]));
-    const selected = selection.selected.filter((file) => {
-        if (file.content.trim().length === 0) {
-            return false;
-        }
-        if (!isDegenerateSelectedSlice(file) || file.source === "focus") {
-            return true;
-        }
-        if (!isRequiredClosurePath(file.path, task)) {
-            return true;
-        }
-        const candidate = candidatesByKey.get(selectedFileKey(file));
-        return (candidate != null &&
-            fileCoversCandidate(file, candidate) &&
-            isRequiredClosurePath(candidate.path, task));
-    });
+function dropEmptySelectedFiles(selection) {
+    const selected = selection.selected.filter((file) => file.content.trim().length > 0);
     const droppedCount = selection.selected.length - selected.length;
     if (droppedCount === 0) {
         return { selection, droppedCount };
     }
     return {
-        droppedCount,
         selection: selectionWithSelectedFiles(selection, selected),
+        droppedCount,
     };
 }
-function makeRoomForRequiredClosureFile(input) {
-    if (input.file.bytes > input.budget.max_bytes_per_file) {
-        return null;
-    }
-    const incomingRank = taskCriticalPathRank(input.file.path, input.task);
-    let selected = [...input.selected];
-    let selectedKeys = new Set(input.selectedKeys);
-    let totalBytes = input.totalBytes;
-    let totalTokens = input.totalTokens;
-    let evictedCount = 0;
-    if (!selectionFitsBudgetWithFile(selected, totalBytes, totalTokens, input.file, input.budget)) {
-        const compacted = compactSelectedFilesForRequiredClosure({
-            selected,
-            totalBytes,
-            totalTokens,
-            incomingFile: input.file,
-            task: input.task,
-        });
-        selected = compacted.selected;
-        totalBytes = compacted.totalBytes;
-        totalTokens = compacted.totalTokens;
-    }
-    const evictionOrder = selected
-        .map((file, index) => ({ file, index }))
-        .filter(({ file }) => canEvictForRequiredClosure(file, input.task, incomingRank))
-        .sort((left, right) => selectedEvictionRank(right.file, input.task, incomingRank) -
-        selectedEvictionRank(left.file, input.task, incomingRank) ||
-        right.index - left.index);
-    for (const { file } of evictionOrder) {
-        if (selectionFitsBudgetWithFile(selected, totalBytes, totalTokens, input.file, input.budget)) {
-            break;
-        }
-        const index = selected.findIndex((item) => selectedFileKey(item) === selectedFileKey(file));
-        if (index < 0) {
-            continue;
-        }
-        const [removed] = selected.splice(index, 1);
-        if (removed == null) {
-            continue;
-        }
-        selectedKeys.delete(selectedFileKey(removed));
-        totalBytes -= removed.bytes;
-        totalTokens -= removed.estimated_tokens;
-        evictedCount += 1;
-    }
-    if (!selectionFitsBudgetWithFile(selected, totalBytes, totalTokens, input.file, input.budget)) {
-        return null;
-    }
-    return { selected, selectedKeys, totalBytes, totalTokens, evictedCount };
-}
-function selectionFitsBudgetWithFile(selected, totalBytes, totalTokens, file, budget) {
-    return (selected.length < budget.max_files &&
-        file.bytes <= budget.max_bytes_per_file &&
-        totalBytes + file.bytes <= budget.max_total_bytes &&
-        totalTokens + file.estimated_tokens <= budget.target_estimated_tokens);
-}
-const REQUIRED_CLOSURE_COMPACT_MIN_TOKENS = 3_000;
-const REQUIRED_CLOSURE_COMPACT_HEAD_LINES = 60;
-const REQUIRED_CLOSURE_COMPACT_CONTEXT_LINES = 24;
-const REQUIRED_CLOSURE_COMPACT_MAX_LINES = 260;
-function compactSelectedFilesForRequiredClosure(input) {
-    let totalBytes = input.totalBytes;
-    let totalTokens = input.totalTokens;
-    const selected = input.selected.map((file) => {
-        const compacted = compactSelectedFileForRequiredClosure(file, input.incomingFile, input.task);
-        if (compacted == null) {
-            return file;
-        }
-        totalBytes = totalBytes - file.bytes + compacted.bytes;
-        totalTokens = totalTokens - file.estimated_tokens + compacted.estimated_tokens;
-        return compacted;
-    });
-    return { selected, totalBytes, totalTokens };
-}
-function compactSelectedFileForRequiredClosure(file, incomingFile, task) {
-    if (file.source !== "focus" ||
-        isProtectedReviewFocusPath(file.path, task) ||
-        file.estimated_tokens <= REQUIRED_CLOSURE_COMPACT_MIN_TOKENS ||
-        selectedRangeLineCount(file) <= REQUIRED_CLOSURE_COMPACT_HEAD_LINES) {
-        return null;
-    }
-    const sourceLines = splitTextLines(file.content);
-    if (sourceLines.length <= REQUIRED_CLOSURE_COMPACT_HEAD_LINES) {
-        return null;
-    }
-    const sourceLineNumbers = selectedFileContentLineNumbers(file, sourceLines.length);
-    if (sourceLineNumbers.length !== sourceLines.length) {
-        return null;
-    }
-    const tokens = new Set([
-        ...tokenizeRepairWords(task),
-        ...tokenizeRepairWords(incomingFile.path),
-        ...tokenizeRepairWords(file.path),
-    ]);
-    const selectedLineNumbers = new Set();
-    addOriginalLineWindow(selectedLineNumbers, sourceLineNumbers, sourceLineNumbers[0] ?? 1, (sourceLineNumbers[0] ?? 1) + REQUIRED_CLOSURE_COMPACT_HEAD_LINES - 1);
-    for (let index = 0; index < sourceLines.length; index++) {
-        if (selectedLineNumbers.size >= REQUIRED_CLOSURE_COMPACT_MAX_LINES) {
-            break;
-        }
-        const line = sourceLines[index] ?? "";
-        if (!lineMatchesRepairTokens(line, tokens)) {
-            continue;
-        }
-        const originalLine = sourceLineNumbers[index];
-        if (originalLine == null) {
-            continue;
-        }
-        addOriginalLineWindow(selectedLineNumbers, sourceLineNumbers, originalLine - REQUIRED_CLOSURE_COMPACT_CONTEXT_LINES, originalLine + REQUIRED_CLOSURE_COMPACT_CONTEXT_LINES);
-    }
-    if (selectedLineNumbers.size >= sourceLines.length) {
-        return null;
-    }
-    const ranges = mergeLineRanges([...selectedLineNumbers].map((line) => ({
-        start_line: line,
-        end_line: line,
-    })));
-    const linesByOriginalLine = new Map();
-    for (let index = 0; index < sourceLines.length; index++) {
-        const lineNumber = sourceLineNumbers[index];
-        if (lineNumber != null) {
-            linesByOriginalLine.set(lineNumber, sourceLines[index] ?? "");
-        }
-    }
-    const content = ranges
-        .flatMap((range) => {
-        const lines = [];
-        for (let line = range.start_line; line <= range.end_line; line++) {
-            const contentLine = linesByOriginalLine.get(line);
-            if (contentLine != null) {
-                lines.push(contentLine);
-            }
-        }
-        return lines;
-    })
-        .join("\n");
-    const bytes = Buffer.byteLength(content, "utf8");
-    if (bytes >= file.bytes) {
-        return null;
-    }
-    return {
-        ...file,
-        ranges,
-        content,
-        bytes,
-        estimated_tokens: estimateContextBuilderTokensFromUtf8Bytes(bytes),
-    };
-}
-function selectedFileContentLineNumbers(file, lineCount) {
-    const numbers = [];
-    for (const range of file.ranges) {
-        for (let line = range.start_line; line <= range.end_line; line++) {
-            numbers.push(line);
-            if (numbers.length >= lineCount) {
-                return numbers;
-            }
-        }
-    }
-    return numbers;
-}
-function addOriginalLineWindow(selectedLineNumbers, availableLineNumbers, startLine, endLine) {
-    const available = new Set(availableLineNumbers);
-    for (let line = startLine; line <= endLine; line++) {
-        if (selectedLineNumbers.size >= REQUIRED_CLOSURE_COMPACT_MAX_LINES) {
-            return;
-        }
-        if (available.has(line)) {
-            selectedLineNumbers.add(line);
-        }
-    }
-}
-function lineMatchesRepairTokens(line, tokens) {
-    for (const token of tokenizeRepairWords(line)) {
-        if (tokens.has(token)) {
-            return true;
-        }
-    }
-    return false;
-}
-function tokenizeRepairWords(input) {
-    return input
-        .toLowerCase()
-        .split(/[^a-z0-9]+/)
-        .filter((token) => token.length >= 3 && !REPAIR_STOP_WORDS.has(token));
-}
-const REPAIR_STOP_WORDS = new Set([
-    "app",
-    "src",
-    "the",
-    "and",
-    "for",
-    "with",
-    "from",
-    "this",
-    "that",
-    "file",
-    "test",
-    "tests",
-]);
-function canEvictForRequiredClosure(file, task, incomingRank) {
-    const existingRank = taskCriticalPathRank(file.path, task);
-    if (file.source === "focus") {
-        return (incomingRank <= 0 &&
-            existingRank > incomingRank &&
-            !isProtectedReviewFocusPath(file.path, task));
-    }
-    if (isRequiredClosurePath(file.path, task) && existingRank <= incomingRank) {
-        return false;
-    }
-    return true;
-}
-function selectedEvictionRank(file, task, incomingRank) {
-    let rank = file.estimated_tokens;
-    if (isDegenerateSelectedSlice(file)) {
-        rank += 10_000;
-    }
-    if (!isRequiredClosurePath(file.path, task)) {
-        rank += 5_000;
-    }
-    rank += Math.max(0, taskCriticalPathRank(file.path, task) - incomingRank) * 500;
-    if (isGenericSelectedPath(file.path)) {
-        rank += 1_000;
-    }
-    return rank;
-}
-function isDegenerateSelectedSlice(file) {
-    return file.content.trim().length === 0 || selectedRangeLineCount(file) <= 1;
-}
-function selectedRangeLineCount(file) {
-    return file.ranges.reduce((total, range) => total + Math.max(0, range.end_line - range.start_line + 1), 0);
-}
-function isRequiredClosurePath(path, task) {
-    return (isContextBuilderTaskClosureAnchor(path, task) ||
-        isTaskCriticalDiscoveredClosure(path, task) ||
-        taskCriticalPathRank(path, task) <= 0);
-}
-function isGenericSelectedPath(path) {
-    const normalized = path.toLowerCase();
-    return (normalized.includes("/settings/") ||
-        normalized.includes("/components/ui/") ||
-        normalized.includes("/admin/") ||
-        normalized.includes("/models/db_models/__init__.py") ||
-        normalized.includes("/db/base.py"));
-}
-function isDevtoolsTraceDebugTask(task) {
-    const normalized = task.toLowerCase();
-    return (/\b(debug|debugging|diagnose|diagnosis|diagnostic)\b/.test(normalized) &&
-        normalized.includes("devtools") &&
-        normalized.includes("trace"));
-}
-function isDevtoolsTraceRelevantPath(path) {
-    if (isTangentialDevtoolsTraceDebugPath(path)) {
-        return false;
-    }
-    const normalized = path.toLowerCase();
-    return (normalized.includes("/right-panel/") ||
-        normalized.endsWith("/rightpaneldevtools.tsx") ||
-        normalized.includes("/store/devtoolsnavstore") ||
-        normalized.includes("/store/__tests__/devtoolsnavstore.test.ts") ||
-        normalized.includes("/services/devtoolsservice") ||
-        normalized.includes("/hooks/queries/usedevtoolsqueries") ||
-        normalized.includes("/hooks/queries/querykeys") ||
-        normalized.endsWith("/querykeys.ts") ||
-        normalized.includes("/types/devtools.types") ||
-        normalized.endsWith("/models/schemas/devtools.py") ||
-        normalized.includes("/api/endpoints/devtools.py") ||
-        normalized.includes("/session_trace_archive") ||
-        normalized.endsWith("/services/codex_trace.py") ||
-        normalized.includes("/chat-window/chat.tsx") ||
-        normalized.includes("/chat/__tests__/chat.test.tsx") ||
-        normalized.includes("/message-bubble/message.tsx") ||
-        normalized.includes("/message-bubble/messagerenderer.tsx") ||
-        normalized.includes("/tools/common/toolcard.tsx") ||
-        normalized.includes("/tools/common/toolexpandcontext.ts") ||
-        normalized.includes("/tools/common/__tests__/toolexpand.test.tsx") ||
-        normalized.includes("/hooks/usemessagecache.ts") ||
-        normalized.includes("/utils/messagecacheorder.ts"));
-}
-function shouldExpandSmallDevtoolsTraceFile(path) {
-    const normalized = path.toLowerCase();
-    return (normalized.endsWith("/rightpanel.tsx") ||
-        normalized.endsWith("/tools/common/toolcard.tsx") ||
-        normalized.endsWith("/tools/common/toolexpandcontext.ts"));
-}
-function isTangentialDevtoolsTraceDebugPath(path) {
-    const normalized = path.toLowerCase();
-    const basename = normalized.split("/").at(-1) ?? normalized;
-    return (basename === "advancedblocknoteeditor.tsx" ||
-        basename === "githubsettingspopover.tsx" ||
-        basename === "input.tsx" ||
-        basename === "inputsettingspopover.tsx" ||
-        basename === "mentionsuggestionspanel.tsx" ||
-        basename === "segmentbuilder.ts" ||
-        basename === "sendbutton.tsx" ||
-        basename === "slashcommandspanel.tsx" ||
-        normalized === "backend/tests/test_devtools_trace_archive.py" ||
-        normalized.endsWith("/backend/tests/test_devtools_trace_archive.py"));
-}
-function isTangentialTaskClosureCandidate(path, task) {
-    return ((isDevtoolsTraceDebugTask(task) && isTangentialDevtoolsTraceDebugPath(path)) ||
-        (isCodexRuntimeReviewTask(task) && isTangentialCodexRuntimeReviewUiPath(path)));
-}
-function isProtectedReviewFocusPath(path, task) {
-    if (!/\breview\b/i.test(task)) {
-        return false;
-    }
-    const normalized = path.toLowerCase();
-    return (normalized.includes("/services/runtime/") ||
-        normalized.endsWith("/services/runtime_session_service.py") ||
-        normalized.endsWith("/services/streaming/orchestrator.py") ||
-        normalized.includes("/tests/services/runtime/") ||
-        normalized.endsWith("/tests/services/test_runtime_session_service.py"));
-}
 function selectionWithSelectedFiles(selection, selected) {
     const bytes = selected.reduce((total, file) => total + file.bytes, 0);
     const tokens = selected.reduce((total, file) => total + file.estimated_tokens, 0);
@@ -2674,54 +1375,6 @@ function selectionWithSelectedFiles(selection, selected) {
 function selectedFileKey(file) {
     return `${file.root_index}\u0000${file.path}`;
 }
-const RETAINABLE_CLOSURE_MAX_BYTES = 24_000;
-const RETAINABLE_PROVIDER_IMPL_MAX_BYTES = 48_000;
-function isRetainableClosureFile(file, task) {
-    if (file.bytes > retainableClosureByteLimit(file.path, task)) {
-        return false;
-    }
-    const normalized = file.path.toLowerCase();
-    const basename = normalized.split("/").at(-1) ?? normalized;
-    return (normalized.includes("/types/") ||
-        normalized.includes("/schemas/") ||
-        normalized.includes("/constants.") ||
-        normalized.includes("/config.") ||
-        normalized.includes("/querykeys.") ||
-        normalized.includes("/messagerenderer.") ||
-        normalized.includes("/message-bubble/message.") ||
-        normalized.includes("/toolcard.") ||
-        normalized.includes("/toolexpandcontext.") ||
-        normalized.includes("/messagecacheorder.") ||
-        normalized.includes("/session_trace_archive.") ||
-        normalized.includes("/runtime/base.") ||
-        normalized.includes("/claude_agent.") ||
-        normalized.includes("/rightpanel.") ||
-        basename.endsWith(".types.ts") ||
-        basename === "api.types.ts" ||
-        basename === "types.ts" ||
-        basename === "schema.ts" ||
-        basename === "schemas.ts" ||
-        basename === "constants.ts" ||
-        basename === "constants.py" ||
-        basename === "config.ts" ||
-        normalized.endsWith("/core/config.py") ||
-        basename === "querykeys.ts" ||
-        basename === "permission_mode.py" ||
-        basename === "effort.py" ||
-        basename === "codex_trace.py");
-}
-function retainableClosureByteLimit(path, task) {
-    const normalized = path.toLowerCase();
-    if (normalized.endsWith("codex_trace.py")) {
-        return 12_000;
-    }
-    if (/\b(provider|runtime|codex|claude|review|discovery)\b/.test(task.toLowerCase()) &&
-        (normalized.endsWith("/claude_agent.py") ||
-            normalized.endsWith("/runtime/base.py"))) {
-        return RETAINABLE_PROVIDER_IMPL_MAX_BYTES;
-    }
-    return RETAINABLE_CLOSURE_MAX_BYTES;
-}
 function selectedFileFromCandidate(candidate) {
     const bytes = Buffer.byteLength(candidate.content, "utf8");
     return {
@@ -2734,421 +1387,21 @@ function selectedFileFromCandidate(candidate) {
         source: "search",
     };
 }
-function compactCandidateForRequiredClosure(candidate, task) {
-    const sourceLines = splitTextLines(candidate.content);
-    if (sourceLines.length === 0) {
-        return null;
-    }
-    const tokens = new Set([
-        ...tokenizeRepairWords(task),
-        ...tokenizeRepairWords(candidate.path),
-    ]);
-    const selectedLineNumbers = new Set();
-    const availableLineNumbers = sourceLines.map((_, index) => index + 1);
-    addOriginalLineWindow(selectedLineNumbers, availableLineNumbers, 1, REQUIRED_CLOSURE_COMPACT_HEAD_LINES);
-    for (let index = 0; index < sourceLines.length; index++) {
-        if (selectedLineNumbers.size >= REQUIRED_CLOSURE_COMPACT_MAX_LINES) {
-            break;
-        }
-        const line = sourceLines[index] ?? "";
-        if (!lineMatchesRepairTokens(line, tokens)) {
-            continue;
-        }
-        const originalLine = index + 1;
-        addOriginalLineWindow(selectedLineNumbers, availableLineNumbers, originalLine - REQUIRED_CLOSURE_COMPACT_CONTEXT_LINES, originalLine + REQUIRED_CLOSURE_COMPACT_CONTEXT_LINES);
-    }
-    if (selectedLineNumbers.size === 0 || selectedLineNumbers.size >= sourceLines.length) {
-        return null;
-    }
-    const ranges = mergeLineRanges([...selectedLineNumbers].map((line) => ({
-        start_line: line,
-        end_line: line,
-    })));
-    const content = ranges
-        .flatMap((range) => sourceLines.slice(range.start_line - 1, range.end_line))
-        .join("\n");
-    const bytes = Buffer.byteLength(content, "utf8");
-    if (bytes <= 0 || bytes >= candidate.byte_length) {
-        return null;
-    }
-    return {
-        root_index: candidate.root_index,
-        path: candidate.path,
-        ranges,
-        content,
-        bytes,
-        estimated_tokens: estimateContextBuilderTokensFromUtf8Bytes(bytes),
-        source: "search",
-    };
-}
-function isTaskCriticalDiscoveredClosure(path, task) {
-    const normalizedTask = task.toLowerCase();
-    const normalized = path.toLowerCase();
-    const basename = normalized.split("/").at(-1) ?? normalized;
-    const providerRuntimeTask = /\b(provider|provider-specific|runtime|codex|claude)\b/.test(normalizedTask);
-    if (/\bdebug(?:ging)?\b/.test(normalizedTask) &&
-        !isTangentialDevtoolsTraceDebugPath(path) &&
-        (basename === "codex_trace.py" ||
-            basename === "session_trace_archive.py" ||
-            basename === "toolcard.tsx" ||
-            basename === "devtools-helpers.ts" ||
-            basename === "devtoolsservice.ts" ||
-            basename === "usedevtoolsqueries.ts" ||
-            basename === "devtoolsnavstore.ts" ||
-            basename === "messagerenderer.tsx" ||
-            basename === "rightpaneldevtools.tsx" ||
-            basename === "rightpanel.tsx" ||
-            basename === "usemessagecache.ts" ||
-            basename === "chat.tsx" ||
-            basename === "right-panel-devtools.test.tsx" ||
-            normalized.endsWith("/api/endpoints/devtools.py") ||
-            normalized.endsWith("/models/db_models/session_trace_archive.py") ||
-            normalized.includes("devtools-helpers.test") ||
-            normalized.includes("toolexpand.test") ||
-            normalized.includes("devtoolsnavstore.test"))) {
-        return true;
-    }
-    if (/\breview\b/.test(normalizedTask) &&
-        !isTangentialCodexRuntimeReviewUiPath(path) &&
-        ((normalized.endsWith("/core/config.py") &&
-            /\bconfig(?:uration)?\b/.test(normalizedTask)) ||
-            basename === "constants.py" ||
-            basename === "permission_manager.py" ||
-            basename === "ai_model.py" ||
-            basename === "permissions.py" ||
-            basename === "permission_mode.py" ||
-            basename === "permissions.ts" ||
-            basename === "effort.py" ||
-            basename === "usepermissionrequest.ts" ||
-            basename === "usemessageactions.ts" ||
-            basename === "fileuploaddialog.tsx" ||
-            basename === "modelprovider.ts" ||
-            basename === "ai_models.py" ||
-            basename === "test_ai_models_codex_gate.py" ||
-            basename === "model_provider_auth.py" ||
-            basename === "chat.types.ts" ||
-            basename === "chatservice.ts" ||
-            normalized.endsWith("/api/endpoints/chat.py") ||
-            normalized.endsWith("/services/chat.py") ||
-            basename === "streamservice.ts" ||
-            basename === "fileuploaddialog.codex.test.tsx" ||
-            basename === "test_permissions.py" ||
-            basename === "test_model_provider_auth.py" ||
-            normalized.endsWith("/api/endpoints/permissions.py") ||
-            isTaskCriticalReviewDoc(normalized) ||
-            normalized.includes("resolver") && normalized.includes("test") ||
-            normalized.includes("modelprovider") && normalized.includes("test"))) {
-        return true;
-    }
-    if (/\bdiscovery\b/.test(normalizedTask) &&
-        (basename === "permission_mode.py" ||
-            normalized.endsWith("/services/chat.py") ||
-            normalized.endsWith("/components/chat/chat-window/chat.tsx") ||
-            normalized.endsWith("/components/chat/message-input/input.tsx") ||
-            normalized.endsWith("/components/chat/message-input/composerruntimecontrols.tsx") ||
-            normalized.endsWith("/components/chat/message-input/inputsettingspopover.tsx") ||
-            normalized.endsWith("/hooks/usechatruntimesettings.ts") ||
-            normalized.endsWith("/pages/chatpage.tsx") ||
-            normalized.endsWith("/api/endpoints/chat.py") ||
-            normalized.endsWith("/models/db_models/chat.py") ||
-            normalized.endsWith("/models/schemas/chat.py") ||
-            basename === "chatservice.ts" ||
-            basename === "messagequeuestore.ts" ||
-            basename === "streamservice.ts" ||
-            basename === "messagequeuestore.ts" ||
-            basename === "usepermissionrequest.ts" ||
-            basename === "usesettingsqueries.ts" ||
-            basename === "chat_processor.py" ||
-            basename === "landingpage.tsx" ||
-            basename === "usechatstreaming.ts" ||
-            basename === "usemessageactions.ts" ||
-            basename === "queue.py" ||
-            basename === "test_chat.py" ||
-            basename === "test_queue.py" ||
-            normalized.endsWith("/tests/services/test_queue.py") ||
-            basename === "test_effort_level.py" ||
-            basename === "test_permission_mode.py" ||
-            basename === "test_codex_runtime.py" ||
-            basename === "test_codex_effort_translation.py" ||
-            normalized.endsWith("/services/runtime/claude.py") ||
-            normalized.endsWith("/services/runtime/codex.py") ||
-            normalized.endsWith("/services/runtime/claude.py") ||
-            normalized.endsWith("/services/runtime/base.py") ||
-            normalized.endsWith("/services/runtime/claude.py") ||
-            normalized.endsWith("/services/runtime/codex_approval.py") ||
-            normalized.endsWith("/services/runtime_session_service.py") ||
-            basename === "test_pending_initial_prompt_service.py" ||
-            basename === "queue.types.ts" ||
-            basename === "chat.types.ts" ||
-            basename.includes("permissionmodeselector") ||
-            basename.includes("thinkingmodeselector"))) {
-        return true;
-    }
-    if (providerRuntimeTask &&
-        /\b(provider-specific|provider\s+semantics|providers?|claude|agent|symmetry)\b/.test(normalizedTask) &&
-        (basename === "claude_agent.py" || normalized.endsWith("/runtime/base.py"))) {
-        return true;
-    }
-    return false;
-}
 function fileCoversCandidate(file, candidate) {
     return file.ranges.some((range) => range.start_line <= 1 &&
         range.end_line >= Math.max(1, candidate.line_count));
 }
-function compareTaskCriticalCandidates(left, right, task) {
-    return (taskCriticalPathRank(left.path, task) - taskCriticalPathRank(right.path, task) ||
-        left.byte_length - right.byte_length ||
-        left.root_index - right.root_index ||
-        left.path.localeCompare(right.path));
-}
-function taskCriticalPathRank(path, task) {
-    const normalized = path.toLowerCase();
-    const basename = normalized.split("/").at(-1) ?? normalized;
-    const normalizedTask = task.toLowerCase();
-    if (/\bdiscovery\b/.test(normalizedTask)) {
-        if (isRuntimeSettingsDiscoveryTask(task) &&
-            isTangentialRuntimeSettingsDiscoveryTestPath(normalized, basename)) {
-            return 5;
-        }
-        if (isRuntimeSettingsDiscoveryTask(task)) {
-            const runtimeRank = runtimeSettingsDiscoveryTaskCriticalRank(normalized, basename);
-            if (runtimeRank != null) {
-                return runtimeRank;
-            }
-        }
-        if (normalized.endsWith("/services/chat.py") ||
-            normalized.endsWith("/components/chat/chat-window/chat.tsx") ||
-            normalized.endsWith("/components/chat/message-input/input.tsx") ||
-            normalized.endsWith("/components/chat/message-input/composerruntimecontrols.tsx") ||
-            normalized.endsWith("/components/chat/message-input/inputsettingspopover.tsx") ||
-            normalized.endsWith("/pages/chatpage.tsx") ||
-            normalized.endsWith("/models/db_models/chat.py") ||
-            normalized.endsWith("/models/schemas/chat.py") ||
-            basename === "chatservice.ts" ||
-            basename === "streamservice.ts" ||
-            basename === "usemessageactions.ts" ||
-            basename === "usechatstreaming.ts" ||
-            basename === "landingpage.tsx" ||
-            basename === "chat_processor.py" ||
-            basename === "test_queue.py" ||
-            normalized.endsWith("/tests/services/test_queue.py") ||
-            basename === "test_chat.py" ||
-            basename === "test_queue_service.py" ||
-            basename === "test_chat_processor.py" ||
-            normalized.endsWith("/services/runtime/claude.py") ||
-            normalized.endsWith("/services/runtime/codex.py") ||
-            normalized.endsWith("/services/runtime/codex_stream_processor.py") ||
-            normalized.endsWith("/services/runtime/base.py") ||
-            normalized.endsWith("/services/runtime/claude.py") ||
-            normalized.endsWith("/services/runtime/codex_approval.py") ||
-            normalized.endsWith("/services/runtime_session_service.py") ||
-            normalized.endsWith("/models/db_models/runtime_session.py") ||
-            normalized.endsWith("/services/permission_manager.py") ||
-            normalized.endsWith("/hooks/__tests__/usechatruntimesettings.test.ts") ||
-            normalized.endsWith("/pages/landingpage.test.tsx") ||
-            normalized.endsWith("/tests/test_codex_runtime_data_migration.py") ||
-            basename === "chat.types.ts" ||
-            basename === "queue.types.ts" ||
-            basename.includes("permissionmodeselector") ||
-            basename.includes("thinkingmodeselector")) {
-            return 0;
-        }
-        if (basename === "test_effort_level.py" ||
-            basename === "test_permission_mode.py" ||
-            basename === "test_codex_runtime.py" ||
-            basename === "test_codex_effort_translation.py") {
-            return 1;
-        }
-        if ((basename === "claude_agent.py" || basename === "test_claude_agent.py") &&
-            /\b(provider-specific|provider\s+semantics|providers?|claude|agent|symmetry)\b/.test(normalizedTask)) {
-            return 0;
-        }
-        if (basename === "test_codex_e2e_live.py" ||
-            basename === "test_codex_sdk_smoke.py" ||
-            basename === "test_transport_absence.py" ||
-            basename === "test_codex_runtime_live.py" ||
-            basename === "test_resolver.py") {
-            return 5;
-        }
-    }
-    if (/\breview\b/.test(normalizedTask)) {
-        if (normalized.endsWith("/api/endpoints/permissions.py") ||
-            (normalized.endsWith("/core/config.py") &&
-                /\bconfig(?:uration)?\b/.test(normalizedTask)) ||
-            normalized.endsWith("/services/runtime/codex.py") ||
-            normalized.endsWith("/services/runtime/codex_approval.py") ||
-            normalized.endsWith("/services/runtime/codex_stream_processor.py") ||
-            normalized.endsWith("/services/runtime/resolver.py") ||
-            normalized.endsWith("/services/runtime_session_service.py") ||
-            normalized.endsWith("/services/sandbox/provider.py") ||
-            normalized.endsWith("/services/streaming/context_usage.py") ||
-            normalized.endsWith("/services/model_provider_auth.py") ||
-            normalized.endsWith("/services/providerauthservice.ts") ||
-            normalized.endsWith("/services/streamservice.ts") ||
-            normalized.endsWith("/hooks/usechatruntimesettings.ts") ||
-            normalized.endsWith("/components/chat/permission-mode-selector/permissionmodeselector.tsx") ||
-            normalized.endsWith("/components/chat/thinking-mode-selector/thinkingmodeselector.tsx") ||
-            normalized.endsWith("/components/chat/message-input/composerruntimecontrols.tsx") ||
-            normalized.endsWith("/api/endpoints/ai_models.py") ||
-            normalized.endsWith("/tests/test_ai_models_codex_gate.py") ||
-            normalized.endsWith("/services/streaming/orchestrator.py") ||
-            (normalized.endsWith("/tests/services/streaming/test_context_usage_payloads.py") &&
-                /\bcontext\s+usage|usage\s+payloads?\b/.test(normalizedTask)) ||
-            normalized.includes("/tests/services/runtime/") ||
-            normalized.endsWith("/tests/services/test_model_provider_auth.py") ||
-            normalized.endsWith("/tests/services/test_runtime_session_service.py") ||
-            normalized.endsWith("/api/endpoints/chat.py") ||
-            normalized.endsWith("/services/chat.py") ||
-            normalized.endsWith("/models/db_models/ai_model.py") ||
-            basename === "constants.py" ||
-            basename === "usepermissionrequest.ts" ||
-            basename === "usemessageactions.ts" ||
-            basename === "fileuploaddialog.tsx" ||
-            basename === "modelprovider.ts" ||
-            basename === "test_permissions.py" ||
-            basename === "permission_manager.py" ||
-            basename === "chatservice.ts" ||
-            basename === "chat.types.ts") {
-            return 0;
-        }
-        if (isTaskCriticalReviewDoc(normalized)) {
-            return 2;
-        }
-        if (normalized.includes("/admin/config.py") ||
-            normalized.includes("/.ai/memory-bank/")) {
-            return 5;
-        }
-    }
-    if (isDevtoolsTraceDebugTask(task)) {
-        if (isTangentialDevtoolsTraceDebugPath(path)) {
-            return 5;
-        }
-        if (normalized.endsWith("/components/right-panel/rightpaneldevtools.tsx") ||
-            normalized.endsWith("/components/right-panel/__tests__/right-panel-devtools.test.tsx") ||
-            normalized.endsWith("/components/chat/__tests__/chat.autoscroll.test.tsx") ||
-            normalized.endsWith("/components/right-panel/devtools-helpers.ts") ||
-            normalized.endsWith("/store/devtoolsnavstore.ts") ||
-            normalized.endsWith("/store/__tests__/devtoolsnavstore.test.ts") ||
-            normalized.endsWith("/components/chat/chat-window/chat.tsx") ||
-            normalized.endsWith("/components/chat/message-bubble/messagerenderer.tsx") ||
-            normalized.endsWith("/components/chat/tools/common/toolcard.tsx") ||
-            normalized.endsWith("/components/chat/message-bubble/message.tsx")) {
-            return 0;
-        }
-        if (normalized.endsWith("/hooks/queries/usedevtoolsqueries.ts") ||
-            normalized.endsWith("/services/devtoolsservice.ts") ||
-            normalized.endsWith("/hooks/queries/querykeys.ts") ||
-            normalized.endsWith("/utils/messagecacheorder.ts") ||
-            normalized.endsWith("/hooks/usemessagecache.ts") ||
-            normalized.endsWith("/components/chat/tools/common/toolexpandcontext.ts") ||
-            normalized.endsWith("/components/chat/tools/common/__tests__/toolexpand.test.tsx")) {
-            return 1;
-        }
-        if (normalized.endsWith("/api/endpoints/devtools.py") ||
-            normalized.endsWith("/services/session_trace_archive.py")) {
-            return 3;
-        }
-        if (normalized.endsWith("/models/db_models/session_trace_archive.py") ||
-            normalized.endsWith("/models/schemas/devtools.py") ||
-            normalized.endsWith("/services/codex_trace.py") ||
-            normalized.endsWith("/types/devtools.types.ts")) {
-            return 4;
-        }
-        if (normalized.endsWith("/pages/chatpage.tsx") ||
-            normalized.endsWith("/components/chat/message-input/input.tsx") ||
-            normalized.endsWith("/api/endpoints/chat.py") ||
-            normalized.endsWith("/services/claude_agent.py") ||
-            normalized.endsWith("/services/chat.py") ||
-            normalized.endsWith("/services/chatservice.ts")) {
-            return 4;
-        }
-    }
-    if (basename === "permission_mode.py" ||
-        basename === "effort.py" ||
-        basename === "permissions.py" ||
-        basename === "constants.py" ||
-        basename === "config.py" ||
-        basename === "querykeys.ts" ||
-        basename.endsWith(".types.ts")) {
-        return 0;
-    }
-    if (basename.endsWith(".test.tsx") || basename.endsWith(".test.ts")) {
-        return 2;
-    }
-    return 1;
-}
-function runtimeSettingsDiscoveryTaskCriticalRank(normalizedPath, basename) {
-    if (normalizedPath.endsWith("/hooks/usechatruntimesettings.ts")) {
-        return 0;
-    }
-    if (normalizedPath.endsWith("/components/chat/message-input/composerruntimecontrols.tsx") ||
-        normalizedPath.endsWith("/components/chat/message-input/input.tsx") ||
-        normalizedPath.endsWith("/pages/chatpage.tsx")) {
-        return 0;
-    }
-    if (normalizedPath.endsWith("/services/chatservice.ts") ||
-        normalizedPath.endsWith("/api/endpoints/chat.py") ||
-        normalizedPath.endsWith("/services/chat.py")) {
-        return 0;
-    }
-    if (normalizedPath.endsWith("/store/messagequeuestore.ts") ||
-        normalizedPath.endsWith("/store/__tests__/messagequeuestore.test.ts") ||
-        normalizedPath.endsWith("/services/queueservice.ts") ||
-        normalizedPath.endsWith("/tests/services/test_queue.py") ||
-        normalizedPath.endsWith("/tests/test_queue.py") ||
-        normalizedPath.endsWith("/tests/services/test_pending_initial_prompt_service.py")) {
-        return 0;
-    }
-    if (normalizedPath.endsWith("/services/runtime/codex.py") ||
-        normalizedPath.endsWith("/services/runtime/claude.py") ||
-        normalizedPath.endsWith("/services/runtime/codex_approval.py") ||
-        normalizedPath.endsWith("/services/runtime/codex_stream_processor.py") ||
-        normalizedPath.endsWith("/services/runtime_session_service.py") ||
-        normalizedPath.endsWith("/services/streaming/orchestrator.py")) {
-        return 0;
-    }
-    if (normalizedPath.endsWith("/hooks/__tests__/usechatruntimesettings.test.ts") ||
-        normalizedPath.endsWith("/pages/landingpage.test.tsx") ||
-        normalizedPath.endsWith("/tests/services/runtime/test_codex_runtime.py") ||
-        normalizedPath.endsWith("/tests/test_codex_runtime_data_migration.py") ||
-        normalizedPath.endsWith("/tests/test_codex_effort_translation.py") ||
-        normalizedPath.endsWith("/tests/test_effort_level.py") ||
-        normalizedPath.endsWith("/tests/test_permission_mode.py") ||
-        normalizedPath.endsWith("/tests/services/test_claude_agent.py")) {
-        return 1;
-    }
-    if (basename === "effort.py" ||
-        basename === "permission_mode.py" ||
-        basename === "chat.types.ts" ||
-        basename === "queue.types.ts" ||
-        normalizedPath.endsWith("/models/schemas/chat.py") ||
-        normalizedPath.endsWith("/models/db_models/chat.py") ||
-        normalizedPath.endsWith("/models/db_models/runtime_session.py") ||
-        basename.includes("permissionmodeselector") ||
-        basename.includes("thinkingmodeselector")) {
-        return 2;
-    }
-    return null;
-}
-function isTaskCriticalReviewDoc(normalizedPath) {
-    if (!normalizedPath.endsWith(".md")) {
-        return false;
-    }
-    if (normalizedPath.startsWith(".ai/memory-bank/") || normalizedPath.includes("/.ai/memory-bank/")) {
-        return false;
-    }
-    if (normalizedPath.startsWith(".ai/") || normalizedPath.includes("/.ai/")) {
-        return false;
-    }
-    if (normalizedPath.endsWith("docs/ops/nano-permissions-policy.md")) {
-        return false;
-    }
-    return (/(^|\/)docs?\/.*(codex|approval|permission|session|runtime).*\.md$/.test(normalizedPath));
-}
 function handleDelegateRuntimeFailure(input) {
-    const failureReason = sanitizeDiagnosticText(input.reason);
+    // Delegate-failure reasons aggregate many per-entry details (each already
+    // individually sanitized/redacted where assembled); the wider marked-
+    // truncation bound keeps the tail from being silently dropped.
+    const failureReason = sanitizeDelegateFailureText(input.reason);
     if (input.delegate.failure_policy === "fail") {
-        throw new ExecutionError(`context_builder delegate failed: ${failureReason}`);
+        const error = new ExecutionError(`context_builder delegate failed: ${failureReason}`);
+        if (input.failureKind === "timeout") {
+            error.failureClass = "transient";
+        }
+        throw error;
     }
     const warnings = [
         delegateWarning("delegate_fallback", `Delegate curation failed; deterministic selection was used. ${failureReason}`),
@@ -3170,6 +1423,11 @@ function handleDelegateRuntimeFailure(input) {
             omission_count: input.omissionCount,
             failure_reason: failureReason,
         },
+        observability: input.observability ?? {
+            curator_ms: null,
+            finalizer_ms: null,
+            delegate_packet_size: 0,
+        },
     };
 }
 function formatOmissionForDelegateFailure(omission) {
@@ -3178,6 +1436,34 @@ function formatOmissionForDelegateFailure(omission) {
         : boundContextBuilderPathList(omission.paths).join(", ");
     return `${omission.reason} (${paths}): ${sanitizeDiagnosticText(omission.message)}`;
 }
+// Bounds for the aggregated delegate-failure omission list. Entries past the
+// cap are dropped with an explicit `(+N more omissions)` marker and the total
+// count always leads the message, so truncation is never silent.
+const DELEGATE_FAILURE_MAX_OMISSION_ENTRIES = 6;
+const DELEGATE_FAILURE_MAX_ENTRY_TEXT_LENGTH = 240;
+const DELEGATE_FAILURE_MAX_ENTRY_PATHS = 5;
+function formatOmissionsForDelegateFailure(omissions) {
+    const total = omissions.length;
+    const shown = omissions
+        .slice(0, DELEGATE_FAILURE_MAX_OMISSION_ENTRIES)
+        .map(formatOmissionEntryForDelegateFailure);
+    const droppedSuffix = total > shown.length ? ` (+${total - shown.length} more omissions)` : "";
+    return `${total} omission${total === 1 ? "" : "s"}: ${shown.join("; ")}${droppedSuffix}`;
+}
+function formatOmissionEntryForDelegateFailure(omission) {
+    // Redaction happens per entry, BEFORE assembly into the aggregate message:
+    // paths through boundContextBuilderPathList (secret-path redaction) and free
+    // text through the marked bounded sanitizer, so no entry can smuggle secret
+    // material into the joined reason and no entry ends in an unmarked "...".
+    const allPaths = omission.paths ?? [];
+    const shownPaths = boundContextBuilderPathList(allPaths, DELEGATE_FAILURE_MAX_ENTRY_PATHS);
+    const pathText = shownPaths.length === 0
+        ? "unknown focused path"
+        : allPaths.length > shownPaths.length
+            ? `${shownPaths.join(", ")} (+${allPaths.length - shownPaths.length} more paths)`
+            : shownPaths.join(", ");
+    return `${sanitizeDelegateFailureText(omission.reason, DELEGATE_FAILURE_MAX_ENTRY_TEXT_LENGTH)} (${pathText}): ${sanitizeDelegateFailureText(omission.message, DELEGATE_FAILURE_MAX_ENTRY_TEXT_LENGTH)}`;
+}
 function rangeCoveredByRanges(target, ranges) {
     let nextLine = target.start_line;
     for (const range of [...ranges].sort((left, right) => left.start_line - right.start_line || left.end_line - right.end_line)) {
@@ -3239,6 +1525,9 @@ function delegateCompletenessFailure(input) {
     if (materialWarnings.length > 0) {
         return `delegate warnings reported material evidence gaps: ${materialWarnings.join("; ")}`;
     }
+    return requiredFocusCoverageFailure(input);
+}
+function requiredFocusCoverageFailure(input) {
     const required = requiredFocusEvidenceSelections(input);
     if (required.length === 0) {
         return undefined;
@@ -3263,6 +1552,53 @@ function delegateCompletenessFailure(input) {
         .join(",")}`)
         .join("; ")}`;
 }
+// Curator-only post-repair guard. Unlike the finalizer branch, the curator-only
+// path does not fold required-focus ranges, so its baseline is the curator's
+// own pre-repair selection. Repair is allowed to:
+//   - COMPACT a required-focus file's ranges to fit budget pressure (the file
+//     stays in the bundle, just sliced — the documented focus-slicing behavior); and
+//   - DROP a degenerate (whitespace-only) selected slice entirely (server-dropped).
+// The HIGH failure mode this guards is repair evicting a NON-degenerate
+// required-focus candidate ENTIRELY: a focus file with real content that the
+// curator selected and that survived reconstruction must not silently vanish
+// from the post-repair selection. Whole-file eviction of non-empty required
+// focus fails closed.
+function postRepairRequiredFocusEvictionFailure(input) {
+    // Root-aware required-focus key set: a multi-root run can carry the same
+    // relative path under two roots, only one of which is required focus. Keying
+    // the required set by bare path would misclassify the non-required twin.
+    const requiredKeys = new Set(input.candidates
+        .filter((candidate) => candidate.focus_requested === true &&
+        (candidate.required_focus_ranges?.length ?? 0) > 0 &&
+        candidateMatchesFocusPath(candidate, input.focusPaths))
+        .map((candidate) => `${candidate.root_index}:${candidate.path}`));
+    if (requiredKeys.size === 0) {
+        return undefined;
+    }
+    const selectedFileKey = (file) => `${file.root_index}:${file.path}`;
+    // Pre-repair required-focus files that carried real (non-whitespace) content.
+    // A whitespace-only focus slice is legitimately server-dropped by repair, so
+    // exempt it — only its eviction is a no-op, never a hard failure.
+    const preRepairRequired = new Map();
+    for (const file of input.preRepairSelected) {
+        if (requiredKeys.has(selectedFileKey(file)) &&
+            file.ranges.length > 0 &&
+            file.content.trim().length > 0) {
+            preRepairRequired.set(selectedFileKey(file), file);
+        }
+    }
+    const postRepairKeys = new Set(input.postRepairSelected
+        .filter((file) => file.ranges.length > 0)
+        .map(selectedFileKey));
+    const evicted = [...preRepairRequired.values()]
+        .filter((file) => !postRepairKeys.has(selectedFileKey(file)))
+        .map((file) => `root ${file.root_index}: ${file.path}`);
+    if (evicted.length === 0) {
+        return undefined;
+    }
+    return `repair evicted required-focus evidence the curator selection carried: ${evicted.join("; ")}`;
+}
+export const postRepairRequiredFocusEvictionFailureForTest = postRepairRequiredFocusEvictionFailure;
 function warningReferencesSelectedDelegateCandidate(input) {
     const selectedCandidateIds = new Set(input.selected.map((selection) => selection.candidate_id));
     const selectedFiles = input.candidates
@@ -3281,6 +1617,37 @@ function warningReferencesSelectedDelegateCandidate(input) {
     }));
     return isStaleSelectedContextOmissionWarning(input.warning.toLowerCase(), selectedFiles);
 }
+/**
+ * Re-express a materialized (post-budget reconstruction) selection as
+ * candidate-id-keyed proposal selections so completeness can be evaluated
+ * against what actually survived the local reconstruction budget — not what
+ * the finalizer merely requested. A candidate dropped by the budget guard is
+ * absent here, so any required-focus range it carried reads as uncovered and
+ * fails closed in delegateCompletenessFailure.
+ */
+function materializeFinalizerSelection(selected, candidates) {
+    const candidateIdByKey = new Map();
+    for (const candidate of candidates) {
+        candidateIdByKey.set(`${candidate.root_index}:${candidate.path}`, candidate.id);
+    }
+    const materialized = [];
+    for (const file of selected) {
+        const candidateId = candidateIdByKey.get(`${file.root_index}:${file.path}`);
+        if (candidateId == null) {
+            continue;
+        }
+        materialized.push({
+            candidate_id: candidateId,
+            reason: "materialized post-budget selection",
+            ranges: file.ranges.map((range) => ({
+                start_line: range.start_line,
+                end_line: range.end_line,
+                reason: "materialized post-budget selection range",
+            })),
+        });
+    }
+    return materialized;
+}
 function requiredFocusEvidenceSelections(input) {
     if (input.focusPaths.length === 0) {
         return [];
@@ -3455,10 +1822,139 @@ function augmentCuratorProposalWithDeterministicBaseline(proposal, packet, maxSe
 function totalSelectedRangeLines(ranges) {
     return ranges.reduce((total, range) => total + Math.max(0, range.end_line - range.start_line + 1), 0);
 }
-export function renderDelegatePrompt(stage, packet) {
+/**
+ * Renders the server-enforced coverage obligations as explicit prompt rules.
+ *
+ * The obligations are already present in the serialized packet, but the packet
+ * alone never told the delegate they were MANDATORY, so a schema-valid proposal
+ * could miss one and be rejected by
+ * {@link validateContextBuilderDelegateCoverageSelection}.
+ *
+ * Branch selection here tracks that validator's branch selection: it enters the
+ * obligation branch on `obligations != null`, NOT on a non-empty target list.
+ * Branching on `targets.length > 0` instead would render the satisfiable
+ * evidence-class contract for a packet the validator rejects outright, i.e.
+ * instruct the delegate to do something that provably cannot pass.
+ */
+function packetCoverageObligationRules(packet) {
+    if (packet == null || typeof packet !== "object") {
+        return [];
+    }
+    const policy = packet["coverage_policy"];
+    if (policy == null || typeof policy !== "object") {
+        return [];
+    }
+    const policyRecord = policy;
+    if (policyRecord["policy_id"] !== "review_deep_v1") {
+        return [];
+    }
+    const requiredClasses = policyRecord["required_when_available"];
+    if (!Array.isArray(requiredClasses) || requiredClasses.length === 0) {
+        return [];
+    }
+    const obligations = policyRecord["obligations"];
+    if (obligations != null && typeof obligations === "object") {
+        const targets = obligations["targets"];
+        if (!Array.isArray(targets) || targets.length === 0) {
+            // The validator rejects a present-but-empty target list unconditionally,
+            // so no instruction rendered here could be satisfied. Stay silent rather
+            // than describe a contract the delegate cannot meet. (The server building
+            // a packet it will always reject is a separate defect; do not paper over
+            // it by rendering the evidence-class rules the validator will not apply.)
+            return [];
+        }
+        return [
+            "Coverage obligations (mandatory, server-enforced):",
+            "- packet.coverage_policy.obligations.targets is required coverage, not a suggestion. Server validation rejects your output if any obligation below is unmet, even when every other rule is satisfied.",
+            "- For EVERY target: selected MUST contain that target's candidate_id with at least one range that overlaps one of that target's ranges.",
+            "- For EVERY target whose regression_links is non-empty: selected MUST also contain at least ONE of those links' candidate_id with an overlapping range. One linked candidate per target is sufficient; you do not need all of them.",
+            "- Obligations hold even when the task reads narrower than the obligation set. Add the obligation candidates alongside your task-driven picks rather than dropping them.",
+        ];
+    }
+    const classes = requiredClasses.filter((entry) => typeof entry === "string");
+    if (classes.length === 0) {
+        return [];
+    }
+    return [
+        "Coverage obligations (mandatory, server-enforced):",
+        `- packet.coverage_policy.required_when_available lists required evidence classes: ${classes.join(", ")}.`,
+        "- For every listed class that ANY packet candidate carries in its evidence_classes, selected MUST include at least one candidate carrying that class. Server validation rejects your output otherwise.",
+    ];
+}
+/**
+ * Renders the finalizer scoring contract.
+ *
+ * `min_score` is a server-side gate
+ * ({@link validateContextBuilderFinalizerOutput}); before this it was never
+ * sent to the model, so the finalizer was asked to clear a bar it could not
+ * see, on a scale that was never defined. The rubric below is deliberately
+ * anchored so that an approving score lands at or above the threshold, and it
+ * names the dominant real-world failure mode: penalizing the packet for
+ * evidence the packet was never meant to contain.
+ */
+function finalizerScoringRules(minScore) {
+    if (minScore == null) {
+        return [];
+    }
+    // A threshold of 0 cannot reject anything (the gate is `score < minScore`), so
+    // the usual "below X, do not approve" band would render a range no score can
+    // occupy and instruct the delegate to "honestly reach 0". State the degenerate
+    // case plainly instead of rendering an impossible rule.
+    const scoreBands = minScore <= 0
+        ? [
+            `- score does not gate this request (any score clears a minimum of ${minScore}); express insufficiency through approved:false and concrete omissions, never through a low score.`,
+        ]
+        : [
+            "- score rates ONLY whether the `selected` you are returning is sufficient, correct local evidence for packet.task, judged against the evidence actually present in this packet:",
+            // Bands are stated relative to the live threshold rather than as fixed
+            // ranges. Fixed bands (9-10 / 6-8 / 0-5) left the shipped 8.5 default
+            // in an undefined gap, and at a lower configured threshold they
+            // labelled the passing score as deficient — telling the delegate to
+            // approve while self-reporting a score whose own band calls the
+            // selection inadequate.
+            `  - ${minScore}-10: selected is sufficient for the task; no packet evidence the task requires was left out.`,
+            `  - below ${minScore}: selected is wrong, or omits locally-available packet evidence the task needs. Do not approve.`,
+            `- If you would approve, return a score at or above ${minScore}. If you cannot honestly reach ${minScore}, set approved:false and list concrete omissions rather than approving with a failing score.`,
+        ];
+    return [
+        "Scoring (server-enforced):",
+        `- score >= ${minScore} clears the score gate; below ${minScore} fails the whole request regardless of everything else. Clearing the score gate is necessary but NOT sufficient — approved, omissions, warnings, selections, coverage, and budget are each validated separately.`,
+        ...scoreBands,
+        "- Do NOT lower score for evidence that is absent from the packet, outside the bounded task, or that you merely suspect exists elsewhere in the repository. The packet is intentionally bounded and is the only source of truth for this call.",
+        // The server scans warnings with a keyword-proximity matcher
+        // (isMaterialEvidenceGapWarning) that has no negation handling, so an
+        // affirmative all-clear is rejected exactly like a real gap report. Name the
+        // exact fatal phrasings; a partial description reads as authoritative and is
+        // worse than none.
+        "- warnings carry speculative or out-of-scope notes ONLY, and the server scans them for evidence-gap phrasing. Do not mention required, requested, or focused evidence in warnings at all — not even to state that nothing is missing — and never phrase a warning as 'outside the selected range(s)' or as 'selected ... not present/not selectable/unselectable'. That scan is a keyword-proximity match with no negation handling, so an affirmative all-clear is rejected exactly like a real gap report.",
+        "- If required evidence is genuinely missing, set approved:false with concrete omissions. Never route a real coverage gap into warnings.",
+    ];
+}
+/**
+ * Single source for every score exemplar the finalizer prompt shows.
+ *
+ * The shape example, the rubric bands, and the minimum-output example must all
+ * derive from the live threshold: hardcoding them let the prompt display a
+ * score that its own rubric did not cover, and (at `min_score` above the
+ * hardcoded value — 9.25 is schema-legal) an example that would fail the very
+ * gate it was illustrating.
+ */
+function finalizerExampleScore(minScore) {
+    // A non-gating threshold gets the neutral fallback rather than its own value:
+    // "emit the lowest score that still clears the gate" is the right anti-inflation
+    // rule wherever a gate exists, but at 0 it would render `{"score":0,"approved":true}`
+    // and an unsure finalizer copying that reports a 0-scored approval into
+    // `finalizer_score` observability. A higher exemplar always clears a lower gate.
+    return minScore == null || minScore <= 0 ? 9 : minScore;
+}
+export function renderDelegatePrompt(stage, packet, options) {
+    // Diagnostic-array exemplars are non-empty on purpose: empty arrays cannot
+    // communicate element types, and a live finalizer failure returned
+    // object-shaped `omissions`. The angle-bracket entries are placeholders that
+    // show each element is one plain string.
     const outputShape = stage === "curator"
-        ? '{"selected":[{"candidate_id":"c:0:path","ranges":[{"start_line":1,"end_line":1,"reason":"why this range"}],"reason":"why this file"}],"warnings":[],"open_questions":[]}'
-        : '{"score":9,"approved":true,"selected":[{"candidate_id":"c:0:path","ranges":[{"start_line":1,"end_line":1,"reason":"why this range"}],"reason":"why this file"}],"warnings":[],"omissions":[]}';
+        ? '{"selected":[{"candidate_id":"c:0:path","ranges":[{"start_line":1,"end_line":1,"reason":"why this range"}],"reason":"why this file"}],"warnings":["<short plain-string caveat>"],"open_questions":["<short plain-string follow-up question>"]}'
+        : `{"score":${finalizerExampleScore(options?.minScore)},"approved":true,"selected":[{"candidate_id":"c:0:path","ranges":[{"start_line":1,"end_line":1,"reason":"why this range"}],"reason":"why this file"}],"warnings":["<short plain-string caveat>"],"omissions":["<short plain string describing an omitted file or range; must be [] when approving>"]}`;
     const stageRules = stage === "curator"
         ? [
             "Curator-specific rules:",
@@ -3468,6 +1964,10 @@ export function renderDelegatePrompt(stage, packet) {
             "- Use packet.deterministic_selection.selected as the safe starting point; keep relevant deterministic candidates unless the task clearly excludes them.",
             "- Treat the minimum valid JSON example as a floor, not a complete packet. Add task-critical candidates from packet.candidates when deterministic_selection is sparse or omissions show important local evidence was budget-pruned.",
             "- Do not return selected:[] to express uncertainty. Select the closest relevant local candidate and put caveats in warnings or open_questions.",
+            // The validator requires string elements (SafeTextSchema) in every
+            // diagnostic array; empty exemplars alone let models invent object
+            // entries, which fail schema validation.
+            "- warnings and open_questions are arrays of plain strings. Each element is one short plain string; objects inside these arrays are invalid and fail server validation.",
         ]
         : [
             "Finalizer-specific rules:",
@@ -3478,9 +1978,19 @@ export function renderDelegatePrompt(stage, packet) {
             "- Treat packet.deterministic_selection.selected as server-ranked required baseline evidence. If the curator underselected or warned about sparse evidence, add relevant deterministic candidates/ranges that are present in packet.candidates instead of lowering the score for evidence the packet already provides.",
             "- Do not reject solely because the curator warning says broader implementation may exist when deterministic_selection and packet.candidates contain concrete task-critical ranges for that concern.",
             "- If the selected packet evidence is insufficient for the bounded task, set approved:false and explain concrete omissions; the server will treat that as delegate failure according to failure_policy.",
-            "- If approving with score at or above the requested minimum, omissions MUST be []. Put speculative out-of-packet concerns or 'may contain more detail' caveats in warnings instead.",
+            // "'may contain more detail' caveats" invited exactly the phrasing
+            // isMaterialEvidenceGapWarning rejects outright
+            // (/\boutside (?:the )?selected ranges?\b/), so obeying this rule got
+            // the finalizer hard-failed. Steer the caveat at evidence absent from
+            // the packet instead of at the selected ranges.
+            "- If approving with score at or above the requested minimum, omissions MUST be []. Put speculative concerns about evidence absent from this packet in warnings instead.",
+            // The observed live schema failure was object-shaped `omissions`;
+            // state the element type explicitly instead of relying on exemplars.
+            // (No open_questions here: the finalizer schema is strict and would
+            // reject that key as unrecognized.)
+            "- warnings and omissions are arrays of plain strings. Each element is one short plain string; objects inside these arrays are invalid and fail server validation.",
         ];
-    const minimumOutput = buildMinimumDelegateOutput(stage, packet);
+    const minimumOutput = buildMinimumDelegateOutput(stage, packet, options?.minScore);
     return [
         `You are the context_builder ${stage}.`,
         `Prompt version: ${CONTEXT_BUILDER_DELEGATE_PROMPT_VERSION}.`,
@@ -3495,6 +2005,8 @@ export function renderDelegatePrompt(stage, packet) {
             ? "Use the excerpt, search_hits, deterministic_selection, omissions, and task fields as evidence; the packet intentionally omits full source content."
             : "Use the excerpt, search_hits, curator_proposal, deterministic_selection, omissions, and task fields as evidence; the packet intentionally omits full source content.",
         ...stageRules,
+        ...(stage === "finalizer" ? finalizerScoringRules(options?.minScore) : []),
+        ...packetCoverageObligationRules(packet),
         ...(minimumOutput == null
             ? []
             : [
@@ -3510,11 +2022,153 @@ export function renderDelegatePrompt(stage, packet) {
         "Return the JSON object now. If candidates exist, selected must be non-empty.",
     ].join("\n");
 }
-function buildMinimumDelegateOutput(stage, packet) {
-    const minimumSelections = packetMinimumSelections(stage, packet);
+/**
+ * True when `selections` would clear the packet's coverage obligations.
+ *
+ * Mirrors {@link validateContextBuilderDelegateCoverageSelection}: every target
+ * needs an overlapping selected range, and a target with regression links needs
+ * an overlapping range from at least ONE of them (the link check is disjunctive).
+ */
+function selectionsSatisfyPacketObligations(selections, packet) {
+    if (packet == null || typeof packet !== "object") {
+        return true;
+    }
+    const policy = packet["coverage_policy"];
+    if (policy == null || typeof policy !== "object") {
+        return true;
+    }
+    const policyRecord = policy;
+    if (policyRecord["policy_id"] !== "review_deep_v1") {
+        return true;
+    }
+    const requiredClasses = policyRecord["required_when_available"];
+    if (!Array.isArray(requiredClasses) || requiredClasses.length === 0) {
+        return true;
+    }
+    const obligations = policyRecord["obligations"];
+    if (obligations == null || typeof obligations !== "object") {
+        // The validator does NOT concede this branch: it falls through to the
+        // evidence-class check and still rejects a selection that omits an
+        // available required class. Returning true here would advertise an example
+        // the validator rejects. Unreachable through the current packet builder
+        // (normalizeCoveragePolicy attaches obligations for every review_deep_v1
+        // policy), but the two must not disagree — that divergence is the bug
+        // generator this whole change exists to close.
+        const candidates = packet["candidates"];
+        if (!Array.isArray(candidates)) {
+            return true;
+        }
+        const selectedIds = new Set(selections.map((selection) => selection.candidate_id));
+        const evidenceClassesOf = (candidate) => {
+            if (candidate == null || typeof candidate !== "object") {
+                return [];
+            }
+            const classes = candidate["evidence_classes"];
+            return Array.isArray(classes) ? classes : [];
+        };
+        return requiredClasses.every((evidenceClass) => {
+            const available = candidates.some((candidate) => evidenceClassesOf(candidate).includes(evidenceClass));
+            if (!available) {
+                return true;
+            }
+            return candidates.some((candidate) => {
+                const id = candidate != null && typeof candidate === "object"
+                    ? candidate["id"]
+                    : undefined;
+                return (typeof id === "string" &&
+                    selectedIds.has(id) &&
+                    evidenceClassesOf(candidate).includes(evidenceClass));
+            });
+        });
+    }
+    const targets = obligations["targets"];
+    if (!Array.isArray(targets)) {
+        return true;
+    }
+    if (targets.length === 0) {
+        // The validator rejects a present-but-empty target list unconditionally, so
+        // no example can be valid.
+        return false;
+    }
+    const selectedById = new Map(selections.map((selection) => [selection.candidate_id, selection.ranges]));
+    const covers = (value) => {
+        if (value == null || typeof value !== "object") {
+            return false;
+        }
+        const record = value;
+        const candidateId = record["candidate_id"];
+        if (typeof candidateId !== "string") {
+            return false;
+        }
+        const selectedRanges = selectedById.get(candidateId);
+        if (selectedRanges == null || selectedRanges.length === 0) {
+            return false;
+        }
+        const obligationRanges = record["ranges"];
+        if (!Array.isArray(obligationRanges) || obligationRanges.length === 0) {
+            return false;
+        }
+        return obligationRanges.some((range) => {
+            if (range == null || typeof range !== "object") {
+                return false;
+            }
+            const start = range["start_line"];
+            const end = range["end_line"];
+            if (typeof start !== "number" || typeof end !== "number") {
+                return false;
+            }
+            return selectedRanges.some((selectedRange) => selectedRange.start_line <= end && start <= selectedRange.end_line);
+        });
+    };
+    return targets.every((target) => {
+        if (!covers(target)) {
+            return false;
+        }
+        const links = target["regression_links"];
+        if (!Array.isArray(links) || links.length === 0) {
+            return true;
+        }
+        return links.some((link) => covers(link));
+    });
+}
+/** The packet's `budget.max_files`, when it carries a usable one. */
+function packetBudgetMaxFiles(packet) {
+    if (packet == null || typeof packet !== "object") {
+        return null;
+    }
+    const budget = packet["budget"];
+    if (budget == null || typeof budget !== "object") {
+        return null;
+    }
+    const maxFiles = budget["max_files"];
+    return typeof maxFiles === "number" && Number.isFinite(maxFiles) && maxFiles > 0
+        ? maxFiles
+        : null;
+}
+function buildMinimumDelegateOutput(stage, packet, minScore) {
+    const allSelections = packetMinimumSelections(stage, packet);
+    if (allSelections.length === 0) {
+        return null;
+    }
+    // The example is advertised as "minimum valid" and a delegate may copy it
+    // verbatim, so it must satisfy every gate the copy would face.
+    //
+    // packetMinimumSelections bounds by MAX_DELEGATE_MINIMUM_OUTPUT_SELECTIONS,
+    // which is unrelated to the caller's budget: validateBudget rejects a
+    // selection longer than budget.max_files, so an unbounded example was invalid
+    // whenever max_files was the smaller limit. Apply the budget first, then judge
+    // coverage on exactly what is advertised.
+    const maxFiles = packetBudgetMaxFiles(packet);
+    const minimumSelections = maxFiles == null ? allSelections : allSelections.slice(0, maxFiles);
     if (minimumSelections.length === 0) {
         return null;
     }
+    // Neither bound ranks obligations first, so a required target can fall outside
+    // the cap — offering an example that fails coverage validation. Withhold the
+    // example rather than advertise an invalid one.
+    if (!selectionsSatisfyPacketObligations(minimumSelections, packet)) {
+        return null;
+    }
     const selected = minimumSelections.map((selection) => ({
         candidate_id: selection.candidate_id,
         ranges: selection.ranges.map((range) => ({
@@ -3533,7 +2187,13 @@ function buildMinimumDelegateOutput(stage, packet) {
             open_questions: [],
         }
         : {
-            score: 10,
+            // This example is offered to an UNSURE finalizer, and it carries a
+            // deliberately minimal selection. Stamping it `score: 10` would pair
+            // the top of the scale with the floor of the evidence and teach
+            // "when uncertain, emit 10" — inflating the very self-score the gate
+            // relies on. Emit the lowest score that still clears the gate, so the
+            // minimum selection reads as the minimum passing answer.
+            score: finalizerExampleScore(minScore),
             approved: true,
             selected,
             warnings: [
@@ -3591,7 +2251,18 @@ function mergePacketSelections(selections) {
     const merged = new Map();
     for (const selection of selections) {
         const ranges = merged.get(selection.candidate_id) ?? [];
-        ranges.push(...selection.ranges);
+        // Deduplicate by bounds. Sources overlap by construction — a candidate in
+        // deterministic_selection is normally also present in packet.candidates —
+        // so concatenating produced the SAME range twice, and validateSelections
+        // rejects a duplicate range outright. That made the advertised "minimum
+        // valid JSON" example invalid in the ordinary case: a delegate copying it
+        // was hard-failed by the server that offered it.
+        for (const range of selection.ranges) {
+            if (!ranges.some((existing) => existing.start_line === range.start_line &&
+                existing.end_line === range.end_line)) {
+                ranges.push(range);
+            }
+        }
         merged.set(selection.candidate_id, ranges);
     }
     return [...merged].map(([candidate_id, ranges]) => ({
@@ -3645,25 +2316,52 @@ function delegatePromptDiagnostic(packet) {
     const deterministicCount = Array.isArray(deterministicSelected)
         ? deterministicSelected.length
         : 0;
+    // `curator_proposal` only exists on a finalizer packet (curator packets are
+    // built before any proposal exists). Reporting `curator_selected=0` for a
+    // curator packet described the packet's missing field, not the curator's
+    // output, so every curator-stage diagnostic claimed an empty selection that
+    // had in fact never been observed. Omit the field unless the packet carries a
+    // proposal to count.
     const proposal = record["curator_proposal"];
     const proposalSelected = proposal != null && typeof proposal === "object"
         ? proposal["selected"]
         : undefined;
-    const curatorProposalCount = Array.isArray(proposalSelected)
-        ? proposalSelected.length
-        : 0;
-    const minimumSelection = packetMinimumSelections("curator", packet);
+    // `min` must report what the prompt actually carried, not whether a minimum
+    // selection could be computed: buildMinimumDelegateOutput also withholds the
+    // example when it would fail budget or coverage, and a withheld floor example
+    // is exactly the condition worth seeing next to a delegate failure. Derive it
+    // from the same call the prompt makes, at the stage this packet belongs to.
+    const stage = Array.isArray(proposalSelected)
+        ? "finalizer"
+        : "curator";
     return [
         `pv=${CONTEXT_BUILDER_DELEGATE_PROMPT_VERSION}`,
         `candidates=${candidateCount}`,
         `det=${deterministicCount}`,
-        `curator_selected=${curatorProposalCount}`,
-        `min=${minimumSelection.length > 0}`,
+        ...(Array.isArray(proposalSelected)
+            ? [`curator_selected=${proposalSelected.length}`]
+            : []),
+        `min=${buildMinimumDelegateOutput(stage, packet) != null}`,
     ].join("; ");
 }
 function failureReasonFromCall(stage, call) {
     return `${stage} ${call.reason}: ${call.message}`;
 }
+/**
+ * Safe-scalar score context for finalizer rejections. A not-approved rejection
+ * previously carried no score at all; surfacing the reported score next to the
+ * configured min_score makes rejection and under-score failures diagnosable
+ * from the failure reason alone. Only a finite numeric `score` read from the
+ * finalizer's raw JSON is ever included — never free-form provider text.
+ */
+function finalizerScoreDiagnostic(json, minScore) {
+    const rawScore = json != null && typeof json === "object"
+        ? json["score"]
+        : undefined;
+    return typeof rawScore === "number" && Number.isFinite(rawScore)
+        ? `; finalizer_score=${rawScore}; min_score=${minScore}`
+        : `; min_score=${minScore}`;
+}
 function failureReasonFromError(stage, err, diagnostic) {
     const message = err instanceof Error ? err.message : "unknown delegate error";
     return diagnostic == null
@@ -3676,6 +2374,50 @@ function delegateWarning(code, message) {
         message: sanitizeDiagnosticText(message),
     };
 }
+// Bounded per-term detail in the search-cap coverage warning. Full per-term
+// rows (up to the public 20-term cap) persist in manifest/summary
+// `search_coverage`; the warning message stays a compact summary.
+const MAX_SEARCH_CAP_WARNING_TERM_DETAILS = 6;
+/**
+ * Builds the receipt-visible explanation for a MATERIAL search cap. Returns
+ * undefined when the cap was not hit or coverage proves it non-material.
+ * The warning `code` is the stable materiality reason string
+ * (`search_cap_unresolved_coverage` / `search_cap_unsearched_candidates`);
+ * classification itself rides on the cap event in the status reducer, so this
+ * warning is explanatory and never double-counts toward `partial`.
+ * Terms are referenced by `search_term_index`, never by value, so the warning
+ * cannot leak caller term text; the full (sanitized) rows live in
+ * `search_coverage`. The first unsearched candidate's rank/path is not
+ * reported: T1's coverage counters are aggregate-only by design and the
+ * caller-phase scheduler is term-major round-robin, so the searched set is not
+ * an ordering prefix and no per-candidate identity is cheaply available.
+ */
+function searchCapCoverageWarning(searchCapHit, coverage) {
+    if (!searchCapHit) {
+        return undefined;
+    }
+    const materiality = evaluateSearchCapMateriality(coverage);
+    if (!materiality.material) {
+        return undefined;
+    }
+    const incompleteTerms = coverage.caller_terms.filter((term) => !term.scan_complete);
+    const termDetails = incompleteTerms
+        .slice(0, MAX_SEARCH_CAP_WARNING_TERM_DETAILS)
+        .map((term) => `#${term.search_term_index}(hits=${term.hit_count})`)
+        .join(", ");
+    const hiddenIncomplete = incompleteTerms.length - Math.min(incompleteTerms.length, MAX_SEARCH_CAP_WARNING_TERM_DETAILS);
+    const callerSummary = coverage.caller_term_count === 0
+        ? "caller terms 0"
+        : `caller terms ${coverage.caller_term_count} (${incompleteTerms.length} incomplete${termDetails.length === 0 ? "" : `: ${termDetails}`}${hiddenIncomplete > 0 ? `, +${hiddenIncomplete} more` : ""}; ${coverage.caller_record_count} records)`;
+    return {
+        code: materiality.reason,
+        message: `search cap ended discovery before coverage was proven: searched ` +
+            `${coverage.searched_candidate_count}/${coverage.eligible_candidate_count} eligible candidates ` +
+            `(${coverage.unsearched_candidate_count} unsearched); ${callerSummary}; ` +
+            `derived terms ${coverage.derived_term_count} (${coverage.derived_record_count} records); ` +
+            `full per-term coverage is in manifest.json search_coverage`,
+    };
+}
 function reconcileContextBuilderWarnings(input) {
     if (input.warnings.length === 0) {
         return [];