clinkx 0.2.3 → 0.3.0

package/dist/context-builder/handler.js

@@ -0,0 +1,3848 @@
+import { isSamePathOrDescendant } from "../allowed-roots.js";
+import { CancellationError, ExecutionError, InvalidParamsError, } from "../errors.js";
+import { readFileSync, 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 { 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 { 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 { resolveContextBuilderFocusPaths, resolveContextBuilderRoots, } from "./paths.js";
+import { createContextBuilderProgressReporter, } from "./progress.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 { cleanupContextBuilderIncompleteRun, createContextBuilderRun, } from "./storage.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 MAX_DELEGATE_MINIMUM_OUTPUT_SELECTIONS = 24;
+export async function handleContextBuilder(args, options = {}) {
+    const input = parseContextBuilderInput(args);
+    const semaphore = options.semaphore ?? getDefaultContextBuilderSemaphore();
+    semaphore.acquire();
+    const progress = createContextBuilderProgressReporter(options.progress);
+    let storage;
+    let committed = false;
+    try {
+        await progress?.emit("validating");
+        const createdAt = (options.now?.() ?? new Date()).toISOString();
+        const runId = input.run_id ?? generateContextBuilderRunId();
+        const internalCaps = options.internalCaps ?? CONTEXT_BUILDER_INTERNAL_CAP_DEFAULTS;
+        const runsDir = await resolveContextBuilderRunsDir(options.runsDir);
+        const currentAllowedRoots = getCurrentAllowedRoots();
+        const explicitlyConfiguredArtifactRoots = getExactlyConfiguredArtifactRoots();
+        const sourceAllowedRoots = currentAllowedRoots.filter((root) => !artifactOnlyAllowedRoots.has(root) ||
+            explicitlyConfiguredArtifactRoots.has(root));
+        validateContextBuilderGlobs({
+            include: input.include_globs,
+            exclude: input.exclude_globs,
+        });
+        await rejectArtifactOnlySourceRoots(input.roots, {
+            explicitlyConfiguredArtifactRoots,
+        });
+        const rootResolution = await resolveContextBuilderRoots(input.roots, {
+            allowedRoots: sourceAllowedRoots,
+        });
+        const focusPaths = await resolveContextBuilderFocusPaths(input.focus_paths, rootResolution.roots);
+        assertContextBuilderAnchorSufficiency({
+            focus_paths: focusPaths,
+            include_globs: input.include_globs,
+            search_terms: input.search_terms,
+        });
+        appendArtifactOnlyRootToEnv(runsDir);
+        if (!sourceAllowedRoots.includes(runsDir)) {
+            artifactOnlyAllowedRoots.add(runsDir);
+        }
+        const excludedArtifactRoots = [...artifactOnlyAllowedRoots].filter((root) => !explicitlyConfiguredArtifactRoots.has(root));
+        storage = await createContextBuilderRun({
+            runsDir,
+            runId,
+            createdAt,
+        });
+        await progress?.emit("scanning");
+        const discovery = await discoverContextBuilderCandidates({
+            roots: rootResolution.roots,
+            task: input.task,
+            focus_paths: focusPaths,
+            include_globs: input.include_globs,
+            exclude_globs: input.exclude_globs,
+            search_terms: input.search_terms,
+            budget: input.budget,
+            internal_caps: internalCaps,
+            excluded_real_roots: excludedArtifactRoots,
+            ...(options.signal == null ? {} : { signal: options.signal }),
+        });
+        await progress?.emit("searching");
+        await progress?.emit("selecting");
+        const selection = selectContextBuilderFinalContext({
+            task: input.task,
+            tree: discovery.tree,
+            search: discovery.search,
+            slices: discovery.slices,
+            budget: input.budget,
+        });
+        const effectiveDelegatePacketCaps = resolveEffectiveDelegatePacketCaps(input.profile, options.delegatePacketCaps);
+        const delegateResult = input.delegate.enabled
+            ? await resolveDelegateSelection({
+                input,
+                discovery,
+                deterministicSelection: selection,
+                focusPaths,
+                baselineOmissions: rootResolution.omissions,
+                sourceRoots: rootResolution.roots,
+                registry: options.registry ?? getDefaultAdapterRegistry(),
+                ...(effectiveDelegatePacketCaps == null
+                    ? {}
+                    : { delegatePacketCaps: effectiveDelegatePacketCaps }),
+                ...(progress == null ? {} : { progress }),
+                ...(options.signal == null ? {} : { signal: options.signal }),
+            })
+            : 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,
+        });
+        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 openQuestions = effectiveDelegateResult?.openQuestions ?? [];
+        const omissions = [
+            ...rootResolution.omissions,
+            ...discovery.omissions,
+            ...finalSelection.omissions,
+            ...(effectiveDelegateResult?.omissions ?? []),
+        ];
+        const metrics = buildContextBuilderMetrics({
+            discovery: discovery.metrics,
+            selection: finalSelection.metrics,
+            omissionCount: omissions.length,
+        });
+        const warnings = reconcileContextBuilderWarnings({
+            warnings: rawWarnings,
+            selected: finalSelection.selected,
+            omissions,
+            metrics,
+            delegate: effectiveDelegateResult?.delegate,
+        });
+        const delegateMetadata = effectiveDelegateResult?.delegate == null
+            ? undefined
+            : {
+                ...effectiveDelegateResult.delegate,
+                selected_count: finalSelection.selected.length,
+                warning_count: warnings.length,
+            };
+        const renderInput = {
+            run_id: runId,
+            created_at: createdAt,
+            task: input.task,
+            roots: rootResolution.roots.map((root) => ({
+                root_index: root.root_index,
+                input_path: root.input_path,
+                path: root.path,
+            })),
+            inputs: {
+                effective_profile: input.profile ?? null,
+                roots: input.roots,
+                focus_paths: input.focus_paths,
+                include_globs: input.include_globs,
+                exclude_globs: input.exclude_globs,
+                search_terms: input.search_terms,
+                resolved_budget: input.budget,
+                delegate: input.delegate,
+                ...(input.run_id == null ? {} : { run_id: input.run_id }),
+            },
+            budget: input.budget,
+            internal_caps: internalCaps,
+            tree: finalSelection.tree,
+            search: finalSelection.search,
+            slices: finalSelection.slices,
+            selected_context: finalSelection.selected,
+            omissions,
+            warnings,
+            metrics,
+            open_questions: openQuestions,
+            ...(delegateMetadata == null ? {} : { delegate: delegateMetadata }),
+            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 }),
+        });
+        committed = true;
+        await progress?.emit("complete");
+        return createContextBuilderReceiptTextResponse(receipt);
+    }
+    catch (err) {
+        if (storage != null && !committed && storage.ownerNonce != null) {
+            await cleanupContextBuilderIncompleteRun(storage, storage.ownerNonce).catch(() => { });
+        }
+        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 };
+    }
+    return {
+        warnings,
+        materialFailureReason: `packet QA missing source evidence for task axis: ${materialGaps
+            .map((gap) => `${gap.axis.label} (${gap.candidatePaths.join(", ")})`)
+            .join("; ")}`,
+    };
+}
+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"));
+            },
+        });
+    }
+    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 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"));
+            },
+        });
+    }
+    return axes;
+}
+async function rejectArtifactOnlySourceRoots(inputRoots, input) {
+    if (artifactOnlyAllowedRoots.size === 0) {
+        return;
+    }
+    const cwd = path.resolve(process.cwd());
+    for (const inputRoot of inputRoots) {
+        const lexicalRoot = path.resolve(cwd, inputRoot);
+        const resolvedRoot = await fsRealpath(lexicalRoot).catch(() => undefined);
+        if (resolvedRoot == null) {
+            continue;
+        }
+        for (const artifactRoot of artifactOnlyAllowedRoots) {
+            if (input.explicitlyConfiguredArtifactRoots.has(artifactRoot) ||
+                !isSamePathOrDescendant(resolvedRoot, artifactRoot)) {
+                continue;
+            }
+            throw new InvalidParamsError(`context_builder root is outside allowed roots: ${inputRoot}`);
+        }
+    }
+}
+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)) {
+                continue;
+            }
+            const resolvedEntry = realpathSyncOrUndefined(path.resolve(cwd, rawEntry));
+            if (resolvedEntry === artifactRoot) {
+                configured.add(artifactRoot);
+                break;
+            }
+        }
+    }
+    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;
+    }
+}
+function rawAllowedRootEntries() {
+    const raw = process.env["CLINKX_ALLOWED_ROOTS"];
+    if (raw == null || raw.trim() === "") {
+        return [];
+    }
+    return raw
+        .split(",")
+        .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);
+    }
+    catch {
+        return undefined;
+    }
+}
+function getDefaultContextBuilderSemaphore() {
+    const limit = getContextBuilderMaxConcurrent();
+    if (defaultSemaphore == null ||
+        defaultSemaphore.limit !== limit) {
+        defaultSemaphore = new ContextBuilderSemaphore(limit);
+    }
+    return defaultSemaphore;
+}
+function getDefaultAdapterRegistry() {
+    if (defaultAdapterRegistry == null) {
+        defaultAdapterRegistry = RuntimeAdapterRegistry.load();
+    }
+    return defaultAdapterRegistry;
+}
+function resolveEffectiveDelegatePacketCaps(profile, explicitCaps) {
+    const profileCaps = profile == null
+        ? undefined
+        : CONTEXT_BUILDER_DELEGATE_PACKET_CAP_PROFILE_DEFAULTS[profile];
+    if (profileCaps == null && explicitCaps == null) {
+        return undefined;
+    }
+    return {
+        ...(profileCaps ?? {}),
+        ...(explicitCaps ?? {}),
+    };
+}
+function contextBuilderFinalizerEnabled(input) {
+    if (!input.delegate.enabled) {
+        return false;
+    }
+    const explicit = input.delegate.finalizer.enabled;
+    if (explicit != null) {
+        return explicit;
+    }
+    if (input.profile != null) {
+        return CONTEXT_BUILDER_INTENT_PROFILE_DEFAULTS[input.profile]
+            .finalizer_enabled;
+    }
+    return true;
+}
+function delegateFinalizerReceiptMetadata(finalizer) {
+    return {
+        cli_name: finalizer.cli_name,
+        role: finalizer.role,
+        min_score: finalizer.min_score,
+    };
+}
+async function resolveDelegateSelection(input) {
+    const delegate = input.input.delegate;
+    if (!delegate.enabled) {
+        throw new ExecutionError("context_builder delegate orchestration requires enabled delegate config");
+    }
+    const finalizerEnabled = contextBuilderFinalizerEnabled(input.input);
+    const delegatePacketInput = {
+        task: input.input.task,
+        discovery: {
+            tree: input.discovery.tree,
+            content_candidates: input.discovery.content_candidates,
+            search: input.discovery.search,
+            slices: input.discovery.slices,
+            omissions: [...input.baselineOmissions, ...input.discovery.omissions],
+            metrics: input.discovery.metrics,
+        },
+        selection: input.deterministicSelection,
+        budget: input.input.budget,
+        focus_paths: input.focusPaths,
+        ...(input.delegatePacketCaps == null
+            ? {}
+            : { caps: input.delegatePacketCaps }),
+    };
+    const candidateFallbackCount = input.deterministicSelection.selected.length;
+    const requestedFocusOmissions = input.discovery.omissions.filter(isRequestedEvidenceOmission);
+    if (requestedFocusOmissions.length > 0) {
+        return handleDelegateRuntimeFailure({
+            delegate,
+            reason: `requested local evidence omitted: ${requestedFocusOmissions
+                .map(formatOmissionForDelegateFailure)
+                .join("; ")}`,
+            deterministicSelection: input.deterministicSelection,
+            omissionCount: input.baselineOmissions.length +
+                input.discovery.omissions.length +
+                input.deterministicSelection.omissions.length,
+            candidateFallbackCount,
+        });
+    }
+    await input.progress?.emit("curating");
+    const curatorPacket = buildContextBuilderCuratorPacket(delegatePacketInput);
+    const curatorPacketRequestedOmissions = curatorPacket.omissions.filter(isRequestedEvidenceOmission);
+    if (curatorPacketRequestedOmissions.length > 0) {
+        return handleDelegateRuntimeFailure({
+            delegate,
+            reason: `requested local evidence omitted: ${curatorPacketRequestedOmissions
+                .map(formatOmissionForDelegateFailure)
+                .join("; ")}`,
+            deterministicSelection: input.deterministicSelection,
+            omissions: curatorPacketRequestedOmissions,
+            omissionCount: input.baselineOmissions.length +
+                input.discovery.omissions.length +
+                input.deterministicSelection.omissions.length +
+                curatorPacketRequestedOmissions.length,
+            candidateFallbackCount,
+        });
+    }
+    if (curatorPacket.candidates.length === 0) {
+        return handleDelegateRuntimeFailure({
+            delegate,
+            reason: `curator packet contained no selectable candidates; ${delegatePromptDiagnostic(curatorPacket)}`,
+            deterministicSelection: input.deterministicSelection,
+            omissionCount: input.baselineOmissions.length +
+                input.discovery.omissions.length +
+                input.deterministicSelection.omissions.length,
+            candidateFallbackCount,
+        });
+    }
+    const curatorCall = await runContextBuilderDelegateCall({
+        prompt: renderDelegatePrompt("curator", curatorPacket),
+        provider: delegate.curator,
+        registry: input.registry,
+        timeout_seconds: delegate.timeout_seconds,
+        max_response_chars: delegate.max_response_chars,
+        ...(input.signal == null ? {} : { signal: input.signal }),
+    });
+    if (!curatorCall.ok) {
+        return handleDelegateRuntimeFailure({
+            delegate,
+            reason: failureReasonFromCall("curator", curatorCall),
+            deterministicSelection: input.deterministicSelection,
+            omissionCount: input.baselineOmissions.length +
+                input.discovery.omissions.length +
+                input.deterministicSelection.omissions.length,
+            candidateFallbackCount,
+        });
+    }
+    let curatorProposal;
+    let curatorSelection;
+    try {
+        const validatedCuratorProposal = validateContextBuilderCuratorOutput(curatorCall.json, {
+            candidates: curatorPacket.candidates,
+            budget: input.input.budget,
+        });
+        curatorProposal = augmentCuratorProposalWithDeterministicBaseline(validatedCuratorProposal, curatorPacket, input.input.budget.max_files);
+        curatorSelection = reconstructContextBuilderDelegateSelection({
+            selected: curatorProposal.selected,
+            candidates: curatorPacket.candidates,
+            slices: input.discovery.slices,
+            tree: input.discovery.tree,
+            search: input.discovery.search,
+            budget: input.input.budget,
+        });
+        if (curatorSelection.omissions.length > 0 &&
+            curatorProposal !== validatedCuratorProposal) {
+            const rawCuratorSelection = reconstructContextBuilderDelegateSelection({
+                selected: validatedCuratorProposal.selected,
+                candidates: curatorPacket.candidates,
+                slices: input.discovery.slices,
+                tree: input.discovery.tree,
+                search: input.discovery.search,
+                budget: input.input.budget,
+            });
+            if (rawCuratorSelection.selected.length > 0 &&
+                rawCuratorSelection.omissions.length === 0) {
+                curatorProposal = {
+                    ...validatedCuratorProposal,
+                    warnings: [
+                        ...validatedCuratorProposal.warnings,
+                        "server-retained deterministic baseline exceeded local reconstruction budget; using curator-selected evidence only",
+                    ],
+                };
+                curatorSelection = rawCuratorSelection;
+            }
+        }
+        if (curatorSelection.selected.length > 0 &&
+            curatorSelection.omissions.length > 0) {
+            curatorProposal = pruneDelegateProposalToLocalSelection(curatorProposal, curatorPacket.candidates, curatorSelection, "curator selection exceeded local reconstruction budget; using budget-pruned selected evidence only");
+        }
+    }
+    catch (err) {
+        if (err instanceof CancellationError) {
+            throw err;
+        }
+        return handleDelegateRuntimeFailure({
+            delegate,
+            reason: failureReasonFromError("curator_validation", err, delegatePromptDiagnostic(curatorPacket)),
+            deterministicSelection: input.deterministicSelection,
+            omissionCount: input.baselineOmissions.length +
+                input.discovery.omissions.length +
+                input.deterministicSelection.omissions.length,
+            candidateFallbackCount,
+        });
+    }
+    if (curatorSelection.selected.length === 0) {
+        return handleDelegateRuntimeFailure({
+            delegate,
+            reason: "curator produced empty local selection",
+            deterministicSelection: input.deterministicSelection,
+            omissionCount: input.baselineOmissions.length +
+                input.discovery.omissions.length +
+                input.deterministicSelection.omissions.length,
+            candidateFallbackCount,
+        });
+    }
+    if (!finalizerEnabled) {
+        const repairedSelection = repairDelegateSelectionForTask({
+            curatorSelection,
+            deterministicSelection: input.deterministicSelection,
+            contentCandidates: input.discovery.content_candidates,
+            focusPaths: input.focusPaths,
+            budget: input.input.budget,
+            task: input.input.task,
+            sourceRoots: input.sourceRoots,
+        });
+        const warnings = curatorProposal.warnings.map((message) => delegateWarning("delegate_curator_warning", message));
+        appendDelegateRepairWarnings(warnings, repairedSelection);
+        const openQuestions = curatorProposal.open_questions.map(sanitizeDiagnosticText);
+        const omissionCount = input.baselineOmissions.length +
+            input.discovery.omissions.length +
+            repairedSelection.selection.omissions.length;
+        return {
+            selection: repairedSelection.selection,
+            warnings,
+            omissions: [],
+            openQuestions,
+            delegate: {
+                enabled: true,
+                status: "succeeded",
+                failure_policy: delegate.failure_policy,
+                fallback_used: false,
+                curator: { ...delegate.curator },
+                finalizer: delegateFinalizerReceiptMetadata(delegate.finalizer),
+                selected_count: repairedSelection.selection.selected.length,
+                warning_count: warnings.length,
+                omission_count: omissionCount,
+            },
+        };
+    }
+    await input.progress?.emit("finalizing");
+    const finalizerPacket = buildContextBuilderFinalizerPacket({
+        ...delegatePacketInput,
+        selection: curatorSelection,
+        curator_proposal: curatorProposal,
+    });
+    const finalizerPacketRequestedOmissions = finalizerPacket.omissions.filter(isRequestedEvidenceOmission);
+    if (finalizerPacketRequestedOmissions.length > 0) {
+        return handleDelegateRuntimeFailure({
+            delegate,
+            reason: `requested local evidence omitted: ${finalizerPacketRequestedOmissions
+                .map(formatOmissionForDelegateFailure)
+                .join("; ")}`,
+            deterministicSelection: input.deterministicSelection,
+            omissions: finalizerPacketRequestedOmissions,
+            omissionCount: input.baselineOmissions.length +
+                input.discovery.omissions.length +
+                input.deterministicSelection.omissions.length +
+                finalizerPacketRequestedOmissions.length,
+            candidateFallbackCount,
+        });
+    }
+    if ((finalizerPacket.curator_proposal?.selected.length ?? 0) === 0) {
+        return handleDelegateRuntimeFailure({
+            delegate,
+            reason: `finalizer packet lost curator proposal selection; ${delegatePromptDiagnostic(finalizerPacket)}`,
+            deterministicSelection: input.deterministicSelection,
+            omissionCount: input.baselineOmissions.length +
+                input.discovery.omissions.length +
+                input.deterministicSelection.omissions.length,
+            candidateFallbackCount,
+        });
+    }
+    const finalizerCall = await runContextBuilderDelegateCall({
+        prompt: renderDelegatePrompt("finalizer", finalizerPacket),
+        provider: delegate.finalizer,
+        registry: input.registry,
+        timeout_seconds: delegate.timeout_seconds,
+        max_response_chars: delegate.max_response_chars,
+        ...(input.signal == null ? {} : { signal: input.signal }),
+    });
+    if (!finalizerCall.ok) {
+        return handleDelegateRuntimeFailure({
+            delegate,
+            reason: failureReasonFromCall("finalizer", finalizerCall),
+            deterministicSelection: input.deterministicSelection,
+            omissionCount: input.baselineOmissions.length +
+                input.discovery.omissions.length +
+                input.deterministicSelection.omissions.length,
+            candidateFallbackCount,
+        });
+    }
+    try {
+        const finalizerProposal = validateContextBuilderFinalizerOutput(finalizerCall.json, {
+            candidates: finalizerPacket.candidates,
+            budget: input.input.budget,
+            minScore: delegate.finalizer.min_score,
+        });
+        if (finalizerProposal.omissions.length > 0) {
+            return handleDelegateRuntimeFailure({
+                delegate,
+                reason: `finalizer reported omissions: ${finalizerProposal.omissions.join("; ")}`,
+                deterministicSelection: input.deterministicSelection,
+                omissionCount: input.baselineOmissions.length +
+                    input.discovery.omissions.length +
+                    input.deterministicSelection.omissions.length +
+                    finalizerProposal.omissions.length,
+                candidateFallbackCount,
+            });
+        }
+        const foldedFinalizerSelection = foldRequiredFocusEvidenceIntoSelection(finalizerProposal.selected, requiredFocusEvidenceSelections({
+            focusPaths: input.focusPaths,
+            candidates: finalizerPacket.candidates,
+        }));
+        const finalSelection = reconstructContextBuilderDelegateSelection({
+            selected: foldedFinalizerSelection.selected,
+            candidates: finalizerPacket.candidates,
+            slices: input.discovery.slices,
+            tree: input.discovery.tree,
+            search: input.discovery.search,
+            budget: input.input.budget,
+        });
+        if (finalSelection.selected.length === 0) {
+            return handleDelegateRuntimeFailure({
+                delegate,
+                reason: "finalizer produced empty local selection",
+                deterministicSelection: input.deterministicSelection,
+                omissionCount: input.baselineOmissions.length +
+                    input.discovery.omissions.length +
+                    input.deterministicSelection.omissions.length,
+                candidateFallbackCount,
+            });
+        }
+        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,
+            });
+        }
+        const completenessFailure = delegateCompletenessFailure({
+            focusPaths: input.focusPaths,
+            candidates: finalizerPacket.candidates,
+            finalizerSelected: foldedFinalizerSelection.selected,
+            curatorWarnings: curatorProposal.warnings,
+            finalizerWarnings: finalizerProposal.warnings,
+        });
+        if (completenessFailure != null) {
+            return handleDelegateRuntimeFailure({
+                delegate,
+                reason: completenessFailure,
+                deterministicSelection: input.deterministicSelection,
+                omissionCount: input.baselineOmissions.length +
+                    input.discovery.omissions.length +
+                    input.deterministicSelection.omissions.length,
+                candidateFallbackCount,
+            });
+        }
+        const repairedSelection = repairDelegateSelectionForTask({
+            curatorSelection: finalSelection,
+            deterministicSelection: input.deterministicSelection,
+            contentCandidates: input.discovery.content_candidates,
+            focusPaths: input.focusPaths,
+            budget: input.input.budget,
+            task: input.input.task,
+            sourceRoots: input.sourceRoots,
+        });
+        const warnings = [
+            ...curatorProposal.warnings.map((message) => delegateWarning("delegate_curator_warning", message)),
+            ...finalizerProposal.warnings.map((message) => delegateWarning("delegate_finalizer_warning", message)),
+        ];
+        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(", ")}`));
+        }
+        appendDelegateRepairWarnings(warnings, repairedSelection);
+        const openQuestions = curatorProposal.open_questions.map(sanitizeDiagnosticText);
+        const omissionCount = input.baselineOmissions.length +
+            input.discovery.omissions.length +
+            repairedSelection.selection.omissions.length;
+        return {
+            selection: repairedSelection.selection,
+            warnings,
+            omissions: [],
+            openQuestions,
+            delegate: {
+                enabled: true,
+                status: "succeeded",
+                failure_policy: delegate.failure_policy,
+                fallback_used: false,
+                curator: { ...delegate.curator },
+                finalizer: delegateFinalizerReceiptMetadata(delegate.finalizer),
+                finalizer_score: finalizerProposal.score,
+                selected_count: repairedSelection.selection.selected.length,
+                warning_count: warnings.length,
+                omission_count: omissionCount,
+            },
+        };
+    }
+    catch (err) {
+        if (err instanceof CancellationError) {
+            throw err;
+        }
+        if (err instanceof ExecutionError) {
+            throw err;
+        }
+        return handleDelegateRuntimeFailure({
+            delegate,
+            reason: failureReasonFromError("finalizer_validation", err, delegatePromptDiagnostic(finalizerPacket)),
+            deterministicSelection: input.deterministicSelection,
+            omissionCount: input.baselineOmissions.length +
+                input.discovery.omissions.length +
+                input.deterministicSelection.omissions.length,
+            candidateFallbackCount,
+        });
+    }
+}
+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;
+    }
+    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);
+    return {
+        ...prunedSelection,
+        search,
+        slices,
+        ...(selection.summary == null ? {} : { summary: { files: summaryFiles } }),
+    };
+}
+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;
+    }
+    if (normalized.endsWith("/tests/services/streaming/test_context_usage_payloads.py") &&
+        !/\bcontext\s+usage|usage\s+payloads?\b/.test(normalizedTask)) {
+        return true;
+    }
+    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) {
+    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)) {
+            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)) {
+            return file;
+        }
+        const candidate = candidatesByKey.get(key);
+        if (candidate == null) {
+            return file;
+        }
+        const fullFile = selectedFileFromCandidate(candidate);
+        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,
+        };
+        if (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, expandedCount };
+    }
+    return {
+        expandedCount,
+        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 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 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 (!isRetainableClosureFile(file, task) &&
+            !isContextBuilderTaskClosureAnchor(file.path, task) &&
+            !isTaskCriticalDiscoveredClosure(file.path, task)) {
+            return file;
+        }
+        const candidate = candidatesByKey.get(selectedFileKey(file));
+        if (candidate == null || fileCoversCandidate(file, candidate)) {
+            return file;
+        }
+        if (candidate.byte_length > retainableClosureByteLimit(candidate.path, task)) {
+            return file;
+        }
+        const fullFile = selectedFileFromCandidate(candidate);
+        const totalsWithoutFile = {
+            totalBytes: totalBytes - file.bytes,
+            totalTokens: totalTokens - file.estimated_tokens,
+        };
+        if (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, expandedCount };
+    }
+    return {
+        expandedCount,
+        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 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));
+    });
+    const droppedCount = selection.selected.length - selected.length;
+    if (droppedCount === 0) {
+        return { selection, droppedCount };
+    }
+    return {
+        droppedCount,
+        selection: selectionWithSelectedFiles(selection, selected),
+    };
+}
+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);
+    return {
+        ...selection,
+        selected,
+        metrics: {
+            files_selected: selected.length,
+            files_omitted: selection.metrics.files_omitted,
+            bytes_selected: bytes,
+            estimated_tokens: tokens,
+            truncated: selection.metrics.truncated,
+        },
+    };
+}
+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 {
+        root_index: candidate.root_index,
+        path: candidate.path,
+        ranges: [{ start_line: 1, end_line: Math.max(1, candidate.line_count) }],
+        content: candidate.content,
+        bytes,
+        estimated_tokens: estimateContextBuilderTokensFromUtf8Bytes(bytes),
+        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);
+    if (input.delegate.failure_policy === "fail") {
+        throw new ExecutionError(`context_builder delegate failed: ${failureReason}`);
+    }
+    const warnings = [
+        delegateWarning("delegate_fallback", `Delegate curation failed; deterministic selection was used. ${failureReason}`),
+    ];
+    return {
+        selection: input.deterministicSelection,
+        warnings,
+        omissions: [...(input.omissions ?? [])],
+        openQuestions: [],
+        delegate: {
+            enabled: true,
+            status: "partial",
+            failure_policy: input.delegate.failure_policy,
+            fallback_used: true,
+            curator: { ...input.delegate.curator },
+            finalizer: delegateFinalizerReceiptMetadata(input.delegate.finalizer),
+            selected_count: input.candidateFallbackCount,
+            warning_count: warnings.length,
+            omission_count: input.omissionCount,
+            failure_reason: failureReason,
+        },
+    };
+}
+function formatOmissionForDelegateFailure(omission) {
+    const paths = omission.paths == null || omission.paths.length === 0
+        ? "unknown focused path"
+        : boundContextBuilderPathList(omission.paths).join(", ");
+    return `${omission.reason} (${paths}): ${sanitizeDiagnosticText(omission.message)}`;
+}
+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)) {
+        if (range.end_line < nextLine) {
+            continue;
+        }
+        if (range.start_line > nextLine) {
+            return false;
+        }
+        nextLine = Math.max(nextLine, range.end_line + 1);
+        if (nextLine > target.end_line) {
+            return true;
+        }
+    }
+    return false;
+}
+function pruneDelegateProposalToLocalSelection(proposal, candidates, selection, warning) {
+    const candidatesByPath = new Map();
+    for (const candidate of candidates) {
+        candidatesByPath.set(`${candidate.root_index}:${candidate.path}`, candidate);
+    }
+    const selected = selection.selected.flatMap((file) => {
+        const candidate = candidatesByPath.get(`${file.root_index}:${file.path}`);
+        if (candidate == null) {
+            return [];
+        }
+        const original = proposal.selected.find((item) => item.candidate_id === candidate.id);
+        return [
+            {
+                candidate_id: candidate.id,
+                ranges: file.ranges.map((range) => ({
+                    start_line: range.start_line,
+                    end_line: range.end_line,
+                    reason: "budget-pruned local selection range",
+                })),
+                reason: original?.reason ??
+                    "retained because it fit the local reconstruction budget",
+            },
+        ];
+    });
+    return {
+        ...proposal,
+        selected,
+        warnings: proposal.warnings.includes(warning)
+            ? proposal.warnings
+            : [...proposal.warnings, warning],
+    };
+}
+function delegateCompletenessFailure(input) {
+    const materialWarnings = [
+        ...input.curatorWarnings,
+        ...input.finalizerWarnings,
+    ].filter((warning) => isMaterialDelegateEvidenceWarning(warning) &&
+        !warningReferencesSelectedDelegateCandidate({
+            warning,
+            candidates: input.candidates,
+            selected: input.finalizerSelected,
+        }));
+    if (materialWarnings.length > 0) {
+        return `delegate warnings reported material evidence gaps: ${materialWarnings.join("; ")}`;
+    }
+    const required = requiredFocusEvidenceSelections(input);
+    if (required.length === 0) {
+        return undefined;
+    }
+    const selectedByCandidate = new Map();
+    for (const selection of input.finalizerSelected) {
+        selectedByCandidate.set(selection.candidate_id, [
+            ...(selectedByCandidate.get(selection.candidate_id) ?? []),
+            ...selection.ranges,
+        ]);
+    }
+    const missing = required.filter((selection) => {
+        const selectedRanges = selectedByCandidate.get(selection.candidate_id) ?? [];
+        return selection.ranges.some((range) => !rangeCoveredByRanges(range, selectedRanges));
+    });
+    if (missing.length === 0) {
+        return undefined;
+    }
+    return `delegate finalizer omitted requested local evidence: ${missing
+        .map((selection) => `${selection.path}#${selection.ranges
+        .map((range) => `${range.start_line}-${range.end_line}`)
+        .join(",")}`)
+        .join("; ")}`;
+}
+function warningReferencesSelectedDelegateCandidate(input) {
+    const selectedCandidateIds = new Set(input.selected.map((selection) => selection.candidate_id));
+    const selectedFiles = input.candidates
+        .filter((candidate) => selectedCandidateIds.has(candidate.id))
+        .map((candidate) => ({
+        root_index: candidate.root_index,
+        path: candidate.path,
+        ranges: candidate.ranges.map((range) => ({
+            start_line: range.start_line,
+            end_line: range.end_line,
+        })),
+        content: "",
+        bytes: candidate.size_bytes,
+        estimated_tokens: candidate.estimated_tokens,
+        source: candidate.discovery_reason === "focus_path" ? "focus" : "search",
+    }));
+    return isStaleSelectedContextOmissionWarning(input.warning.toLowerCase(), selectedFiles);
+}
+function requiredFocusEvidenceSelections(input) {
+    if (input.focusPaths.length === 0) {
+        return [];
+    }
+    return input.candidates
+        .filter((candidate) => candidate.focus_requested === true &&
+        (candidate.required_focus_ranges?.length ?? 0) > 0 &&
+        candidateMatchesFocusPath(candidate, input.focusPaths))
+        .map((candidate) => ({
+        candidate_id: candidate.id,
+        path: candidate.path,
+        ranges: candidate.required_focus_ranges.map((range) => ({
+            start_line: range.start_line,
+            end_line: range.end_line,
+        })),
+    }));
+}
+function foldRequiredFocusEvidenceIntoSelection(finalizerSelected, requiredFocus) {
+    if (requiredFocus.length === 0) {
+        return { selected: [...finalizerSelected], foldedPaths: [] };
+    }
+    const selectedByCandidate = new Map();
+    for (const selection of finalizerSelected) {
+        selectedByCandidate.set(selection.candidate_id, {
+            candidate_id: selection.candidate_id,
+            reason: selection.reason,
+            ranges: selection.ranges.map((range) => ({ ...range })),
+        });
+    }
+    const foldedPaths = [];
+    for (const required of requiredFocus) {
+        const existing = selectedByCandidate.get(required.candidate_id);
+        const existingRanges = existing?.ranges ?? [];
+        const hasUncoveredRange = required.ranges.some((range) => !rangeCoveredByRanges(range, existingRanges));
+        if (!hasUncoveredRange) {
+            continue;
+        }
+        foldedPaths.push(required.path);
+        const ranges = mergeLineRanges([
+            ...existingRanges.map((range) => ({
+                start_line: range.start_line,
+                end_line: range.end_line,
+            })),
+            ...required.ranges,
+        ]).map((range) => ({
+            start_line: range.start_line,
+            end_line: range.end_line,
+            reason: "server-folded requested local evidence omitted by finalizer",
+        }));
+        selectedByCandidate.set(required.candidate_id, {
+            candidate_id: required.candidate_id,
+            reason: existing?.reason ?? "requested local focus evidence preserved by server",
+            ranges,
+        });
+    }
+    return { selected: [...selectedByCandidate.values()], foldedPaths };
+}
+function candidateMatchesFocusPath(candidate, focusPaths) {
+    return focusPaths.some((focus) => {
+        if (focus.root_index !== candidate.root_index) {
+            return false;
+        }
+        if (focus.kind === "file") {
+            return candidate.path === focus.root_relative_path;
+        }
+        return isSameRootRelativePathOrDescendant(candidate.path, focus.root_relative_path);
+    });
+}
+function isSameRootRelativePathOrDescendant(candidatePath, parentPath) {
+    if (parentPath === "") {
+        return true;
+    }
+    return candidatePath === parentPath || candidatePath.startsWith(`${parentPath}/`);
+}
+function isMaterialDelegateEvidenceWarning(message) {
+    const text = message.toLowerCase();
+    if (isNonBlockingDelegateWarning(text)) {
+        return false;
+    }
+    return (/\b(required|requested|focus(?:ed)?)\b.{0,80}\b(missing|missed|incomplete|unavailable|insufficient|omitted|not selected|not selectable|unselectable|not present)\b/.test(text) ||
+        /\b(missing|missed|incomplete|unavailable|insufficient|omitted|not selected|not selectable|unselectable|not present)\b.{0,80}\b(required|requested|focus(?:ed)?)\b/.test(text) ||
+        /\bselected\b.{0,80}\b(not selectable|unselectable|not present)\b/.test(text) ||
+        /\boutside (?:the )?selected ranges?\b/.test(text));
+}
+function isNonBlockingDelegateWarning(text) {
+    return (/\bpacket evidence omitted full source excerpts\b/.test(text) ||
+        /\bfull source excerpts? (?:were )?omitted\b/.test(text) ||
+        /\bfull-file focus ranges?\b.{0,120}\b(?:excerpts?|full source)\b.{0,80}\b(?:omitted|truncated)\b/.test(text) ||
+        /\bfull source excerpts?\b.{0,80}\bunavailable\b.{0,120}\bwhole-file focus ranges?\b/.test(text) ||
+        isSecretSafetyOmissionWarning(text) ||
+        /\bomitted from deterministic_selection\b.{0,120}\bbut selected\b/.test(text) ||
+        isSpeculativeIrrelevantOmissionWarning(text) ||
+        isFocusPreservingSkipWarning(text) ||
+        isDeterministicExpansionWarning(text));
+}
+function isSecretSafetyOmissionWarning(text) {
+    return (/\b(?:high-confidence secret|secret detection|secret safety|secret[- ]safe|redacted|redacted-safe|redaction)\b/.test(text) &&
+        /\b(?:omitted|excluded|not selected|not requested|should not be requested|unavailable)\b/.test(text));
+}
+function isFocusPreservingSkipWarning(text) {
+    return (/\b(?:unrelated|irrelevant|out-of-scope|low[- ]signal)\b.{0,120}\b(?:not selected|omitted|skipped)\b.{0,80}\bpreserve focus\b/.test(text) ||
+        /\b(?:not selected|omitted|skipped)\b.{0,120}\b(?:unrelated|irrelevant|out-of-scope|low[- ]signal)\b.{0,80}\bpreserve focus\b/.test(text));
+}
+function isSpeculativeIrrelevantOmissionWarning(text) {
+    if (!/\b(?:may|might|could)\b.{0,80}\b(?:omit|omits|omitted|missing)\b/.test(text)) {
+        return false;
+    }
+    if (/\b(required|requested)\b/.test(text)) {
+        return false;
+    }
+    return /\b(additional|broader|other|unrelated|irrelevant|repository|out-of-packet|outside (?:this|the) bounded packet)\b/.test(text);
+}
+function isDeterministicExpansionWarning(text) {
+    return (/\bselection\b.{0,80}\b(?:intentionally\s+)?(?:exceeds|exceeded|expands beyond|expanded beyond|extends beyond|extended beyond)\b.{0,120}\bdeterministic\b.{0,160}\binsufficient\b/.test(text) &&
+        !/\b(missing|missed|omitted|not selected|not selectable|unselectable|not present|unavailable)\b/.test(text));
+}
+function augmentCuratorProposalWithDeterministicBaseline(proposal, packet, maxSelections) {
+    const deterministicSelected = packet.deterministic_selection?.selected ?? [];
+    if (deterministicSelected.length === 0 ||
+        proposal.selected.length >= maxSelections) {
+        return proposal;
+    }
+    const selectedByCandidate = new Map();
+    for (const selection of proposal.selected) {
+        selectedByCandidate.set(selection.candidate_id, {
+            candidate_id: selection.candidate_id,
+            ranges: [...selection.ranges],
+            reason: selection.reason,
+        });
+    }
+    let added = 0;
+    for (const selection of deterministicSelected) {
+        const existing = selectedByCandidate.get(selection.candidate_id);
+        if (existing == null) {
+            if (selectedByCandidate.size >= maxSelections) {
+                break;
+            }
+            selectedByCandidate.set(selection.candidate_id, {
+                candidate_id: selection.candidate_id,
+                ranges: selection.ranges.map((range) => ({
+                    start_line: range.start_line,
+                    end_line: range.end_line,
+                    reason: "deterministic baseline retained because curator underselected local evidence",
+                })),
+                reason: "server-retained deterministic baseline candidate for finalizer review",
+            });
+            added += 1;
+            continue;
+        }
+        const deterministicRanges = selection.ranges.map((range) => ({
+            start_line: range.start_line,
+            end_line: range.end_line,
+            reason: "deterministic baseline range retained because curator expanded local evidence",
+        }));
+        if (totalSelectedRangeLines(deterministicRanges) < totalSelectedRangeLines(existing.ranges)) {
+            existing.ranges = deterministicRanges;
+            added += 1;
+        }
+    }
+    if (added === 0) {
+        return proposal;
+    }
+    return {
+        selected: [...selectedByCandidate.values()],
+        warnings: [
+            ...proposal.warnings,
+            `curator selected fewer local candidates than the deterministic baseline; retained ${added} deterministic baseline candidate/range item(s) for finalizer review`,
+        ],
+        open_questions: proposal.open_questions,
+    };
+}
+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) {
+    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":[]}';
+    const stageRules = stage === "curator"
+        ? [
+            "Curator-specific rules:",
+            "- The packet is the complete local evidence. Do not run commands, read files, discover paths, or use filesystem state.",
+            "- selected:[] is invalid when packet.candidates is non-empty. It will fail server validation.",
+            "- If packet.candidates is non-empty, selected MUST contain at least one candidate.",
+            "- 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.",
+        ]
+        : [
+            "Finalizer-specific rules:",
+            "- The packet is the complete local evidence. Do not run commands, read files, discover paths, or use filesystem state.",
+            "- selected:[] is invalid when approving. It will fail server validation.",
+            "- If approving, selected MUST contain at least one candidate.",
+            "- Start from packet.curator_proposal.selected and keep only candidates that are locally supported by packet.candidates.",
+            "- 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.",
+        ];
+    const minimumOutput = buildMinimumDelegateOutput(stage, packet);
+    return [
+        `You are the context_builder ${stage}.`,
+        `Prompt version: ${CONTEXT_BUILDER_DELEGATE_PROMPT_VERSION}.`,
+        "Return exactly one strict JSON object and no prose.",
+        "For this tool call, the JSON packet below is the only source of truth.",
+        stage === "curator"
+            ? "Never answer with selected:[]. If candidates exist, choose at least one candidate_id and one eligible range from packet.candidates or packet.deterministic_selection.selected."
+            : "Never answer with selected:[]. If approving, choose at least one candidate_id and one eligible range from packet.curator_proposal.selected.",
+        "Use only candidate_id and ranges from the packet. Do not add paths or source content.",
+        "Every selected range must stay within one of that candidate's packet.ranges entries.",
+        stage === "curator"
+            ? "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,
+        ...(minimumOutput == null
+            ? []
+            : [
+                "If unsure, return this minimum valid JSON object rather than an empty selection:",
+                minimumOutput,
+            ]),
+        `Required JSON shape: ${outputShape}`,
+        "Invalid output example: {\"selected\":[],\"warnings\":[],\"open_questions\":[]}",
+        "",
+        "Packet:",
+        JSON.stringify(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);
+    if (minimumSelections.length === 0) {
+        return null;
+    }
+    const selected = minimumSelections.map((selection) => ({
+        candidate_id: selection.candidate_id,
+        ranges: selection.ranges.map((range) => ({
+            start_line: range.start_line,
+            end_line: range.end_line,
+            reason: "locally supported range from the packet",
+        })),
+        reason: "minimum valid local selection for the requested context",
+    }));
+    const output = stage === "curator"
+        ? {
+            selected,
+            warnings: [
+                "minimum deterministic selection used; review packet evidence for more context",
+            ],
+            open_questions: [],
+        }
+        : {
+            score: 10,
+            approved: true,
+            selected,
+            warnings: [
+                "minimum curator proposal selection used; review packet evidence for more context",
+            ],
+            omissions: [],
+        };
+    return JSON.stringify(output);
+}
+function packetMinimumSelections(stage, packet) {
+    if (packet == null || typeof packet !== "object") {
+        return [];
+    }
+    const record = packet;
+    if (stage === "finalizer") {
+        const proposal = record["curator_proposal"];
+        const proposalSelected = proposal != null && typeof proposal === "object"
+            ? proposal["selected"]
+            : undefined;
+        return packetSelectionsFromValues(proposalSelected);
+    }
+    const deterministic = record["deterministic_selection"];
+    const deterministicSelected = deterministic != null && typeof deterministic === "object"
+        ? deterministic["selected"]
+        : undefined;
+    const deterministicSelections = packetSelectionsFromValues(deterministicSelected);
+    const candidateSelections = packetCandidateSelectionsFromValues(record["candidates"]);
+    if (deterministicSelections.length > 0) {
+        return mergePacketSelections([
+            ...deterministicSelections,
+            ...candidateSelections,
+        ]).slice(0, MAX_DELEGATE_MINIMUM_OUTPUT_SELECTIONS);
+    }
+    return candidateSelections;
+}
+function packetSelectionsFromValues(values) {
+    if (!Array.isArray(values)) {
+        return [];
+    }
+    return mergePacketSelections(values
+        .slice(0, MAX_DELEGATE_MINIMUM_OUTPUT_SELECTIONS)
+        .map((value) => packetSelectionFromValue(value, "candidate_id"))
+        .filter((selection) => selection != null));
+}
+function packetCandidateSelectionsFromValues(values) {
+    if (!Array.isArray(values)) {
+        return [];
+    }
+    return mergePacketSelections(values
+        .slice(0, MAX_DELEGATE_MINIMUM_OUTPUT_SELECTIONS)
+        .map((value) => packetSelectionFromValue(value, "id"))
+        .filter((selection) => selection != null));
+}
+function mergePacketSelections(selections) {
+    const merged = new Map();
+    for (const selection of selections) {
+        const ranges = merged.get(selection.candidate_id) ?? [];
+        ranges.push(...selection.ranges);
+        merged.set(selection.candidate_id, ranges);
+    }
+    return [...merged].map(([candidate_id, ranges]) => ({
+        candidate_id,
+        ranges,
+    }));
+}
+function packetSelectionFromValue(value, candidateIdKey) {
+    if (value == null || typeof value !== "object") {
+        return null;
+    }
+    const record = value;
+    const candidateId = record[candidateIdKey];
+    const ranges = record["ranges"];
+    const validRanges = Array.isArray(ranges)
+        ? ranges.map(packetRangeBounds).filter((range) => range != null)
+        : [];
+    return typeof candidateId === "string" && validRanges.length > 0
+        ? { candidate_id: candidateId, ranges: validRanges }
+        : null;
+}
+function packetRangeBounds(value) {
+    if (value == null || typeof value !== "object") {
+        return null;
+    }
+    const record = value;
+    const startLine = record["start_line"];
+    const endLine = record["end_line"];
+    if (typeof startLine !== "number" || typeof endLine !== "number") {
+        return null;
+    }
+    return Number.isInteger(startLine) &&
+        Number.isInteger(endLine) &&
+        startLine > 0 &&
+        endLine >= startLine
+        ? { start_line: startLine, end_line: endLine }
+        : null;
+}
+function delegatePromptDiagnostic(packet) {
+    if (packet == null || typeof packet !== "object") {
+        return `prompt_version=${CONTEXT_BUILDER_DELEGATE_PROMPT_VERSION}; packet=invalid`;
+    }
+    const record = packet;
+    const candidateCount = Array.isArray(record["candidates"])
+        ? record["candidates"].length
+        : 0;
+    const deterministic = record["deterministic_selection"];
+    const deterministicSelected = deterministic != null && typeof deterministic === "object"
+        ? deterministic["selected"]
+        : undefined;
+    const deterministicCount = Array.isArray(deterministicSelected)
+        ? deterministicSelected.length
+        : 0;
+    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);
+    return [
+        `pv=${CONTEXT_BUILDER_DELEGATE_PROMPT_VERSION}`,
+        `candidates=${candidateCount}`,
+        `det=${deterministicCount}`,
+        `curator_selected=${curatorProposalCount}`,
+        `min=${minimumSelection.length > 0}`,
+    ].join("; ");
+}
+function failureReasonFromCall(stage, call) {
+    return `${stage} ${call.reason}: ${call.message}`;
+}
+function failureReasonFromError(stage, err, diagnostic) {
+    const message = err instanceof Error ? err.message : "unknown delegate error";
+    return diagnostic == null
+        ? `${stage}: ${message}`
+        : `${stage}: ${diagnostic}; ${message}`;
+}
+function delegateWarning(code, message) {
+    return {
+        code: sanitizeDiagnosticText(code),
+        message: sanitizeDiagnosticText(message),
+    };
+}
+function reconcileContextBuilderWarnings(input) {
+    if (input.warnings.length === 0) {
+        return [];
+    }
+    return input.warnings.filter((warning) => {
+        const text = warning.message.toLowerCase();
+        if (isStaleTruncationWarning(text, input)) {
+            return false;
+        }
+        if (isStaleSelectedContextOmissionWarning(text, input.selected)) {
+            return false;
+        }
+        if (isStaleSelectedContextRangeWarning(text, input.selected)) {
+            return false;
+        }
+        return true;
+    });
+}
+function isStaleTruncationWarning(text, input) {
+    if (!isTruncationWarning(text)) {
+        return false;
+    }
+    return !contextBuilderPacketIsDegraded(input);
+}
+function contextBuilderPacketIsDegraded(input) {
+    return (input.metrics.truncated ||
+        input.omissions.some(isMaterialWarningOmission) ||
+        input.delegate?.fallback_used === true ||
+        input.delegate?.status === "partial");
+}
+function isMaterialWarningOmission(omission) {
+    if (omission.reason === "excluded" ||
+        omission.reason === "exclude_glob" ||
+        omission.reason === "caller_include_glob" ||
+        omission.reason === "content_secret" ||
+        omission.reason === "secret_path" ||
+        omission.reason === "symlink_omitted" ||
+        omission.reason === "symlink_file" ||
+        omission.reason === "binary_file" ||
+        omission.reason === "duplicate_root" ||
+        omission.reason === "noisy_file" ||
+        omission.reason === "default_exclude" ||
+        omission.reason === "default_noisy_exclude") {
+        return false;
+    }
+    return true;
+}
+function isTruncationWarning(text) {
+    return /\b(?:truncat(?:ed|ion)|token[- ]?truncated|token budget|budget[- ]limited|budget limited)\b/.test(text);
+}
+function isStaleSelectedContextOmissionWarning(text, selected) {
+    if (selected.length === 0 ||
+        !isOmissionWarning(text) ||
+        isPathOrSecretOmissionWarning(text)) {
+        return false;
+    }
+    const references = selectedContextWarningReferences(selected);
+    const groupedRefs = concreteWarningReferenceGroups(text);
+    if (groupedRefs.length > 0) {
+        if (groupedRefs.some((group) => group.every((ref) => references.tokens.has(ref)))) {
+            return true;
+        }
+    }
+    return warningReferencesSelectedContext(text, references);
+}
+function isStaleSelectedContextRangeWarning(text, selected) {
+    if (selected.length === 0 ||
+        !/\b(?:available as|available only|only available|only includes|only selected|partial|range|ranges|slice|slices|line|lines|clipped|narrow)\b/.test(text)) {
+        return false;
+    }
+    return warningReferencesSelectedContext(text, selectedContextWarningReferences(selected));
+}
+function isOmissionWarning(text) {
+    return /\b(?:missing|missed|omission|omissions|omit|omits|omitted|not selected|not be selected|not present|unavailable|insufficient)\b/.test(text);
+}
+function isPathOrSecretOmissionWarning(text) {
+    return /\b(?:secret|sensitive|credential|private key|api key|redacted|allowed roots?|outside allowed|unsafe path|path traversal|symlink|permission denied|eacces|enoent|not readable)\b/.test(text);
+}
+function selectedContextWarningReferences(selected) {
+    const compactTextRefs = new Set();
+    const tokens = new Set();
+    for (const file of selected) {
+        const normalizedPath = normalizeWarningReference(file.path);
+        if (normalizedPath.length > 0) {
+            compactTextRefs.add(normalizedPath);
+        }
+        const basename = file.path.split("/").at(-1) ?? file.path;
+        const basenameRef = normalizeWarningReference(basename);
+        if (basenameRef.length > 0) {
+            compactTextRefs.add(basenameRef);
+        }
+        const stem = basename.split(".")[0] ?? basename;
+        const stemRef = normalizeWarningReference(stem);
+        if (isConcreteWarningReference(stemRef)) {
+            compactTextRefs.add(stemRef);
+            tokens.add(stemRef);
+        }
+    }
+    return { compactTextRefs, tokens };
+}
+function warningReferencesSelectedContext(text, references) {
+    const compactText = normalizeWarningReference(text);
+    for (const ref of references.compactTextRefs) {
+        if (isConcreteWarningReference(ref) && compactText.includes(ref)) {
+            return true;
+        }
+    }
+    return false;
+}
+function concreteWarningReferenceGroups(text) {
+    const groups = [];
+    const groupPatterns = [
+        /\b([a-z0-9_.-]+(?:\/[a-z0-9_.-]+)+)\s+(?:schemas?|tests?|files?)\b/g,
+        /\b([a-z0-9_.-]+)\s+and\s+([a-z0-9_.-]+)\s+(?:schemas?|tests?|files?)\b/g,
+    ];
+    for (const pattern of groupPatterns) {
+        for (const match of text.matchAll(pattern)) {
+            const refs = match
+                .slice(1)
+                .flatMap((value) => value.split("/"))
+                .map(normalizeWarningReference)
+                .filter(isConcreteWarningReference);
+            if (refs.length > 0) {
+                groups.push(refs);
+            }
+        }
+    }
+    return groups;
+}
+function normalizeWarningReference(value) {
+    return value.toLowerCase().replace(/[^a-z0-9]+/g, "");
+}
+function isConcreteWarningReference(value) {
+    if (value.length < 4) {
+        return false;
+    }
+    return !new Set([
+        "backend",
+        "frontend",
+        "schema",
+        "schemas",
+        "service",
+        "services",
+        "source",
+        "test",
+        "tests",
+        "types",
+    ]).has(value);
+}
+function buildContextBuilderMetrics(input) {
+    return {
+        files_seen: input.discovery.files_seen,
+        files_considered: input.discovery.files_considered,
+        files_selected: input.selection.files_selected,
+        files_omitted: input.omissionCount,
+        scan_cap_hit: input.discovery.scan_cap_hit,
+        search_cap_hit: input.discovery.search_cap_hit,
+        discovery_byte_cap_hit: input.discovery.discovery_byte_cap_hit,
+        discovery_candidate_cap_hit: input.discovery.discovery_candidate_cap_hit,
+        candidate_cap_hit: input.discovery.candidate_cap_hit,
+        bytes_read: input.discovery.bytes_read,
+        bytes_written: 0,
+        estimated_tokens: input.selection.estimated_tokens,
+        truncated: input.selection.truncated ||
+            input.discovery.scan_cap_hit ||
+            input.discovery.discovery_byte_cap_hit ||
+            input.discovery.discovery_candidate_cap_hit,
+    };
+}
+//# sourceMappingURL=handler.js.map