clinkx 0.2.3 → 1.0.0

package/dist/context-builder/handler.js

@@ -0,0 +1,2590 @@
+import { appendArtifactOnlyRootsToEnv, isArtifactOnlyAllowedRootEntry, isSamePathOrDescendant, parseAllowedRootsEnv, stripArtifactOnlyMarker, } from "../allowed-roots.js";
+import { CancellationError, ExecutionError, InvalidParamsError, } from "../errors.js";
+import { realpathSync } from "node:fs";
+import { realpath as fsRealpath } from "node:fs/promises";
+import path from "node:path";
+import { AdapterRegistry as RuntimeAdapterRegistry } from "../registry.js";
+import { logger } from "../logger.js";
+import { assertContextBuilderAnchorSufficiency } from "./anchors.js";
+import { writeContextBuilderFinalArtifacts, } from "./bundle.js";
+import { CONTEXT_BUILDER_INTERNAL_CAP_DEFAULTS, getSharedContextBuilderSemaphore, resolveContextBuilderRunsDir, } from "./config.js";
+import { buildContextBuilderCuratorPacket, buildContextBuilderFinalizerPacket, CONTEXT_BUILDER_DELEGATE_PACKET_CAP_PROFILE_DEFAULTS, contextBuilderCandidateId, } from "./delegate-packet.js";
+import { reconstructContextBuilderDelegateSelection } from "./delegate-reconstruction.js";
+import { runContextBuilderDelegateCall, } from "./delegate.js";
+import { validateContextBuilderCuratorOutput, validateContextBuilderDelegateCoverageSelection, validateContextBuilderFinalizerOutput, } from "./delegate-validation.js";
+import { discoverContextBuilderCandidates, mergeLineRanges, } from "./discovery.js";
+import { evaluateSearchCapMateriality } from "./status.js";
+import { boundContextBuilderPathList, isRequestedEvidenceOmission, sanitizeDelegateFailureText, sanitizeDiagnosticText, } from "./diagnostics.js";
+import { compileContextBuilderGlobs, CONTEXT_BUILDER_DEFAULT_EXCLUDE_GLOBS, validateContextBuilderGlobs, } from "./globs.js";
+import { resolveContextBuilderFocusPaths, resolveContextBuilderRoots, } from "./paths.js";
+import { createContextBuilderProgressReporter, } from "./progress.js";
+import { ContextBuilderLifecycleController, ContextBuilderLifecycleObserverError, } from "./lifecycle-observer.js";
+import { createContextBuilderLifecycleJournal } from "./lifecycle-journal.js";
+import { recordContextRunCatalogMarker } from "./context-run-catalog.js";
+import { appendLifecycleCompletionWarning } from "./lifecycle-recovery.js";
+import { withContextBuilderWriteWatchdog } from "./write-watchdog.js";
+import { createContextBuilderReceiptTextResponse, } from "./receipt.js";
+import { generateContextBuilderRunId } from "./run-id.js";
+import { CONTEXT_BUILDER_INTENT_PROFILE_DEFAULTS, parseContextBuilderInput, } from "./schema.js";
+import { evaluateContextCoverage, resolveContextCoveragePolicy, } from "./review-coverage.js";
+import { selectContextBuilderFinalContext, } from "./selection.js";
+import { cleanupContextBuilderIncompleteRun, createContextBuilderRun, } from "./storage.js";
+import { admitJournalContextGeneration } from "./session-log-identity.js";
+import { estimateContextBuilderTokensFromUtf8Bytes } from "./token-estimate.js";
+let defaultAdapterRegistry;
+const artifactOnlyAllowedRoots = new Set();
+const CONTEXT_BUILDER_DELEGATE_PROMPT_VERSION = "cb-delegate-v3-scored-obligations";
+const MAX_DELEGATE_MINIMUM_OUTPUT_SELECTIONS = 24;
+export async function handleContextBuilder(args, options = {}) {
+    const input = parseContextBuilderInput(args);
+    const coveragePolicy = resolveContextCoveragePolicy(input.profile);
+    const semaphore = options.semaphore ?? getDefaultContextBuilderSemaphore();
+    const progress = createContextBuilderProgressReporter(options.progress);
+    const ownsLifecycle = options.lifecycleController == null;
+    semaphore.acquire();
+    let lifecycle;
+    let storage;
+    let committed = false;
+    try {
+        // Resolve and validate the runs dir up front so a broad/forbidden runs_dir
+        // is rejected with its canonical error BEFORE any lifecycle transition, and
+        // so the journal reuses this one already-validated path instead of
+        // re-resolving (a second resolution would wrap that rejection as an opaque
+        // observer failure).
+        const runsDir = await resolveContextBuilderRunsDir(options.runsDir);
+        // A standalone operation that owns its lifecycle (no injected observer)
+        // persists authoritatively through the .context-runs journal; the injected
+        // path — workflow preflight — supplies its own store instead.
+        const journal = ownsLifecycle && options.lifecycle == null
+            ? createContextBuilderLifecycleJournal({
+                runsDir,
+                resolveRunsDir: async () => runsDir,
+            })
+            : undefined;
+        lifecycle = options.lifecycleController ??
+            new ContextBuilderLifecycleController({
+                operationKind: "standalone",
+                execution: lifecycleExecutionConfig(input),
+                ...(options.lifecycle != null
+                    ? {
+                        observer: options.lifecycle.observer,
+                        ...(options.lifecycle.origin == null
+                            ? {}
+                            : { origin: options.lifecycle.origin }),
+                    }
+                    : journal == null
+                        ? {}
+                        : { observer: journal.observe }),
+                ...(progress == null ? {} : { notificationObserver: progress.observe }),
+                ...(options.now == null ? {} : { now: options.now }),
+            });
+        if (ownsLifecycle) {
+            await lifecycle?.transition("resolving");
+        }
+        const createdAt = (options.now?.() ?? new Date()).toISOString();
+        const runId = input.run_id ?? generateContextBuilderRunId();
+        await lifecycle?.transition("validating", {
+            ...(ownsLifecycle ? { artifactRunId: runId } : {}),
+        });
+        const internalCaps = options.internalCaps ?? CONTEXT_BUILDER_INTERNAL_CAP_DEFAULTS;
+        const currentAllowedRoots = parseAllowedRootsEnv({
+            includeArtifactOnly: false,
+        });
+        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,
+            allowRootWideDiscovery: options.allowRootWideDiscovery ?? false,
+        });
+        assertNoContextBuilderFocusGlobConflicts({
+            focusPaths,
+            includeGlobs: input.include_globs,
+            excludeGlobs: input.exclude_globs,
+        });
+        appendArtifactOnlyRootToEnv(runsDir);
+        if (!sourceAllowedRoots.includes(runsDir)) {
+            artifactOnlyAllowedRoots.add(runsDir);
+        }
+        const excludedArtifactRoots = [...artifactOnlyAllowedRoots].filter((root) => !explicitlyConfiguredArtifactRoots.has(root));
+        const writingStorage = await createContextBuilderRun({
+            runsDir,
+            runId,
+            createdAt,
+        });
+        storage = writingStorage;
+        let sessionLogContext;
+        if (journal !== undefined) {
+            try {
+                sessionLogContext = {
+                    contextRunId: lifecycle.contextRunId,
+                    contextGeneration: await admitJournalContextGeneration(runsDir, lifecycle.contextRunId),
+                };
+            }
+            catch {
+                logger.debug({ contextRunId: lifecycle.contextRunId }, "context session-log identity admission failed open");
+            }
+        }
+        else if (options.sessionLogContext !== undefined) {
+            // Workflow preflight path: the runner minted the operation id (via the
+            // controller) and created the run-dir generation sidecar. Use that pair
+            // instead of the journal (which the injected-controller path does not
+            // create). Both flow into the context-family session-log owner emitted for
+            // the curator/finalizer delegate calls.
+            const injected = options.sessionLogContext;
+            sessionLogContext = injected.contextRunId === lifecycle.contextRunId
+                ? injected
+                : { contextRunId: lifecycle.contextRunId, contextGeneration: injected.contextGeneration };
+        }
+        await lifecycle?.transition("scanning");
+        const discovery = await discoverContextBuilderCandidates({
+            roots: rootResolution.roots,
+            task: input.task,
+            allowSecrets: input.allow_secrets,
+            focus_paths: focusPaths,
+            include_globs: input.include_globs,
+            exclude_globs: input.exclude_globs,
+            search_terms: input.search_terms,
+            coverage_policy: coveragePolicy,
+            budget: input.budget,
+            internal_caps: internalCaps,
+            excluded_real_roots: excludedArtifactRoots,
+            ...(options.signal == null ? {} : { signal: options.signal }),
+        });
+        await lifecycle?.transition("searching", {
+            counts: lifecycleCountsFromDiscovery(discovery),
+        });
+        await lifecycle?.transition("selecting");
+        const selection = selectContextBuilderFinalContext({
+            task: input.task,
+            tree: discovery.tree,
+            search: discovery.search,
+            slices: discovery.slices,
+            budget: input.budget,
+            coverage_policy: coveragePolicy,
+            evidence_classes_by_candidate: evidenceClassesByCandidate(discovery.content_candidates),
+            ...(discovery.review_obligations == null
+                ? {}
+                : { review_obligations: discovery.review_obligations }),
+        });
+        const effectiveDelegatePacketCaps = resolveEffectiveDelegatePacketCaps(input.profile, options.delegatePacketCaps);
+        const delegateResult = input.delegate.enabled
+            ? await resolveDelegateSelection({
+                input,
+                discovery,
+                deterministicSelection: selection,
+                focusPaths,
+                baselineOmissions: rootResolution.omissions,
+                sourceRoots: rootResolution.roots,
+                registry: options.registry ?? getDefaultAdapterRegistry(),
+                coveragePolicy,
+                ...(effectiveDelegatePacketCaps == null
+                    ? {}
+                    : { delegatePacketCaps: effectiveDelegatePacketCaps }),
+                ...(lifecycle == null ? {} : { lifecycle }),
+                ...(options.signal == null ? {} : { signal: options.signal }),
+                ...(sessionLogContext == null ? {} : { sessionLogContext }),
+            })
+            : undefined;
+        const effectiveDelegateResult = delegateResult;
+        const finalSelection = effectiveDelegateResult?.selection ?? selection;
+        const coverage = evaluateSelectionCoverage({
+            policy: coveragePolicy,
+            candidates: discovery.content_candidates,
+            selected: finalSelection.selected,
+            ...(discovery.review_obligations == null
+                ? {}
+                : { obligations: discovery.review_obligations }),
+        });
+        const rawWarnings = [...(effectiveDelegateResult?.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 reconciledWarnings = reconcileContextBuilderWarnings({
+            warnings: rawWarnings,
+            selected: finalSelection.selected,
+            omissions,
+            metrics,
+            delegate: effectiveDelegateResult?.delegate,
+        });
+        // A material search cap must be explained in the receipt, not just
+        // classified: the warning carries the bounded coverage summary while the
+        // cap event (built from metrics + search_coverage in the status reducer)
+        // carries the partial classification.
+        const searchCapWarning = searchCapCoverageWarning(metrics.search_cap_hit, discovery.search_coverage);
+        const warnings = searchCapWarning == null
+            ? reconciledWarnings
+            : [...reconciledWarnings, searchCapWarning];
+        const delegateMetadata = effectiveDelegateResult?.delegate == null
+            ? undefined
+            : {
+                ...effectiveDelegateResult.delegate,
+                selected_count: finalSelection.selected.length,
+                warning_count: warnings.length,
+            };
+        const delegatePacketEstimatedTokens = effectiveDelegateResult?.observability.delegate_packet_size ?? 0;
+        const delegatePacketCompaction = effectiveDelegateResult?.observability.delegate_packet_compaction;
+        const observability = {
+            curator_ms: effectiveDelegateResult?.observability.curator_ms ?? null,
+            finalizer_ms: effectiveDelegateResult?.observability.finalizer_ms ?? null,
+            candidate_pool_size: discovery.content_candidates.length,
+            // Deprecated alias (see ContextBuilderObservabilityMetrics): historical
+            // name for the packet ESTIMATED-TOKEN metric. Kept byte-identical for
+            // compatibility; new readers should use delegate_packet_estimated_tokens.
+            delegate_packet_size: delegatePacketEstimatedTokens,
+            delegate_packet_estimated_tokens: delegatePacketEstimatedTokens,
+            ...(delegatePacketCompaction == null
+                ? {}
+                : { delegate_packet_compaction: delegatePacketCompaction }),
+        };
+        const renderInput = {
+            run_id: runId,
+            created_at: createdAt,
+            task: input.task,
+            allowSecrets: input.allow_secrets,
+            roots: rootResolution.roots.map((root) => ({
+                root_index: root.root_index,
+                input_path: root.input_path,
+                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,
+            search_coverage: discovery.search_coverage,
+            open_questions: openQuestions,
+            ...(delegateMetadata == null ? {} : { delegate: delegateMetadata }),
+            observability,
+            coverage,
+            status_evidence: { coverage },
+            debug: input.debug,
+        };
+        await lifecycle?.transition("writing", {
+            ...delegateLifecyclePatch(effectiveDelegateResult, lifecycle),
+            counts: lifecycleCountsFromMetrics(metrics, discovery.search.length),
+            coverage: lifecycleCoverage(coverage),
+            ...(effectiveDelegateResult?.delegate.fallback_used === true
+                ? {
+                    fallback: {
+                        status: "used",
+                        reason_code: "delegate_fallback",
+                    },
+                    reasonCodes: ["delegate_fallback"],
+                }
+                : {}),
+        });
+        // Capture into a const so the beforeManifestCommit closure keeps the
+        // narrowed non-undefined type (the outer binding is a reassignable let).
+        const committingLifecycle = lifecycle;
+        const receipt = await withContextBuilderWriteWatchdog((signal) => writeContextBuilderFinalArtifacts(writingStorage, renderInput, {
+            signal,
+            ...(writingStorage.ownerNonce == null ? {} : { ownerNonce: writingStorage.ownerNonce }),
+            ...(!ownsLifecycle || committingLifecycle == null
+                ? {}
+                : { beforeManifestCommit: () => committingLifecycle.transition("committing") }),
+        }), options.signal == null ? {} : { signal: options.signal });
+        committed = true;
+        if (ownsLifecycle) {
+            await recordContextRunCatalogMarker({
+                runsDir,
+                kind: "artifact",
+                id: receipt.run_id,
+                createdAt,
+            }).catch(() => {
+                logger.warn({ contextRunId: receipt.run_id }, "context run catalog marker write failed");
+            });
+        }
+        let responseReceipt = receipt;
+        if (ownsLifecycle) {
+            try {
+                await lifecycle?.complete(receipt.status, {
+                    artifactRunId: receipt.run_id,
+                    counts: lifecycleCountsFromMetrics(receipt.metrics, discovery.search.length),
+                    coverage: lifecycleCoverage(coverage),
+                });
+            }
+            catch (error) {
+                if (!(error instanceof ContextBuilderLifecycleObserverError))
+                    throw error;
+                logger.warn({ contextRunId: lifecycle?.contextRunId }, "context run lifecycle completion unavailable after retry");
+                responseReceipt = appendLifecycleCompletionWarning(receipt, internalCaps.max_warnings);
+            }
+        }
+        return createContextBuilderReceiptTextResponse(responseReceipt);
+    }
+    catch (err) {
+        if (storage != null && !committed && storage.ownerNonce != null) {
+            await cleanupContextBuilderIncompleteRun(storage, storage.ownerNonce).catch(() => { });
+        }
+        if (ownsLifecycle && lifecycle != null &&
+            !(err instanceof ContextBuilderLifecycleObserverError)) {
+            const cancelled = err instanceof CancellationError || options.signal?.aborted === true;
+            const delegateFailed = input.delegate.enabled && delegateExecutionActive(lifecycle);
+            await lifecycle.fail(cancelled ? "cancelled" : "failed", {
+                ...terminalExecutionPatch(lifecycle, cancelled),
+                reasonCodes: [
+                    cancelled
+                        ? "operation_cancelled"
+                        : delegateFailed
+                            ? "delegate_failed"
+                            : "internal_failure",
+                ],
+                ...(!cancelled && delegateFailed
+                    ? {
+                        fallback: {
+                            status: "failed",
+                            reason_code: "delegate_failed",
+                        },
+                    }
+                    : {}),
+            });
+        }
+        throw err;
+    }
+    finally {
+        semaphore.release();
+    }
+}
+function lifecycleExecutionConfig(input) {
+    if (!input.delegate.enabled) {
+        return {
+            curator: { configured: false, enabled: false },
+            finalizer: { configured: false, enabled: false },
+        };
+    }
+    return {
+        curator: { configured: true, enabled: true },
+        finalizer: {
+            configured: true,
+            enabled: contextBuilderFinalizerEnabled(input),
+        },
+    };
+}
+function lifecycleCountsFromDiscovery(discovery) {
+    return {
+        files_seen: discovery.metrics.files_seen,
+        files_considered: discovery.metrics.files_considered,
+        files_selected: 0,
+        files_omitted: discovery.omissions.length,
+        search_results: discovery.search.length,
+        bytes_read: discovery.metrics.bytes_read,
+        bytes_written: 0,
+    };
+}
+function lifecycleCountsFromMetrics(metrics, searchResults) {
+    return {
+        files_seen: metrics.files_seen,
+        files_considered: metrics.files_considered,
+        files_selected: metrics.files_selected,
+        files_omitted: metrics.files_omitted,
+        search_results: searchResults,
+        bytes_read: metrics.bytes_read,
+        bytes_written: metrics.bytes_written,
+    };
+}
+function lifecycleCoverage(coverage) {
+    const required = coverage.required_when_available.length;
+    const missing = coverage.missing_required.length;
+    return {
+        policy: coverage.policy_id,
+        status: coverage.status,
+        required,
+        selected: Math.max(0, required - missing),
+        missing,
+    };
+}
+function delegateLifecyclePatch(result, lifecycle) {
+    if (result == null)
+        return {};
+    if (result.delegate.fallback_used) {
+        if (lifecycle?.snapshot?.phase === "finalizing") {
+            return { curatorStatus: "succeeded", finalizerStatus: "failed" };
+        }
+        return {
+            curatorStatus: "failed",
+            ...(lifecycle?.snapshot?.finalizer.effective_enabled === true
+                ? { finalizerStatus: "skipped" }
+                : {}),
+        };
+    }
+    return {
+        curatorStatus: "succeeded",
+        ...(result.delegate.finalizer_score == null
+            ? {}
+            : {
+                finalizerStatus: "succeeded",
+                finalizerScore: result.delegate.finalizer_score,
+            }),
+    };
+}
+function terminalExecutionPatch(lifecycle, cancelled) {
+    const snapshot = lifecycle.snapshot;
+    if (snapshot == null)
+        return {};
+    const terminalStatus = cancelled ? "cancelled" : "failed";
+    return {
+        ...(snapshot.curator.execution_status === "running"
+            ? { curatorStatus: terminalStatus }
+            : snapshot.curator.execution_status === "pending"
+                ? { curatorStatus: "skipped" }
+                : {}),
+        ...(snapshot.finalizer.execution_status === "running"
+            ? { finalizerStatus: terminalStatus }
+            : snapshot.finalizer.execution_status === "pending"
+                ? { finalizerStatus: "skipped" }
+                : {}),
+    };
+}
+function delegateExecutionActive(lifecycle) {
+    const snapshot = lifecycle.snapshot;
+    return snapshot?.curator.execution_status === "running" ||
+        snapshot?.finalizer.execution_status === "running";
+}
+function evidenceClassesByCandidate(candidates) {
+    return new Map(candidates.map((candidate) => [
+        `${candidate.root_index}\u0000${candidate.path}`,
+        candidate.evidence_classes ?? [],
+    ]));
+}
+function evaluateSelectionCoverage(input) {
+    const classesByCandidate = evidenceClassesByCandidate(input.candidates);
+    const selectedClasses = input.selected.flatMap((file) => classesByCandidate.get(`${file.root_index}\u0000${file.path}`) ?? []);
+    return evaluateContextCoverage({
+        policy: input.policy,
+        available: input.candidates.flatMap((candidate) => candidate.evidence_classes ?? []),
+        selected: selectedClasses,
+        unclassifiable: input.policy.id == null
+            ? []
+            : ["public_entrypoint", "reverse_consumer"],
+        ...(input.obligations == null ? {} : { obligations: input.obligations }),
+        selectedRanges: input.selected,
+    });
+}
+function delegateCoverageSelectionFailure(selected, candidates, coveragePolicy) {
+    try {
+        validateContextBuilderDelegateCoverageSelection(selected.map((file) => ({
+            candidate_id: contextBuilderCandidateId(file.root_index, file.path),
+            ranges: file.ranges,
+        })), candidates, coveragePolicy);
+        return null;
+    }
+    catch (error) {
+        return error instanceof Error ? error.message : String(error);
+    }
+}
+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}`);
+        }
+    }
+}
+/**
+ * Fail-fast admission check: an explicitly-focused path that the caller's own
+ * (or the default) globs would prune is a contradictory request. Discovery
+ * only surfaces these later, one gate at a time, as fatal runtime omissions,
+ * so aggregate EVERY conflict up front into one InvalidParamsError before any
+ * scanning or delegate subprocess work begins.
+ *
+ * The check mirrors discovery's glob semantics exactly: the matcher is
+ * compiled from include_globs plus CONTEXT_BUILDER_DEFAULT_EXCLUDE_GLOBS +
+ * exclude_globs (discoverContextBuilderCandidates does the same), focus FILES
+ * are matched on their own root-relative path (processFile's includes/excludes
+ * gates), and focus DIRECTORIES are flagged only when the directory itself is
+ * exclude-pruned via the same `<dir>` / `<dir>/__dir__` probes traverseDirectory
+ * uses. Ancestor-directory exclusion and directory-vs-include pruning are
+ * deliberately NOT modeled here (they depend on traversal state), so anything
+ * not flagged falls through to discovery's existing runtime handling.
+ */
+function assertNoContextBuilderFocusGlobConflicts(input) {
+    const matcher = compileContextBuilderGlobs({
+        include: [...input.includeGlobs],
+        exclude: [
+            ...CONTEXT_BUILDER_DEFAULT_EXCLUDE_GLOBS,
+            ...input.excludeGlobs,
+        ],
+    });
+    const conflicts = [];
+    const seen = new Set();
+    for (const focus of input.focusPaths) {
+        const relative = focus.root_relative_path;
+        if (relative === "") {
+            continue;
+        }
+        const key = `${focus.root_index}\u0000${relative}\u0000${focus.kind}`;
+        if (seen.has(key)) {
+            continue;
+        }
+        seen.add(key);
+        if (focus.kind === "directory") {
+            if (matcher.excludes(relative) ||
+                matcher.excludes(`${relative}/__dir__`)) {
+                conflicts.push(`focus directory "${relative}" (root_index ${focus.root_index}) is pruned by exclude_globs`);
+            }
+            continue;
+        }
+        if (matcher.excludes(relative)) {
+            conflicts.push(`focus path "${relative}" (root_index ${focus.root_index}) is omitted by exclude_globs`);
+            continue;
+        }
+        if (!matcher.includes(relative)) {
+            conflicts.push(`focus path "${relative}" (root_index ${focus.root_index}) is outside include_globs`);
+        }
+    }
+    if (conflicts.length > 0) {
+        throw new InvalidParamsError(`context_builder focus_paths conflict with the effective include/exclude globs (${conflicts.length} conflict${conflicts.length === 1 ? "" : "s"}): ${conflicts.join("; ")}`);
+    }
+}
+function getExactlyConfiguredArtifactRoots() {
+    const rawEntries = rawAllowedRootEntries();
+    const configured = new Set();
+    const cwd = path.resolve(process.cwd());
+    for (const artifactRoot of artifactOnlyAllowedRoots) {
+        for (const rawEntry of rawEntries) {
+            if (isArtifactOnlyAllowedRootEntry(rawEntry) &&
+                realpathSyncOrUndefined(path.resolve(cwd, stripArtifactOnlyMarker(rawEntry))) === artifactRoot) {
+                continue;
+            }
+            const resolvedEntry = realpathSyncOrUndefined(path.resolve(cwd, rawEntry));
+            if (resolvedEntry === artifactRoot) {
+                configured.add(artifactRoot);
+                break;
+            }
+        }
+    }
+    return configured;
+}
+function appendArtifactOnlyRootToEnv(runsDir) {
+    appendArtifactOnlyRootsToEnv([runsDir], { requireExisting: false });
+}
+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 realpathSyncOrUndefined(input) {
+    try {
+        return realpathSync(input);
+    }
+    catch {
+        return undefined;
+    }
+}
+function getDefaultContextBuilderSemaphore() {
+    return getSharedContextBuilderSemaphore();
+}
+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,
+        allowSecrets: input.input.allow_secrets,
+        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,
+            ...(input.discovery.review_obligations == null
+                ? {}
+                : { review_obligations: input.discovery.review_obligations }),
+        },
+        selection: input.deterministicSelection,
+        budget: input.input.budget,
+        focus_paths: input.focusPaths,
+        caller_search_terms: input.input.search_terms,
+        coveragePolicy: input.coveragePolicy,
+        ...(input.delegatePacketCaps == null
+            ? {}
+            : { caps: input.delegatePacketCaps }),
+    };
+    const candidateFallbackCount = input.deterministicSelection.selected.length;
+    let curatorMs = null;
+    let finalizerMs = null;
+    let delegatePacketSize = 0;
+    // Compaction counters from the last-built packet (finalizer overrides
+    // curator) and bounded T3 evidence warnings, surfaced additively.
+    let delegatePacketCompaction;
+    const packetEvidenceWarnings = [];
+    const recordPacketEvidenceWarning = (warning) => {
+        if (warning == null ||
+            packetEvidenceWarnings.some((existing) => existing.code === warning.code)) {
+            return;
+        }
+        packetEvidenceWarnings.push({
+            code: warning.code,
+            message: warning.message,
+        });
+    };
+    const currentDelegateObservability = () => ({
+        curator_ms: curatorMs,
+        finalizer_ms: finalizerMs,
+        delegate_packet_size: delegatePacketSize,
+        ...(delegatePacketCompaction == null
+            ? {}
+            : { delegate_packet_compaction: delegatePacketCompaction }),
+    });
+    const sessionLogOwner = (executor) => input.sessionLogContext == null
+        ? undefined
+        : {
+            family: "context",
+            contextRunId: input.sessionLogContext.contextRunId,
+            contextGeneration: input.sessionLogContext.contextGeneration,
+            executor,
+            executionId: `${executor}_${input.sessionLogContext.contextRunId.slice(-32)}`,
+            attempt: 1,
+        };
+    const requestedFocusOmissions = input.discovery.omissions.filter(isRequestedEvidenceOmission);
+    if (requestedFocusOmissions.length > 0) {
+        return handleDelegateRuntimeFailure({
+            delegate,
+            reason: `requested local evidence omitted: ${formatOmissionsForDelegateFailure(requestedFocusOmissions)}`,
+            deterministicSelection: input.deterministicSelection,
+            omissionCount: input.baselineOmissions.length +
+                input.discovery.omissions.length +
+                input.deterministicSelection.omissions.length,
+            candidateFallbackCount,
+            observability: currentDelegateObservability(),
+        });
+    }
+    await input.lifecycle?.transition("curating", { curatorStatus: "running" });
+    const curatorPacket = buildContextBuilderCuratorPacket(delegatePacketInput);
+    delegatePacketSize = curatorPacket.metrics.packet_estimated_tokens;
+    delegatePacketCompaction = curatorPacket.metrics.compaction;
+    recordPacketEvidenceWarning(curatorPacket.evidence_warning);
+    const curatorPacketRequestedOmissions = curatorPacket.omissions.filter(isRequestedEvidenceOmission);
+    if (curatorPacketRequestedOmissions.length > 0) {
+        return handleDelegateRuntimeFailure({
+            delegate,
+            reason: `requested local evidence omitted: ${formatOmissionsForDelegateFailure(curatorPacketRequestedOmissions)}`,
+            deterministicSelection: input.deterministicSelection,
+            omissions: curatorPacketRequestedOmissions,
+            omissionCount: input.baselineOmissions.length +
+                input.discovery.omissions.length +
+                input.deterministicSelection.omissions.length +
+                curatorPacketRequestedOmissions.length,
+            candidateFallbackCount,
+            observability: currentDelegateObservability(),
+        });
+    }
+    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,
+            observability: currentDelegateObservability(),
+        });
+    }
+    const curatorStartMs = Date.now();
+    const curatorSessionLogOwner = sessionLogOwner("curator");
+    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 }),
+        ...(curatorSessionLogOwner == null
+            ? {}
+            : { sessionLogOwner: curatorSessionLogOwner }),
+    });
+    curatorMs = Math.max(0, Date.now() - curatorStartMs);
+    if (!curatorCall.ok) {
+        return handleDelegateRuntimeFailure({
+            delegate,
+            reason: failureReasonFromCall("curator", curatorCall),
+            failureKind: curatorCall.reason,
+            deterministicSelection: input.deterministicSelection,
+            omissionCount: input.baselineOmissions.length +
+                input.discovery.omissions.length +
+                input.deterministicSelection.omissions.length,
+            candidateFallbackCount,
+            observability: currentDelegateObservability(),
+        });
+    }
+    let curatorProposal;
+    let curatorSelection;
+    try {
+        const validatedCuratorProposal = validateContextBuilderCuratorOutput(curatorCall.json, {
+            candidates: curatorPacket.candidates,
+            budget: input.input.budget,
+            allowSecrets: input.input.allow_secrets,
+            coveragePolicy: curatorPacket.coverage_policy,
+        });
+        curatorProposal = augmentCuratorProposalWithDeterministicBaseline(validatedCuratorProposal, curatorPacket, input.input.budget.max_files);
+        curatorSelection = reconstructContextBuilderDelegateSelection({
+            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,
+            observability: currentDelegateObservability(),
+        });
+    }
+    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,
+            observability: currentDelegateObservability(),
+        });
+    }
+    if (!finalizerEnabled) {
+        const repairedSelection = repairDelegateSelection({
+            curatorSelection,
+            contentCandidates: input.discovery.content_candidates,
+            focusPaths: input.focusPaths,
+            budget: input.input.budget,
+            expandSelectedFiles: true,
+        });
+        const warnings = curatorProposal.warnings.map((message) => delegateWarning("delegate_curator_warning", message));
+        warnings.push(...packetEvidenceWarnings);
+        appendDelegateRepairWarnings(warnings, repairedSelection);
+        const openQuestions = curatorProposal.open_questions.map((question) => sanitizeDiagnosticText(question));
+        const omissionCount = input.baselineOmissions.length +
+            input.discovery.omissions.length +
+            repairedSelection.selection.omissions.length;
+        const delegateEvidenceCoverageFailure = delegateCoverageSelectionFailure(restoreDroppedDegenerateReviewTargetsForValidation({
+            preRepairSelected: curatorSelection.selected,
+            postRepairSelected: repairedSelection.selection.selected,
+            candidates: curatorPacket.candidates,
+            coveragePolicy: curatorPacket.coverage_policy,
+        }), curatorPacket.candidates, curatorPacket.coverage_policy);
+        if (delegateEvidenceCoverageFailure != null) {
+            return handleDelegateRuntimeFailure({
+                delegate,
+                reason: `post-repair evidence coverage failed: ${delegateEvidenceCoverageFailure}`,
+                deterministicSelection: input.deterministicSelection,
+                omissionCount,
+                candidateFallbackCount,
+                observability: currentDelegateObservability(),
+            });
+        }
+        // Re-verify required-focus presence against the actual returned selection.
+        // The curator-only branch does not fold required-focus ranges, so it checks
+        // whole-file presence here; range coverage is re-verified only in the
+        // finalizer branch, which folds requested focus evidence first.
+        const curatorOnlyCoverageFailure = postRepairRequiredFocusEvictionFailure({
+            focusPaths: input.focusPaths,
+            candidates: curatorPacket.candidates,
+            preRepairSelected: curatorSelection.selected,
+            postRepairSelected: repairedSelection.selection.selected,
+        });
+        if (curatorOnlyCoverageFailure != null) {
+            return handleDelegateRuntimeFailure({
+                delegate,
+                reason: `post-repair required-focus coverage failed: ${curatorOnlyCoverageFailure}`,
+                deterministicSelection: input.deterministicSelection,
+                omissionCount: input.baselineOmissions.length +
+                    input.discovery.omissions.length +
+                    input.deterministicSelection.omissions.length,
+                candidateFallbackCount,
+                observability: currentDelegateObservability(),
+            });
+        }
+        return {
+            selection: repairedSelection.selection,
+            warnings,
+            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,
+            },
+            observability: currentDelegateObservability(),
+        };
+    }
+    await input.lifecycle?.transition("finalizing", {
+        curatorStatus: "succeeded",
+        finalizerStatus: "running",
+    });
+    const finalizerPacket = buildContextBuilderFinalizerPacket({
+        ...delegatePacketInput,
+        selection: curatorSelection,
+        curator_proposal: curatorProposal,
+    });
+    delegatePacketSize = finalizerPacket.metrics.packet_estimated_tokens;
+    delegatePacketCompaction = finalizerPacket.metrics.compaction;
+    recordPacketEvidenceWarning(finalizerPacket.evidence_warning);
+    const finalizerPacketRequestedOmissions = finalizerPacket.omissions.filter(isRequestedEvidenceOmission);
+    if (finalizerPacketRequestedOmissions.length > 0) {
+        return handleDelegateRuntimeFailure({
+            delegate,
+            reason: `requested local evidence omitted: ${formatOmissionsForDelegateFailure(finalizerPacketRequestedOmissions)}`,
+            deterministicSelection: input.deterministicSelection,
+            omissions: finalizerPacketRequestedOmissions,
+            omissionCount: input.baselineOmissions.length +
+                input.discovery.omissions.length +
+                input.deterministicSelection.omissions.length +
+                finalizerPacketRequestedOmissions.length,
+            candidateFallbackCount,
+            observability: currentDelegateObservability(),
+        });
+    }
+    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,
+            observability: currentDelegateObservability(),
+        });
+    }
+    const finalizerStartMs = Date.now();
+    const finalizerSessionLogOwner = sessionLogOwner("finalizer");
+    const finalizerCall = await runContextBuilderDelegateCall({
+        prompt: renderDelegatePrompt("finalizer", finalizerPacket, {
+            minScore: delegate.finalizer.min_score,
+        }),
+        provider: delegate.finalizer,
+        registry: input.registry,
+        timeout_seconds: delegate.timeout_seconds,
+        max_response_chars: delegate.max_response_chars,
+        ...(input.signal == null ? {} : { signal: input.signal }),
+        ...(finalizerSessionLogOwner == null
+            ? {}
+            : { sessionLogOwner: finalizerSessionLogOwner }),
+    });
+    finalizerMs = Math.max(0, Date.now() - finalizerStartMs);
+    if (!finalizerCall.ok) {
+        return handleDelegateRuntimeFailure({
+            delegate,
+            reason: failureReasonFromCall("finalizer", finalizerCall),
+            failureKind: finalizerCall.reason,
+            deterministicSelection: input.deterministicSelection,
+            omissionCount: input.baselineOmissions.length +
+                input.discovery.omissions.length +
+                input.deterministicSelection.omissions.length,
+            candidateFallbackCount,
+            observability: currentDelegateObservability(),
+        });
+    }
+    try {
+        const finalizerProposal = validateContextBuilderFinalizerOutput(finalizerCall.json, {
+            candidates: finalizerPacket.candidates,
+            budget: input.input.budget,
+            minScore: delegate.finalizer.min_score,
+            allowSecrets: input.input.allow_secrets,
+            coveragePolicy: finalizerPacket.coverage_policy,
+        });
+        if (finalizerProposal.omissions.length > 0) {
+            return handleDelegateRuntimeFailure({
+                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,
+                observability: currentDelegateObservability(),
+            });
+        }
+        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,
+                observability: currentDelegateObservability(),
+            });
+        }
+        // A per-file reconstruction-budget overrun no longer fails the entire
+        // delegate selection. Over-budget candidates (e.g. large generated/i18n
+        // catalogs the finalizer over-selected) are dropped while the rest of the
+        // curated bundle is retained. Completeness is re-checked against the
+        // MATERIALIZED (post-budget) selection, so a dropped REQUIRED-FOCUS file
+        // still fails closed below, while non-required oversized files are pruned
+        // and surfaced as a warning further down rather than collapsing the bundle.
+        // Required-focus coverage is additionally re-verified against the
+        // post-repair selection below, so eviction/compaction during repair also
+        // fails closed.
+        const completenessFailure = delegateCompletenessFailure({
+            focusPaths: input.focusPaths,
+            candidates: finalizerPacket.candidates,
+            finalizerSelected: materializeFinalizerSelection(finalSelection.selected, finalizerPacket.candidates),
+            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,
+                observability: currentDelegateObservability(),
+            });
+        }
+        const repairedSelection = repairDelegateSelection({
+            curatorSelection: finalSelection,
+            contentCandidates: input.discovery.content_candidates,
+            focusPaths: input.focusPaths,
+            budget: input.input.budget,
+            expandSelectedFiles: false,
+        });
+        const delegateEvidenceCoverageFailure = delegateCoverageSelectionFailure(repairedSelection.selection.selected, finalizerPacket.candidates, finalizerPacket.coverage_policy);
+        if (delegateEvidenceCoverageFailure != null) {
+            return handleDelegateRuntimeFailure({
+                delegate,
+                reason: `post-repair evidence coverage failed: ${delegateEvidenceCoverageFailure}`,
+                deterministicSelection: input.deterministicSelection,
+                omissionCount: input.baselineOmissions.length +
+                    input.discovery.omissions.length +
+                    repairedSelection.selection.omissions.length,
+                candidateFallbackCount,
+                observability: currentDelegateObservability(),
+            });
+        }
+        // Re-verify required-focus completeness against the actual returned
+        // selection. This keeps the fallback contract tied to the final materialized
+        // packet rather than the delegate's requested selection.
+        const postRepairCoverageFailure = requiredFocusCoverageFailure({
+            focusPaths: input.focusPaths,
+            candidates: finalizerPacket.candidates,
+            finalizerSelected: materializeFinalizerSelection(repairedSelection.selection.selected, finalizerPacket.candidates),
+        });
+        if (postRepairCoverageFailure != null) {
+            return handleDelegateRuntimeFailure({
+                delegate,
+                reason: `post-repair required-focus coverage failed: ${postRepairCoverageFailure}`,
+                deterministicSelection: input.deterministicSelection,
+                omissionCount: input.baselineOmissions.length +
+                    input.discovery.omissions.length +
+                    input.deterministicSelection.omissions.length,
+                candidateFallbackCount,
+                observability: currentDelegateObservability(),
+            });
+        }
+        const warnings = [
+            ...curatorProposal.warnings.map((message) => delegateWarning("delegate_curator_warning", message)),
+            ...finalizerProposal.warnings.map((message) => delegateWarning("delegate_finalizer_warning", message)),
+        ];
+        if (foldedFinalizerSelection.foldedPaths.length > 0) {
+            warnings.push(delegateWarning("delegate_finalizer_warning", `finalizer omitted requested local evidence; server folded it back into the selection: ${boundContextBuilderPathList(foldedFinalizerSelection.foldedPaths).join(", ")}`));
+        }
+        if (finalSelection.omissions.length > 0) {
+            warnings.push(delegateWarning("delegate_finalizer_warning", `finalizer selection pruned to fit the local reconstruction budget; omitted: ${finalSelection.omissions
+                .map(formatOmissionForDelegateFailure)
+                .join("; ")}`));
+        }
+        warnings.push(...packetEvidenceWarnings);
+        appendDelegateRepairWarnings(warnings, repairedSelection);
+        const openQuestions = curatorProposal.open_questions.map((question) => sanitizeDiagnosticText(question));
+        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,
+            },
+            observability: currentDelegateObservability(),
+        };
+    }
+    catch (err) {
+        if (err instanceof CancellationError) {
+            throw err;
+        }
+        if (err instanceof ExecutionError) {
+            throw err;
+        }
+        return handleDelegateRuntimeFailure({
+            delegate,
+            reason: failureReasonFromError("finalizer_validation", err, `${delegatePromptDiagnostic(finalizerPacket)}${finalizerScoreDiagnostic(finalizerCall.json, delegate.finalizer.min_score)}`),
+            deterministicSelection: input.deterministicSelection,
+            omissionCount: input.baselineOmissions.length +
+                input.discovery.omissions.length +
+                input.deterministicSelection.omissions.length,
+            candidateFallbackCount,
+            observability: currentDelegateObservability(),
+        });
+    }
+}
+function restoreDroppedDegenerateReviewTargetsForValidation(input) {
+    const targetKeys = new Set((input.coveragePolicy.obligations?.targets ?? []).flatMap((target) => {
+        const candidate = input.candidates.find((item) => item.id === target.candidate_id);
+        return candidate == null
+            ? []
+            : [`${candidate.root_index}\u0000${candidate.path}`];
+    }));
+    if (targetKeys.size === 0) {
+        return [...input.postRepairSelected];
+    }
+    const postRepairKeys = new Set(input.postRepairSelected.map((file) => selectedFileKey(file)));
+    const droppedDegenerateTargets = input.preRepairSelected.filter((file) => {
+        const key = selectedFileKey(file);
+        return (targetKeys.has(key) &&
+            !postRepairKeys.has(key) &&
+            file.content.trim().length === 0);
+    });
+    return [...input.postRepairSelected, ...droppedDegenerateTargets];
+}
+function repairDelegateSelection(input) {
+    const focusExpanded = input.expandSelectedFiles
+        ? expandSelectedFocusFilesToFullCandidates(input.curatorSelection, input.contentCandidates, input.focusPaths, input.budget)
+        : { selection: input.curatorSelection, expandedCount: 0 };
+    const smallSlicesExpanded = input.expandSelectedFiles
+        ? expandSelectedSmallFilesToFullCandidates(focusExpanded.selection, input.contentCandidates, input.focusPaths, input.budget)
+        : focusExpanded;
+    const emptyDropped = dropEmptySelectedFiles(smallSlicesExpanded.selection);
+    return {
+        selection: emptyDropped.selection,
+        expandedCount: focusExpanded.expandedCount + smallSlicesExpanded.expandedCount,
+        droppedDegenerateCount: emptyDropped.droppedCount,
+    };
+}
+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)`));
+    }
+}
+function expandSelectedFocusFilesToFullCandidates(selection, candidates, focusPaths, budget) {
+    const focusKeys = new Set(focusPaths
+        .filter((focus) => focus.kind === "file")
+        .map((focus) => `${focus.root_index}\u0000${focus.root_relative_path}`));
+    if (focusKeys.size === 0) {
+        return { selection, expandedCount: 0 };
+    }
+    const candidatesByKey = new Map(candidates.map((candidate) => [selectedFileKey(candidate), candidate]));
+    let totalBytes = selection.metrics.bytes_selected;
+    let totalTokens = selection.metrics.estimated_tokens;
+    let expandedCount = 0;
+    const selected = selection.selected.map((file) => {
+        const key = selectedFileKey(file);
+        if (!focusKeys.has(key)) {
+            return file;
+        }
+        if (file.ranges.length !== 1) {
+            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;
+        }
+        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,
+            },
+        },
+    };
+}
+const SMALL_SELECTED_SLICE_FULL_EXPANSION_MAX_BYTES = 64_000;
+function expandSelectedSmallFilesToFullCandidates(selection, candidates, focusPaths, budget) {
+    const candidatesByKey = new Map(candidates.map((candidate) => [selectedFileKey(candidate), candidate]));
+    const focusKeys = new Set(focusPaths
+        .filter((focus) => focus.kind === "file")
+        .map((focus) => `${focus.root_index}\u0000${focus.root_relative_path}`));
+    let totalBytes = selection.metrics.bytes_selected;
+    let totalTokens = selection.metrics.estimated_tokens;
+    let expandedCount = 0;
+    const selected = selection.selected.map((file) => {
+        if (focusKeys.has(selectedFileKey(file)) || file.ranges.length !== 1) {
+            return file;
+        }
+        const candidate = candidatesByKey.get(selectedFileKey(file));
+        if (candidate == null || fileCoversCandidate(file, candidate)) {
+            return file;
+        }
+        if (candidate.byte_length > SMALL_SELECTED_SLICE_FULL_EXPANSION_MAX_BYTES) {
+            return file;
+        }
+        const fullFile = selectedFileFromCandidate(candidate);
+        if (fullFile.bytes <= file.bytes) {
+            return file;
+        }
+        const totalsWithoutFile = {
+            totalBytes: totalBytes - file.bytes,
+            totalTokens: totalTokens - file.estimated_tokens,
+        };
+        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 dropEmptySelectedFiles(selection) {
+    const selected = selection.selected.filter((file) => file.content.trim().length > 0);
+    const droppedCount = selection.selected.length - selected.length;
+    if (droppedCount === 0) {
+        return { selection, droppedCount };
+    }
+    return {
+        selection: selectionWithSelectedFiles(selection, selected),
+        droppedCount,
+    };
+}
+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}`;
+}
+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 fileCoversCandidate(file, candidate) {
+    return file.ranges.some((range) => range.start_line <= 1 &&
+        range.end_line >= Math.max(1, candidate.line_count));
+}
+function handleDelegateRuntimeFailure(input) {
+    // Delegate-failure reasons aggregate many per-entry details (each already
+    // individually sanitized/redacted where assembled); the wider marked-
+    // truncation bound keeps the tail from being silently dropped.
+    const failureReason = sanitizeDelegateFailureText(input.reason);
+    if (input.delegate.failure_policy === "fail") {
+        const error = new ExecutionError(`context_builder delegate failed: ${failureReason}`);
+        if (input.failureKind === "timeout") {
+            error.failureClass = "transient";
+        }
+        throw error;
+    }
+    const warnings = [
+        delegateWarning("delegate_fallback", `Delegate curation failed; deterministic selection was used. ${failureReason}`),
+    ];
+    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,
+        },
+        observability: input.observability ?? {
+            curator_ms: null,
+            finalizer_ms: null,
+            delegate_packet_size: 0,
+        },
+    };
+}
+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)}`;
+}
+// Bounds for the aggregated delegate-failure omission list. Entries past the
+// cap are dropped with an explicit `(+N more omissions)` marker and the total
+// count always leads the message, so truncation is never silent.
+const DELEGATE_FAILURE_MAX_OMISSION_ENTRIES = 6;
+const DELEGATE_FAILURE_MAX_ENTRY_TEXT_LENGTH = 240;
+const DELEGATE_FAILURE_MAX_ENTRY_PATHS = 5;
+function formatOmissionsForDelegateFailure(omissions) {
+    const total = omissions.length;
+    const shown = omissions
+        .slice(0, DELEGATE_FAILURE_MAX_OMISSION_ENTRIES)
+        .map(formatOmissionEntryForDelegateFailure);
+    const droppedSuffix = total > shown.length ? ` (+${total - shown.length} more omissions)` : "";
+    return `${total} omission${total === 1 ? "" : "s"}: ${shown.join("; ")}${droppedSuffix}`;
+}
+function formatOmissionEntryForDelegateFailure(omission) {
+    // Redaction happens per entry, BEFORE assembly into the aggregate message:
+    // paths through boundContextBuilderPathList (secret-path redaction) and free
+    // text through the marked bounded sanitizer, so no entry can smuggle secret
+    // material into the joined reason and no entry ends in an unmarked "...".
+    const allPaths = omission.paths ?? [];
+    const shownPaths = boundContextBuilderPathList(allPaths, DELEGATE_FAILURE_MAX_ENTRY_PATHS);
+    const pathText = shownPaths.length === 0
+        ? "unknown focused path"
+        : allPaths.length > shownPaths.length
+            ? `${shownPaths.join(", ")} (+${allPaths.length - shownPaths.length} more paths)`
+            : shownPaths.join(", ");
+    return `${sanitizeDelegateFailureText(omission.reason, DELEGATE_FAILURE_MAX_ENTRY_TEXT_LENGTH)} (${pathText}): ${sanitizeDelegateFailureText(omission.message, DELEGATE_FAILURE_MAX_ENTRY_TEXT_LENGTH)}`;
+}
+function rangeCoveredByRanges(target, ranges) {
+    let nextLine = target.start_line;
+    for (const range of [...ranges].sort((left, right) => left.start_line - right.start_line || left.end_line - right.end_line)) {
+        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("; ")}`;
+    }
+    return requiredFocusCoverageFailure(input);
+}
+function requiredFocusCoverageFailure(input) {
+    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("; ")}`;
+}
+// Curator-only post-repair guard. Unlike the finalizer branch, the curator-only
+// path does not fold required-focus ranges, so its baseline is the curator's
+// own pre-repair selection. Repair is allowed to:
+//   - COMPACT a required-focus file's ranges to fit budget pressure (the file
+//     stays in the bundle, just sliced — the documented focus-slicing behavior); and
+//   - DROP a degenerate (whitespace-only) selected slice entirely (server-dropped).
+// The HIGH failure mode this guards is repair evicting a NON-degenerate
+// required-focus candidate ENTIRELY: a focus file with real content that the
+// curator selected and that survived reconstruction must not silently vanish
+// from the post-repair selection. Whole-file eviction of non-empty required
+// focus fails closed.
+function postRepairRequiredFocusEvictionFailure(input) {
+    // Root-aware required-focus key set: a multi-root run can carry the same
+    // relative path under two roots, only one of which is required focus. Keying
+    // the required set by bare path would misclassify the non-required twin.
+    const requiredKeys = new Set(input.candidates
+        .filter((candidate) => candidate.focus_requested === true &&
+        (candidate.required_focus_ranges?.length ?? 0) > 0 &&
+        candidateMatchesFocusPath(candidate, input.focusPaths))
+        .map((candidate) => `${candidate.root_index}:${candidate.path}`));
+    if (requiredKeys.size === 0) {
+        return undefined;
+    }
+    const selectedFileKey = (file) => `${file.root_index}:${file.path}`;
+    // Pre-repair required-focus files that carried real (non-whitespace) content.
+    // A whitespace-only focus slice is legitimately server-dropped by repair, so
+    // exempt it — only its eviction is a no-op, never a hard failure.
+    const preRepairRequired = new Map();
+    for (const file of input.preRepairSelected) {
+        if (requiredKeys.has(selectedFileKey(file)) &&
+            file.ranges.length > 0 &&
+            file.content.trim().length > 0) {
+            preRepairRequired.set(selectedFileKey(file), file);
+        }
+    }
+    const postRepairKeys = new Set(input.postRepairSelected
+        .filter((file) => file.ranges.length > 0)
+        .map(selectedFileKey));
+    const evicted = [...preRepairRequired.values()]
+        .filter((file) => !postRepairKeys.has(selectedFileKey(file)))
+        .map((file) => `root ${file.root_index}: ${file.path}`);
+    if (evicted.length === 0) {
+        return undefined;
+    }
+    return `repair evicted required-focus evidence the curator selection carried: ${evicted.join("; ")}`;
+}
+export const postRepairRequiredFocusEvictionFailureForTest = postRepairRequiredFocusEvictionFailure;
+function warningReferencesSelectedDelegateCandidate(input) {
+    const selectedCandidateIds = new Set(input.selected.map((selection) => selection.candidate_id));
+    const selectedFiles = input.candidates
+        .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);
+}
+/**
+ * Re-express a materialized (post-budget reconstruction) selection as
+ * candidate-id-keyed proposal selections so completeness can be evaluated
+ * against what actually survived the local reconstruction budget — not what
+ * the finalizer merely requested. A candidate dropped by the budget guard is
+ * absent here, so any required-focus range it carried reads as uncovered and
+ * fails closed in delegateCompletenessFailure.
+ */
+function materializeFinalizerSelection(selected, candidates) {
+    const candidateIdByKey = new Map();
+    for (const candidate of candidates) {
+        candidateIdByKey.set(`${candidate.root_index}:${candidate.path}`, candidate.id);
+    }
+    const materialized = [];
+    for (const file of selected) {
+        const candidateId = candidateIdByKey.get(`${file.root_index}:${file.path}`);
+        if (candidateId == null) {
+            continue;
+        }
+        materialized.push({
+            candidate_id: candidateId,
+            reason: "materialized post-budget selection",
+            ranges: file.ranges.map((range) => ({
+                start_line: range.start_line,
+                end_line: range.end_line,
+                reason: "materialized post-budget selection range",
+            })),
+        });
+    }
+    return materialized;
+}
+function requiredFocusEvidenceSelections(input) {
+    if (input.focusPaths.length === 0) {
+        return [];
+    }
+    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);
+}
+/**
+ * Renders the server-enforced coverage obligations as explicit prompt rules.
+ *
+ * The obligations are already present in the serialized packet, but the packet
+ * alone never told the delegate they were MANDATORY, so a schema-valid proposal
+ * could miss one and be rejected by
+ * {@link validateContextBuilderDelegateCoverageSelection}.
+ *
+ * Branch selection here tracks that validator's branch selection: it enters the
+ * obligation branch on `obligations != null`, NOT on a non-empty target list.
+ * Branching on `targets.length > 0` instead would render the satisfiable
+ * evidence-class contract for a packet the validator rejects outright, i.e.
+ * instruct the delegate to do something that provably cannot pass.
+ */
+function packetCoverageObligationRules(packet) {
+    if (packet == null || typeof packet !== "object") {
+        return [];
+    }
+    const policy = packet["coverage_policy"];
+    if (policy == null || typeof policy !== "object") {
+        return [];
+    }
+    const policyRecord = policy;
+    if (policyRecord["policy_id"] !== "review_deep_v1") {
+        return [];
+    }
+    const requiredClasses = policyRecord["required_when_available"];
+    if (!Array.isArray(requiredClasses) || requiredClasses.length === 0) {
+        return [];
+    }
+    const obligations = policyRecord["obligations"];
+    if (obligations != null && typeof obligations === "object") {
+        const targets = obligations["targets"];
+        if (!Array.isArray(targets) || targets.length === 0) {
+            // The validator rejects a present-but-empty target list unconditionally,
+            // so no instruction rendered here could be satisfied. Stay silent rather
+            // than describe a contract the delegate cannot meet. (The server building
+            // a packet it will always reject is a separate defect; do not paper over
+            // it by rendering the evidence-class rules the validator will not apply.)
+            return [];
+        }
+        return [
+            "Coverage obligations (mandatory, server-enforced):",
+            "- packet.coverage_policy.obligations.targets is required coverage, not a suggestion. Server validation rejects your output if any obligation below is unmet, even when every other rule is satisfied.",
+            "- For EVERY target: selected MUST contain that target's candidate_id with at least one range that overlaps one of that target's ranges.",
+            "- For EVERY target whose regression_links is non-empty: selected MUST also contain at least ONE of those links' candidate_id with an overlapping range. One linked candidate per target is sufficient; you do not need all of them.",
+            "- Obligations hold even when the task reads narrower than the obligation set. Add the obligation candidates alongside your task-driven picks rather than dropping them.",
+        ];
+    }
+    const classes = requiredClasses.filter((entry) => typeof entry === "string");
+    if (classes.length === 0) {
+        return [];
+    }
+    return [
+        "Coverage obligations (mandatory, server-enforced):",
+        `- packet.coverage_policy.required_when_available lists required evidence classes: ${classes.join(", ")}.`,
+        "- For every listed class that ANY packet candidate carries in its evidence_classes, selected MUST include at least one candidate carrying that class. Server validation rejects your output otherwise.",
+    ];
+}
+/**
+ * Renders the finalizer scoring contract.
+ *
+ * `min_score` is a server-side gate
+ * ({@link validateContextBuilderFinalizerOutput}); before this it was never
+ * sent to the model, so the finalizer was asked to clear a bar it could not
+ * see, on a scale that was never defined. The rubric below is deliberately
+ * anchored so that an approving score lands at or above the threshold, and it
+ * names the dominant real-world failure mode: penalizing the packet for
+ * evidence the packet was never meant to contain.
+ */
+function finalizerScoringRules(minScore) {
+    if (minScore == null) {
+        return [];
+    }
+    // A threshold of 0 cannot reject anything (the gate is `score < minScore`), so
+    // the usual "below X, do not approve" band would render a range no score can
+    // occupy and instruct the delegate to "honestly reach 0". State the degenerate
+    // case plainly instead of rendering an impossible rule.
+    const scoreBands = minScore <= 0
+        ? [
+            `- score does not gate this request (any score clears a minimum of ${minScore}); express insufficiency through approved:false and concrete omissions, never through a low score.`,
+        ]
+        : [
+            "- score rates ONLY whether the `selected` you are returning is sufficient, correct local evidence for packet.task, judged against the evidence actually present in this packet:",
+            // Bands are stated relative to the live threshold rather than as fixed
+            // ranges. Fixed bands (9-10 / 6-8 / 0-5) left the shipped 8.5 default
+            // in an undefined gap, and at a lower configured threshold they
+            // labelled the passing score as deficient — telling the delegate to
+            // approve while self-reporting a score whose own band calls the
+            // selection inadequate.
+            `  - ${minScore}-10: selected is sufficient for the task; no packet evidence the task requires was left out.`,
+            `  - below ${minScore}: selected is wrong, or omits locally-available packet evidence the task needs. Do not approve.`,
+            `- If you would approve, return a score at or above ${minScore}. If you cannot honestly reach ${minScore}, set approved:false and list concrete omissions rather than approving with a failing score.`,
+        ];
+    return [
+        "Scoring (server-enforced):",
+        `- score >= ${minScore} clears the score gate; below ${minScore} fails the whole request regardless of everything else. Clearing the score gate is necessary but NOT sufficient — approved, omissions, warnings, selections, coverage, and budget are each validated separately.`,
+        ...scoreBands,
+        "- Do NOT lower score for evidence that is absent from the packet, outside the bounded task, or that you merely suspect exists elsewhere in the repository. The packet is intentionally bounded and is the only source of truth for this call.",
+        // The server scans warnings with a keyword-proximity matcher
+        // (isMaterialEvidenceGapWarning) that has no negation handling, so an
+        // affirmative all-clear is rejected exactly like a real gap report. Name the
+        // exact fatal phrasings; a partial description reads as authoritative and is
+        // worse than none.
+        "- warnings carry speculative or out-of-scope notes ONLY, and the server scans them for evidence-gap phrasing. Do not mention required, requested, or focused evidence in warnings at all — not even to state that nothing is missing — and never phrase a warning as 'outside the selected range(s)' or as 'selected ... not present/not selectable/unselectable'. That scan is a keyword-proximity match with no negation handling, so an affirmative all-clear is rejected exactly like a real gap report.",
+        "- If required evidence is genuinely missing, set approved:false with concrete omissions. Never route a real coverage gap into warnings.",
+    ];
+}
+/**
+ * Single source for every score exemplar the finalizer prompt shows.
+ *
+ * The shape example, the rubric bands, and the minimum-output example must all
+ * derive from the live threshold: hardcoding them let the prompt display a
+ * score that its own rubric did not cover, and (at `min_score` above the
+ * hardcoded value — 9.25 is schema-legal) an example that would fail the very
+ * gate it was illustrating.
+ */
+function finalizerExampleScore(minScore) {
+    // A non-gating threshold gets the neutral fallback rather than its own value:
+    // "emit the lowest score that still clears the gate" is the right anti-inflation
+    // rule wherever a gate exists, but at 0 it would render `{"score":0,"approved":true}`
+    // and an unsure finalizer copying that reports a 0-scored approval into
+    // `finalizer_score` observability. A higher exemplar always clears a lower gate.
+    return minScore == null || minScore <= 0 ? 9 : minScore;
+}
+export function renderDelegatePrompt(stage, packet, options) {
+    // Diagnostic-array exemplars are non-empty on purpose: empty arrays cannot
+    // communicate element types, and a live finalizer failure returned
+    // object-shaped `omissions`. The angle-bracket entries are placeholders that
+    // show each element is one plain string.
+    const outputShape = stage === "curator"
+        ? '{"selected":[{"candidate_id":"c:0:path","ranges":[{"start_line":1,"end_line":1,"reason":"why this range"}],"reason":"why this file"}],"warnings":["<short plain-string caveat>"],"open_questions":["<short plain-string follow-up question>"]}'
+        : `{"score":${finalizerExampleScore(options?.minScore)},"approved":true,"selected":[{"candidate_id":"c:0:path","ranges":[{"start_line":1,"end_line":1,"reason":"why this range"}],"reason":"why this file"}],"warnings":["<short plain-string caveat>"],"omissions":["<short plain string describing an omitted file or range; must be [] when approving>"]}`;
+    const stageRules = stage === "curator"
+        ? [
+            "Curator-specific rules:",
+            "- 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.",
+            // The validator requires string elements (SafeTextSchema) in every
+            // diagnostic array; empty exemplars alone let models invent object
+            // entries, which fail schema validation.
+            "- warnings and open_questions are arrays of plain strings. Each element is one short plain string; objects inside these arrays are invalid and fail server validation.",
+        ]
+        : [
+            "Finalizer-specific rules:",
+            "- 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.",
+            // "'may contain more detail' caveats" invited exactly the phrasing
+            // isMaterialEvidenceGapWarning rejects outright
+            // (/\boutside (?:the )?selected ranges?\b/), so obeying this rule got
+            // the finalizer hard-failed. Steer the caveat at evidence absent from
+            // the packet instead of at the selected ranges.
+            "- If approving with score at or above the requested minimum, omissions MUST be []. Put speculative concerns about evidence absent from this packet in warnings instead.",
+            // The observed live schema failure was object-shaped `omissions`;
+            // state the element type explicitly instead of relying on exemplars.
+            // (No open_questions here: the finalizer schema is strict and would
+            // reject that key as unrecognized.)
+            "- warnings and omissions are arrays of plain strings. Each element is one short plain string; objects inside these arrays are invalid and fail server validation.",
+        ];
+    const minimumOutput = buildMinimumDelegateOutput(stage, packet, options?.minScore);
+    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,
+        ...(stage === "finalizer" ? finalizerScoringRules(options?.minScore) : []),
+        ...packetCoverageObligationRules(packet),
+        ...(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");
+}
+/**
+ * True when `selections` would clear the packet's coverage obligations.
+ *
+ * Mirrors {@link validateContextBuilderDelegateCoverageSelection}: every target
+ * needs an overlapping selected range, and a target with regression links needs
+ * an overlapping range from at least ONE of them (the link check is disjunctive).
+ */
+function selectionsSatisfyPacketObligations(selections, packet) {
+    if (packet == null || typeof packet !== "object") {
+        return true;
+    }
+    const policy = packet["coverage_policy"];
+    if (policy == null || typeof policy !== "object") {
+        return true;
+    }
+    const policyRecord = policy;
+    if (policyRecord["policy_id"] !== "review_deep_v1") {
+        return true;
+    }
+    const requiredClasses = policyRecord["required_when_available"];
+    if (!Array.isArray(requiredClasses) || requiredClasses.length === 0) {
+        return true;
+    }
+    const obligations = policyRecord["obligations"];
+    if (obligations == null || typeof obligations !== "object") {
+        // The validator does NOT concede this branch: it falls through to the
+        // evidence-class check and still rejects a selection that omits an
+        // available required class. Returning true here would advertise an example
+        // the validator rejects. Unreachable through the current packet builder
+        // (normalizeCoveragePolicy attaches obligations for every review_deep_v1
+        // policy), but the two must not disagree — that divergence is the bug
+        // generator this whole change exists to close.
+        const candidates = packet["candidates"];
+        if (!Array.isArray(candidates)) {
+            return true;
+        }
+        const selectedIds = new Set(selections.map((selection) => selection.candidate_id));
+        const evidenceClassesOf = (candidate) => {
+            if (candidate == null || typeof candidate !== "object") {
+                return [];
+            }
+            const classes = candidate["evidence_classes"];
+            return Array.isArray(classes) ? classes : [];
+        };
+        return requiredClasses.every((evidenceClass) => {
+            const available = candidates.some((candidate) => evidenceClassesOf(candidate).includes(evidenceClass));
+            if (!available) {
+                return true;
+            }
+            return candidates.some((candidate) => {
+                const id = candidate != null && typeof candidate === "object"
+                    ? candidate["id"]
+                    : undefined;
+                return (typeof id === "string" &&
+                    selectedIds.has(id) &&
+                    evidenceClassesOf(candidate).includes(evidenceClass));
+            });
+        });
+    }
+    const targets = obligations["targets"];
+    if (!Array.isArray(targets)) {
+        return true;
+    }
+    if (targets.length === 0) {
+        // The validator rejects a present-but-empty target list unconditionally, so
+        // no example can be valid.
+        return false;
+    }
+    const selectedById = new Map(selections.map((selection) => [selection.candidate_id, selection.ranges]));
+    const covers = (value) => {
+        if (value == null || typeof value !== "object") {
+            return false;
+        }
+        const record = value;
+        const candidateId = record["candidate_id"];
+        if (typeof candidateId !== "string") {
+            return false;
+        }
+        const selectedRanges = selectedById.get(candidateId);
+        if (selectedRanges == null || selectedRanges.length === 0) {
+            return false;
+        }
+        const obligationRanges = record["ranges"];
+        if (!Array.isArray(obligationRanges) || obligationRanges.length === 0) {
+            return false;
+        }
+        return obligationRanges.some((range) => {
+            if (range == null || typeof range !== "object") {
+                return false;
+            }
+            const start = range["start_line"];
+            const end = range["end_line"];
+            if (typeof start !== "number" || typeof end !== "number") {
+                return false;
+            }
+            return selectedRanges.some((selectedRange) => selectedRange.start_line <= end && start <= selectedRange.end_line);
+        });
+    };
+    return targets.every((target) => {
+        if (!covers(target)) {
+            return false;
+        }
+        const links = target["regression_links"];
+        if (!Array.isArray(links) || links.length === 0) {
+            return true;
+        }
+        return links.some((link) => covers(link));
+    });
+}
+/** The packet's `budget.max_files`, when it carries a usable one. */
+function packetBudgetMaxFiles(packet) {
+    if (packet == null || typeof packet !== "object") {
+        return null;
+    }
+    const budget = packet["budget"];
+    if (budget == null || typeof budget !== "object") {
+        return null;
+    }
+    const maxFiles = budget["max_files"];
+    return typeof maxFiles === "number" && Number.isFinite(maxFiles) && maxFiles > 0
+        ? maxFiles
+        : null;
+}
+function buildMinimumDelegateOutput(stage, packet, minScore) {
+    const allSelections = packetMinimumSelections(stage, packet);
+    if (allSelections.length === 0) {
+        return null;
+    }
+    // The example is advertised as "minimum valid" and a delegate may copy it
+    // verbatim, so it must satisfy every gate the copy would face.
+    //
+    // packetMinimumSelections bounds by MAX_DELEGATE_MINIMUM_OUTPUT_SELECTIONS,
+    // which is unrelated to the caller's budget: validateBudget rejects a
+    // selection longer than budget.max_files, so an unbounded example was invalid
+    // whenever max_files was the smaller limit. Apply the budget first, then judge
+    // coverage on exactly what is advertised.
+    const maxFiles = packetBudgetMaxFiles(packet);
+    const minimumSelections = maxFiles == null ? allSelections : allSelections.slice(0, maxFiles);
+    if (minimumSelections.length === 0) {
+        return null;
+    }
+    // Neither bound ranks obligations first, so a required target can fall outside
+    // the cap — offering an example that fails coverage validation. Withhold the
+    // example rather than advertise an invalid one.
+    if (!selectionsSatisfyPacketObligations(minimumSelections, packet)) {
+        return null;
+    }
+    const selected = minimumSelections.map((selection) => ({
+        candidate_id: selection.candidate_id,
+        ranges: selection.ranges.map((range) => ({
+            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: [],
+        }
+        : {
+            // This example is offered to an UNSURE finalizer, and it carries a
+            // deliberately minimal selection. Stamping it `score: 10` would pair
+            // the top of the scale with the floor of the evidence and teach
+            // "when uncertain, emit 10" — inflating the very self-score the gate
+            // relies on. Emit the lowest score that still clears the gate, so the
+            // minimum selection reads as the minimum passing answer.
+            score: finalizerExampleScore(minScore),
+            approved: true,
+            selected,
+            warnings: [
+                "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) ?? [];
+        // Deduplicate by bounds. Sources overlap by construction — a candidate in
+        // deterministic_selection is normally also present in packet.candidates —
+        // so concatenating produced the SAME range twice, and validateSelections
+        // rejects a duplicate range outright. That made the advertised "minimum
+        // valid JSON" example invalid in the ordinary case: a delegate copying it
+        // was hard-failed by the server that offered it.
+        for (const range of selection.ranges) {
+            if (!ranges.some((existing) => existing.start_line === range.start_line &&
+                existing.end_line === range.end_line)) {
+                ranges.push(range);
+            }
+        }
+        merged.set(selection.candidate_id, ranges);
+    }
+    return [...merged].map(([candidate_id, ranges]) => ({
+        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;
+    // `curator_proposal` only exists on a finalizer packet (curator packets are
+    // built before any proposal exists). Reporting `curator_selected=0` for a
+    // curator packet described the packet's missing field, not the curator's
+    // output, so every curator-stage diagnostic claimed an empty selection that
+    // had in fact never been observed. Omit the field unless the packet carries a
+    // proposal to count.
+    const proposal = record["curator_proposal"];
+    const proposalSelected = proposal != null && typeof proposal === "object"
+        ? proposal["selected"]
+        : undefined;
+    // `min` must report what the prompt actually carried, not whether a minimum
+    // selection could be computed: buildMinimumDelegateOutput also withholds the
+    // example when it would fail budget or coverage, and a withheld floor example
+    // is exactly the condition worth seeing next to a delegate failure. Derive it
+    // from the same call the prompt makes, at the stage this packet belongs to.
+    const stage = Array.isArray(proposalSelected)
+        ? "finalizer"
+        : "curator";
+    return [
+        `pv=${CONTEXT_BUILDER_DELEGATE_PROMPT_VERSION}`,
+        `candidates=${candidateCount}`,
+        `det=${deterministicCount}`,
+        ...(Array.isArray(proposalSelected)
+            ? [`curator_selected=${proposalSelected.length}`]
+            : []),
+        `min=${buildMinimumDelegateOutput(stage, packet) != null}`,
+    ].join("; ");
+}
+function failureReasonFromCall(stage, call) {
+    return `${stage} ${call.reason}: ${call.message}`;
+}
+/**
+ * Safe-scalar score context for finalizer rejections. A not-approved rejection
+ * previously carried no score at all; surfacing the reported score next to the
+ * configured min_score makes rejection and under-score failures diagnosable
+ * from the failure reason alone. Only a finite numeric `score` read from the
+ * finalizer's raw JSON is ever included — never free-form provider text.
+ */
+function finalizerScoreDiagnostic(json, minScore) {
+    const rawScore = json != null && typeof json === "object"
+        ? json["score"]
+        : undefined;
+    return typeof rawScore === "number" && Number.isFinite(rawScore)
+        ? `; finalizer_score=${rawScore}; min_score=${minScore}`
+        : `; min_score=${minScore}`;
+}
+function failureReasonFromError(stage, err, diagnostic) {
+    const message = err instanceof Error ? err.message : "unknown delegate error";
+    return diagnostic == null
+        ? `${stage}: ${message}`
+        : `${stage}: ${diagnostic}; ${message}`;
+}
+function delegateWarning(code, message) {
+    return {
+        code: sanitizeDiagnosticText(code),
+        message: sanitizeDiagnosticText(message),
+    };
+}
+// Bounded per-term detail in the search-cap coverage warning. Full per-term
+// rows (up to the public 20-term cap) persist in manifest/summary
+// `search_coverage`; the warning message stays a compact summary.
+const MAX_SEARCH_CAP_WARNING_TERM_DETAILS = 6;
+/**
+ * Builds the receipt-visible explanation for a MATERIAL search cap. Returns
+ * undefined when the cap was not hit or coverage proves it non-material.
+ * The warning `code` is the stable materiality reason string
+ * (`search_cap_unresolved_coverage` / `search_cap_unsearched_candidates`);
+ * classification itself rides on the cap event in the status reducer, so this
+ * warning is explanatory and never double-counts toward `partial`.
+ * Terms are referenced by `search_term_index`, never by value, so the warning
+ * cannot leak caller term text; the full (sanitized) rows live in
+ * `search_coverage`. The first unsearched candidate's rank/path is not
+ * reported: T1's coverage counters are aggregate-only by design and the
+ * caller-phase scheduler is term-major round-robin, so the searched set is not
+ * an ordering prefix and no per-candidate identity is cheaply available.
+ */
+function searchCapCoverageWarning(searchCapHit, coverage) {
+    if (!searchCapHit) {
+        return undefined;
+    }
+    const materiality = evaluateSearchCapMateriality(coverage);
+    if (!materiality.material) {
+        return undefined;
+    }
+    const incompleteTerms = coverage.caller_terms.filter((term) => !term.scan_complete);
+    const termDetails = incompleteTerms
+        .slice(0, MAX_SEARCH_CAP_WARNING_TERM_DETAILS)
+        .map((term) => `#${term.search_term_index}(hits=${term.hit_count})`)
+        .join(", ");
+    const hiddenIncomplete = incompleteTerms.length - Math.min(incompleteTerms.length, MAX_SEARCH_CAP_WARNING_TERM_DETAILS);
+    const callerSummary = coverage.caller_term_count === 0
+        ? "caller terms 0"
+        : `caller terms ${coverage.caller_term_count} (${incompleteTerms.length} incomplete${termDetails.length === 0 ? "" : `: ${termDetails}`}${hiddenIncomplete > 0 ? `, +${hiddenIncomplete} more` : ""}; ${coverage.caller_record_count} records)`;
+    return {
+        code: materiality.reason,
+        message: `search cap ended discovery before coverage was proven: searched ` +
+            `${coverage.searched_candidate_count}/${coverage.eligible_candidate_count} eligible candidates ` +
+            `(${coverage.unsearched_candidate_count} unsearched); ${callerSummary}; ` +
+            `derived terms ${coverage.derived_term_count} (${coverage.derived_record_count} records); ` +
+            `full per-term coverage is in manifest.json search_coverage`,
+    };
+}
+function reconcileContextBuilderWarnings(input) {
+    if (input.warnings.length === 0) {
+        return [];
+    }
+    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