clinkx 0.2.3 → 0.3.0

package/dist/context-builder/selection.js

@@ -0,0 +1,1649 @@
+import { mergeLineRanges, splitTextLines, } from "./discovery.js";
+import { buildFileCodemap } from "./codemap.js";
+import { directoryDistance, genericPathKind, isTestPath, normalizedPathStem, } from "./path-signals.js";
+import { estimateContextBuilderTokensFromUtf8Bytes } from "./token-estimate.js";
+export function selectContextBuilderFinalContext(input) {
+    const pending = buildPendingSelections(input.slices, input.search, input.task ?? "", input.budget);
+    const selected = [];
+    const omissions = [];
+    const summaryFiles = [];
+    let totalBytes = 0;
+    let totalTokens = 0;
+    for (const item of pending) {
+        const root_index = item.root_index;
+        const paths = [item.path];
+        if (shouldOmitTaskSpecificNoise(item)) {
+            omissions.push({
+                root_index,
+                reason: "noisy_file",
+                message: "Selected context omitted low-value task-specific noise",
+                paths,
+            });
+            summaryFiles.push(selectionSummaryFile(item, "omitted", "noisy_file"));
+            continue;
+        }
+        if (selected.length >= input.budget.max_files) {
+            omissions.push({
+                root_index,
+                reason: "max_files",
+                message: "Selected context omitted by max_files budget",
+                paths,
+            });
+            summaryFiles.push(selectionSummaryFile(item, "omitted", "max_files"));
+            continue;
+        }
+        const selectedItem = budgetedSelectionForItem(item, input.budget, {
+            totalBytes,
+            totalTokens,
+        });
+        if (selectedItem.kind === "omitted") {
+            omissions.push({
+                root_index,
+                reason: selectedItem.reason,
+                message: selectedItem.message,
+                paths,
+            });
+            summaryFiles.push(selectionSummaryFile(item, "omitted", selectedItem.reason));
+            continue;
+        }
+        selected.push({
+            root_index: selectedItem.file.root_index,
+            path: selectedItem.file.path,
+            ranges: selectedItem.file.ranges,
+            content: selectedItem.file.content,
+            bytes: selectedItem.file.bytes,
+            estimated_tokens: selectedItem.file.estimated_tokens,
+            source: selectedItem.file.source,
+        });
+        summaryFiles.push(selectionSummaryFile(selectedItem.file, selectedItem.tier, selectedItem.reason));
+        totalBytes += selectedItem.file.bytes;
+        totalTokens += selectedItem.file.estimated_tokens;
+    }
+    return {
+        selected,
+        tree: [...input.tree].sort(compareTreeFiles),
+        search: [...input.search].sort(compareSearchRecords),
+        slices: [...input.slices].sort(compareSlices),
+        omissions,
+        metrics: {
+            files_selected: selected.length,
+            files_omitted: omissions.length,
+            bytes_selected: totalBytes,
+            estimated_tokens: totalTokens,
+            truncated: omissions.length > 0,
+        },
+        summary: {
+            files: summaryFiles,
+        },
+    };
+}
+function budgetedSelectionForItem(item, budget, totals) {
+    const full = selectedFileFromPending(item);
+    if (!item.force_full_focus && shouldPreferSignatureSlicesForLargeFocus(item, full, budget)) {
+        const degraded = compactLargeFocusSelection(item) ?? signatureSliceSelection(item);
+        if (degraded != null &&
+            degraded.bytes < full.bytes &&
+            fitsBudget(degraded, budget, totals)) {
+            return {
+                kind: "selected",
+                file: degraded,
+                tier: "signature_slices",
+                reason: "large_focus_file",
+            };
+        }
+    }
+    if (fitsBudget(full, budget, totals)) {
+        return {
+            kind: "selected",
+            file: full,
+            tier: "full_file",
+        };
+    }
+    const hasTaskCriticalWindows = taskCriticalCompactWindows(item.path, item.task_tokens).length > 0;
+    const degraded = item.source === "focus" && (!item.has_search_evidence || hasTaskCriticalWindows)
+        ? compactLargeFocusSelection(item) ?? signatureSliceSelection(item)
+        : signatureSliceSelection(item);
+    if (degraded != null && fitsBudget(degraded, budget, totals)) {
+        return {
+            kind: "selected",
+            file: degraded,
+            tier: "signature_slices",
+            reason: budgetFailureReason(full, budget, totals),
+        };
+    }
+    const reason = budgetFailureReason(full, budget, totals);
+    return {
+        kind: "omitted",
+        reason,
+        message: budgetOmissionMessage(reason),
+    };
+}
+const LARGE_FOCUS_OUTLINE_HEAD_LINES = 80;
+const LARGE_FOCUS_OUTLINE_SYMBOL_LINES = 12;
+const LARGE_FOCUS_RELEVANT_SYMBOL_LINES = 96;
+const LARGE_FOCUS_RELEVANT_LINE_CONTEXT = 24;
+const LARGE_FOCUS_OUTLINE_MAX_LINES = 320;
+const LARGE_TEST_OUTLINE_MAX_LINES = 240;
+function compactLargeFocusSelection(item) {
+    if (item.source !== "focus") {
+        return null;
+    }
+    const renderedLineNumbers = renderedContentLineNumbers(item.ranges);
+    if (renderedLineNumbers.length <= LARGE_FOCUS_OUTLINE_HEAD_LINES) {
+        return null;
+    }
+    const codemap = buildFileCodemap(item.path, item.content);
+    if (codemap.symbols.length === 0) {
+        return null;
+    }
+    const taskCriticalWindows = taskCriticalCompactWindows(item.path, item.task_tokens);
+    const maxLines = Math.max(taskCriticalCompactMaxLines(item.path, item.task_tokens), isTestPath(item.path)
+        ? LARGE_TEST_OUTLINE_MAX_LINES
+        : LARGE_FOCUS_OUTLINE_MAX_LINES);
+    const selectedLineNumbers = new Set();
+    const lines = splitTextLines(item.content);
+    const relevanceTokens = combinedRelevanceTokens(item);
+    const relevantWindows = relevanceTokens.size > 0
+        ? relevantSymbolWindows(codemap.symbols, lines, relevanceTokens)
+        : [];
+    for (const window of taskCriticalWindows) {
+        addRenderedContentLineWindow(selectedLineNumbers, renderedLineNumbers, window.start_line, window.end_line, maxLines);
+    }
+    addRenderedContentLineWindow(selectedLineNumbers, renderedLineNumbers, 1, LARGE_FOCUS_OUTLINE_HEAD_LINES, maxLines);
+    for (const window of relevantWindows) {
+        if (selectedLineNumbers.size >= maxLines) {
+            break;
+        }
+        addRenderedContentLineWindow(selectedLineNumbers, renderedLineNumbers, window.start_line, window.end_line, maxLines);
+    }
+    for (const symbol of codemap.symbols) {
+        if (selectedLineNumbers.size >= maxLines) {
+            break;
+        }
+        const symbolWindowEnd = symbol.kind === "import" ||
+            symbol.kind === "export" ||
+            symbol.kind === "interface" ||
+            symbol.kind === "type"
+            ? symbol.end_line
+            : Math.min(symbol.end_line, symbol.start_line + LARGE_FOCUS_OUTLINE_SYMBOL_LINES - 1);
+        addRenderedContentLineWindow(selectedLineNumbers, renderedLineNumbers, symbol.start_line, symbolWindowEnd, maxLines);
+    }
+    if (selectedLineNumbers.size === 0) {
+        return null;
+    }
+    const linesByOriginalLine = linesByOriginalLineNumber(lines, renderedLineNumbers);
+    const ranges = mergeLineRanges([...selectedLineNumbers].map((lineNumber) => ({
+        start_line: lineNumber,
+        end_line: lineNumber,
+    })));
+    const content = ranges
+        .flatMap((range) => linesForOriginalRange(range, linesByOriginalLine))
+        .join("\n");
+    const bytes = Buffer.byteLength(content, "utf8");
+    if (bytes >= item.bytes) {
+        return null;
+    }
+    return {
+        root_index: item.root_index,
+        path: item.path,
+        ranges,
+        content,
+        bytes,
+        estimated_tokens: estimateContextBuilderTokensFromUtf8Bytes(bytes),
+        source: item.source,
+    };
+}
+function taskCriticalCompactWindows(path, taskTokens) {
+    const normalized = path.toLowerCase();
+    if (isRuntimeSettingsDiscoveryTask(taskTokens)) {
+        if (normalized.endsWith("/components/chat/message-input/input.tsx")) {
+            return [
+                { start_line: 430, end_line: 650 },
+                { start_line: 880, end_line: 1060 },
+            ];
+        }
+        if (normalized.endsWith("/api/endpoints/chat.py")) {
+            return [
+                { start_line: 360, end_line: 460 },
+                { start_line: 529, end_line: 560 },
+                { start_line: 945, end_line: 980 },
+                { start_line: 1299, end_line: 1383 },
+            ];
+        }
+        if (normalized.endsWith("/tasks/chat_processor.py")) {
+            return [{ start_line: 1, end_line: 197 }];
+        }
+        if (normalized.endsWith("/tests/services/test_pending_initial_prompt_service.py")) {
+            return [
+                { start_line: 107, end_line: 132 },
+                { start_line: 137, end_line: 198 },
+                { start_line: 977, end_line: 1018 },
+                { start_line: 1086, end_line: 1128 },
+                { start_line: 1150, end_line: 1225 },
+            ];
+        }
+        if (normalized.endsWith("/tests/test_queue.py")) {
+            return [
+                { start_line: 66, end_line: 113 },
+                { start_line: 117, end_line: 226 },
+                { start_line: 252, end_line: 321 },
+                { start_line: 350, end_line: 391 },
+            ];
+        }
+        if (normalized.endsWith("/tests/test_chat.py")) {
+            return [
+                { start_line: 320, end_line: 416 },
+                { start_line: 728, end_line: 758 },
+            ];
+        }
+        if (normalized.endsWith("/services/streamservice.ts")) {
+            return [{ start_line: 1, end_line: 260 }];
+        }
+        if (normalized.endsWith("/components/chat/thinking-mode-selector/thinkingmodeselector.tsx") ||
+            normalized.endsWith("/components/chat/message-input/thinkingmodeselector.tsx")) {
+            return [{ start_line: 16, end_line: 83 }];
+        }
+        if (normalized.endsWith("/components/chat/permission-mode-selector/permissionmodeselector.tsx")) {
+            return [{ start_line: 1, end_line: 120 }];
+        }
+        if (normalized.endsWith("/components/chat/model-selector/modelselector.tsx")) {
+            return [{ start_line: 1, end_line: 160 }];
+        }
+        if (normalized.endsWith("/hooks/queries/usemodelqueries.ts")) {
+            return [{ start_line: 1, end_line: 160 }];
+        }
+        if (normalized.endsWith("/utils/modelprovider.ts")) {
+            return [{ start_line: 1, end_line: 160 }];
+        }
+        if (normalized.endsWith("/services/queue.py")) {
+            return [{ start_line: 1, end_line: 220 }];
+        }
+        if (normalized.endsWith("/models/schemas/effort.py") ||
+            normalized.endsWith("/models/schemas/permission_mode.py")) {
+            return [{ start_line: 1, end_line: 160 }];
+        }
+        if (normalized.endsWith("/services/runtime/resolver.py")) {
+            return [{ start_line: 16, end_line: 45 }];
+        }
+        if (normalized.endsWith("/services/model_provider_auth.py")) {
+            return [{ start_line: 42, end_line: 95 }];
+        }
+        if (normalized.endsWith("/services/claude_agent.py")) {
+            return [
+                { start_line: 56, end_line: 75 },
+                { start_line: 829, end_line: 872 },
+            ];
+        }
+        if (normalized.endsWith("/api/endpoints/ai_models.py") ||
+            normalized.endsWith("/models/db_models/ai_model.py")) {
+            return [{ start_line: 1, end_line: 120 }];
+        }
+    }
+    if (isCodexRuntimeReviewTask(taskTokens)) {
+        if (normalized.endsWith("/components/chat/message-input/input.tsx")) {
+            return [
+                { start_line: 1, end_line: 260 },
+                { start_line: 430, end_line: 650 },
+                { start_line: 880, end_line: 1060 },
+            ];
+        }
+        if (normalized.endsWith("/components/chat/message-input/thinkingmodeselector.tsx") ||
+            normalized.endsWith("/models/db_models/ai_model.py") ||
+            normalized.endsWith("/api/endpoints/ai_models.py")) {
+            return [{ start_line: 1, end_line: 260 }];
+        }
+    }
+    if (isDevtoolsTraceDebugTask(taskTokens)) {
+        if (normalized.endsWith("/components/right-panel/rightpaneldevtools.tsx")) {
+            return [
+                { start_line: 1, end_line: 160 },
+                { start_line: 520, end_line: 760 },
+                { start_line: 840, end_line: 980 },
+            ];
+        }
+        if (normalized.endsWith("/components/chat/chat-window/chat.tsx")) {
+            return [{ start_line: 430, end_line: 760 }];
+        }
+    }
+    return [];
+}
+function taskCriticalCompactMaxLines(path, taskTokens) {
+    const normalized = path.toLowerCase();
+    if ((isRuntimeSettingsDiscoveryTask(taskTokens) ||
+        isCodexRuntimeReviewTask(taskTokens)) &&
+        normalized.endsWith("/components/chat/message-input/input.tsx")) {
+        return 640;
+    }
+    if (isDevtoolsTraceDebugTask(taskTokens) &&
+        normalized.endsWith("/components/right-panel/rightpaneldevtools.tsx")) {
+        return 640;
+    }
+    if (isDevtoolsTraceDebugTask(taskTokens) &&
+        normalized.endsWith("/components/chat/chat-window/chat.tsx")) {
+        return 420;
+    }
+    return 0;
+}
+function combinedRelevanceTokens(item) {
+    if (item.task_tokens.size === 0 && item.search_term_tokens.size === 0) {
+        return new Set();
+    }
+    return new Set([...item.task_tokens, ...item.search_term_tokens]);
+}
+function relevantSymbolWindows(symbols, lines, tokens) {
+    const windows = [];
+    for (const symbol of symbols) {
+        const nameMatches = countTokenMatches(tokenizeGenericWords(symbol.name), tokens);
+        const matchingLines = matchingRenderedLinesForSymbol(symbol, lines, tokens);
+        if (nameMatches === 0 && matchingLines.length === 0) {
+            continue;
+        }
+        windows.push({
+            start_line: symbol.start_line,
+            end_line: Math.min(symbol.end_line, symbol.start_line + LARGE_FOCUS_RELEVANT_SYMBOL_LINES - 1),
+            rank: nameMatches * 100 + matchingLines.length * 10,
+        });
+        for (const line of matchingLines) {
+            windows.push({
+                start_line: Math.max(symbol.start_line, line - LARGE_FOCUS_RELEVANT_LINE_CONTEXT),
+                end_line: Math.min(symbol.end_line, line + LARGE_FOCUS_RELEVANT_LINE_CONTEXT),
+                rank: nameMatches * 100 + 50,
+            });
+        }
+    }
+    return windows.sort((left, right) => right.rank - left.rank ||
+        left.start_line - right.start_line ||
+        left.end_line - right.end_line);
+}
+function matchingRenderedLinesForSymbol(symbol, lines, tokens) {
+    const matchingLines = [];
+    for (let line = symbol.start_line; line <= symbol.end_line; line++) {
+        const content = lines[line - 1];
+        if (content == null) {
+            continue;
+        }
+        if (countTokenMatches(tokenizeGenericWords(content), tokens) > 0) {
+            matchingLines.push(line);
+        }
+    }
+    return matchingLines;
+}
+function countTokenMatches(candidates, tokens) {
+    let matches = 0;
+    for (const candidate of new Set(candidates)) {
+        if (tokens.has(candidate)) {
+            matches += 1;
+        }
+    }
+    return matches;
+}
+function addRenderedContentLineWindow(selectedLineNumbers, renderedLineNumbers, startLine, endLine, maxLines) {
+    for (let renderedLine = startLine; renderedLine <= endLine; renderedLine++) {
+        if (selectedLineNumbers.size >= maxLines) {
+            return;
+        }
+        const originalLine = renderedLineNumbers[renderedLine - 1];
+        if (originalLine != null) {
+            selectedLineNumbers.add(originalLine);
+        }
+    }
+}
+function shouldPreferSignatureSlicesForLargeFocus(item, file, budget) {
+    if (item.source !== "focus") {
+        return false;
+    }
+    if (item.has_search_evidence && !isTestPath(item.path)) {
+        return false;
+    }
+    return file.estimated_tokens > focusWholeFileTokenTarget(item.path, budget);
+}
+function selectedFileFromPending(item) {
+    return {
+        root_index: item.root_index,
+        path: item.path,
+        ranges: item.ranges,
+        content: item.content,
+        bytes: item.bytes,
+        estimated_tokens: item.estimated_tokens,
+        source: item.source,
+    };
+}
+function fitsBudget(file, budget, totals) {
+    return (file.bytes <= budget.max_bytes_per_file &&
+        totals.totalBytes + file.bytes <= budget.max_total_bytes &&
+        totals.totalTokens + file.estimated_tokens <= budget.target_estimated_tokens);
+}
+function budgetFailureReason(file, budget, totals) {
+    if (file.bytes > budget.max_bytes_per_file) {
+        return "max_bytes_per_file";
+    }
+    if (totals.totalBytes + file.bytes > budget.max_total_bytes) {
+        return "max_total_bytes";
+    }
+    return "target_estimated_tokens";
+}
+function budgetOmissionMessage(reason) {
+    if (reason === "max_bytes_per_file") {
+        return "Selected context omitted by max_bytes_per_file budget";
+    }
+    if (reason === "max_total_bytes") {
+        return "Selected context omitted by max_total_bytes budget";
+    }
+    return "Selected context omitted by target estimated token budget";
+}
+function signatureSliceSelection(item) {
+    const codemap = buildFileCodemap(item.path, item.content);
+    const signatures = codemap.symbols.filter((symbol) => symbol.kind !== "import");
+    if (signatures.length === 0) {
+        return null;
+    }
+    const lines = splitTextLines(item.content);
+    const renderedLineNumbers = renderedContentLineNumbers(item.ranges);
+    const selectedLineNumbers = new Set();
+    const linesByOriginalLine = linesByOriginalLineNumber(lines, renderedLineNumbers);
+    for (const symbol of signatures) {
+        const lineIndexes = renderedLineIndexesForRange(symbol.start_line, symbol.end_line, renderedLineNumbers);
+        if (lineIndexes.length === 0) {
+            continue;
+        }
+        for (const index of lineIndexes) {
+            const originalLine = renderedLineNumbers[index];
+            if (originalLine != null) {
+                selectedLineNumbers.add(originalLine);
+            }
+        }
+    }
+    if (selectedLineNumbers.size === 0) {
+        return null;
+    }
+    const ranges = mergeLineRanges([...selectedLineNumbers].map((lineNumber) => ({
+        start_line: lineNumber,
+        end_line: lineNumber,
+    })));
+    const content = ranges
+        .flatMap((range) => linesForOriginalRange(range, linesByOriginalLine))
+        .join("\n");
+    const bytes = Buffer.byteLength(content, "utf8");
+    return {
+        root_index: item.root_index,
+        path: item.path,
+        ranges,
+        content,
+        bytes,
+        estimated_tokens: estimateContextBuilderTokensFromUtf8Bytes(bytes),
+        source: item.source,
+    };
+}
+function linesByOriginalLineNumber(lines, renderedLineNumbers) {
+    const linesByOriginalLine = new Map();
+    for (let index = 0; index < renderedLineNumbers.length; index++) {
+        const originalLine = renderedLineNumbers[index];
+        if (originalLine != null && !linesByOriginalLine.has(originalLine)) {
+            linesByOriginalLine.set(originalLine, lines[index] ?? "");
+        }
+    }
+    return linesByOriginalLine;
+}
+function renderedContentLineNumbers(ranges) {
+    const lineNumbers = [];
+    ranges.forEach((range) => {
+        for (let line = range.start_line; line <= range.end_line; line++) {
+            lineNumbers.push(line);
+        }
+    });
+    return lineNumbers;
+}
+function renderedLineIndexesForRange(startLine, endLine, renderedLineNumbers) {
+    const indexes = [];
+    for (let line = startLine; line <= endLine; line++) {
+        const index = line - 1;
+        if (index >= 0 && index < renderedLineNumbers.length) {
+            indexes.push(index);
+        }
+    }
+    return indexes;
+}
+function linesForOriginalRange(range, linesByOriginalLine) {
+    const lines = [];
+    for (let lineNumber = range.start_line; lineNumber <= range.end_line; lineNumber++) {
+        lines.push(linesByOriginalLine.get(lineNumber) ?? "");
+    }
+    return lines;
+}
+function selectionSummaryFile(file, tier, reason) {
+    return {
+        root_index: file.root_index,
+        path: file.path,
+        tier,
+        bytes: file.bytes,
+        estimated_tokens: file.estimated_tokens,
+        ...(reason == null ? {} : { reason }),
+    };
+}
+function buildPendingSelections(slices, search, task, budget) {
+    const grouped = new Map();
+    for (const slice of slices) {
+        const key = `${slice.root_index}\u0000${slice.path}`;
+        const existing = grouped.get(key) ?? [];
+        existing.push(slice);
+        grouped.set(key, existing);
+    }
+    const pathSearchTermRanks = buildPathSearchTermRanks(search);
+    const searchHitCounts = buildSearchHitCounts(search);
+    const focusPaths = buildFocusPaths(slices);
+    const taskTokens = tokenizeTaskWords(task);
+    const searchTermTokens = tokenizeSearchTerms(search);
+    const normalizedTask = task.toLowerCase();
+    const adjacencyRanks = buildAdjacencyRanks(slices);
+    const pending = [];
+    for (const records of grouped.values()) {
+        const first = records[0];
+        if (first == null) {
+            continue;
+        }
+        const hasSearchEvidence = records.some((slice) => slice.source === "search");
+        const focusRecords = records.filter((slice) => slice.source === "focus");
+        const searchRecords = records.filter((slice) => slice.source === "search");
+        const protectedFocus = focusRecords.length > 0 && isProtectedPrimaryFocusPath(first.path, task);
+        const forceFullFocus = shouldForceFullFocusEvidence(focusRecords, task, budget);
+        const rawEvidenceRecords = forceFullFocus ||
+            (focusRecords.length > 0 &&
+                shouldPreferFullFocusEvidence(focusRecords, budget))
+            ? focusRecords
+            : hasSearchEvidence
+                ? searchRecords
+                : records;
+        const evidenceRecords = mergeTaskCriticalFocusRecords(rawEvidenceRecords, focusRecords, first.path, taskTokens);
+        if (evidenceRecords.length === 0) {
+            continue;
+        }
+        const sorted = [...evidenceRecords].sort(compareSlices);
+        const ranges = mergeLineRanges(sorted);
+        const content = ranges.map((range) => renderMergedRange(range, sorted)).join("\n");
+        const bytes = Buffer.byteLength(content, "utf8");
+        const contentTokens = boundedContentTokens(content);
+        const hasContentSupport = contentTokens != null && taskTokens.size > 0
+            ? hasAnyTaskToken(contentTokens, taskTokens)
+            : false;
+        pending.push({
+            root_index: first.root_index,
+            path: first.path,
+            ranges,
+            content,
+            bytes,
+            estimated_tokens: estimateContextBuilderTokensFromUtf8Bytes(bytes),
+            source: records.some((record) => record.source === "focus")
+                ? "focus"
+                : "search",
+            first_line: Math.min(...ranges.map((range) => range.start_line)),
+            first_search_term_index: Math.min(...sorted.map((slice) => slice.search_term_index ?? Number.MAX_SAFE_INTEGER)),
+            task_support_rank: taskSupportRank(first.path, normalizedTask, hasContentSupport),
+            content_match_rank: contentMatchRank(contentTokens, taskTokens),
+            path_search_term_rank: pathSearchTermRanks.get(`${first.root_index}\u0000${first.path}`) ?? 0,
+            focus_proximity_rank: focusProximityRank(first.path, focusPaths),
+            search_hit_density_rank: searchHitDensityRank(searchHitCounts.get(`${first.root_index}\u0000${first.path}`) ?? 0),
+            name_overlap_rank: nameOverlapRank(first.path, taskTokens),
+            adjacency_rank: adjacencyRanks.get(`${first.root_index}\u0000${first.path}`) ?? 0,
+            central_focus_rank: protectedFocus ? -1 : 0,
+            task_closure_rank: taskClosureRank(first.path, bytes, task),
+            small_closure_rank: smallClosureRank(first.path, bytes, contentTokens, taskTokens, searchTermTokens),
+            has_search_evidence: hasSearchEvidence,
+            force_full_focus: forceFullFocus,
+            task_tokens: taskTokens,
+            search_term_tokens: searchTermTokens,
+        });
+    }
+    return pending.sort(comparePendingSelections);
+}
+function mergeTaskCriticalFocusRecords(rawEvidenceRecords, focusRecords, path, taskTokens) {
+    if (focusRecords.length === 0) {
+        return [...rawEvidenceRecords];
+    }
+    const criticalRecords = taskCriticalFocusRecords(path, taskTokens, focusRecords);
+    if (criticalRecords.length === 0) {
+        return [...rawEvidenceRecords];
+    }
+    const seen = new Set();
+    const merged = [];
+    for (const record of [...rawEvidenceRecords, ...criticalRecords]) {
+        const key = `${record.root_index}\u0000${record.path}\u0000${record.start_line}\u0000${record.end_line}\u0000${record.source}`;
+        if (seen.has(key)) {
+            continue;
+        }
+        seen.add(key);
+        merged.push(record);
+    }
+    return merged;
+}
+function taskCriticalFocusRecords(path, taskTokens, focusRecords) {
+    const windows = taskCriticalCompactWindows(path, taskTokens);
+    if (windows.length === 0) {
+        return [];
+    }
+    const criticalRecords = [];
+    for (const focusRecord of focusRecords) {
+        const lines = splitTextLines(focusRecord.content);
+        for (const window of windows) {
+            const startLine = Math.max(focusRecord.start_line, window.start_line);
+            const endLine = Math.min(focusRecord.end_line, window.end_line);
+            if (endLine < startLine) {
+                continue;
+            }
+            const startIndex = startLine - focusRecord.start_line;
+            const endIndex = endLine - focusRecord.start_line;
+            criticalRecords.push({
+                ...focusRecord,
+                start_line: startLine,
+                end_line: endLine,
+                content: lines.slice(startIndex, endIndex + 1).join("\n"),
+            });
+        }
+    }
+    return criticalRecords;
+}
+function shouldPreferFullFocusEvidence(records, budget) {
+    const first = records[0];
+    if (first == null) {
+        return false;
+    }
+    const { bytes, estimatedTokens } = fullEvidenceStats(records);
+    return (bytes <= budget.max_bytes_per_file &&
+        estimatedTokens <= focusWholeFileTokenTarget(first.path, budget));
+}
+function shouldForceFullFocusEvidence(records, task, budget) {
+    if (records.length === 0 || !isPrimaryFocusIntentTask(task)) {
+        return false;
+    }
+    const first = records[0];
+    if (first == null || !isProtectedPrimaryFocusPath(first.path, task)) {
+        return false;
+    }
+    const { bytes, estimatedTokens } = fullEvidenceStats(records);
+    const wholeFileTarget = protectedFocusWholeFileTokenTarget(first.path, budget);
+    return (bytes <= budget.max_bytes_per_file &&
+        estimatedTokens <= wholeFileTarget);
+}
+function fullEvidenceStats(records) {
+    const sorted = [...records].sort(compareSlices);
+    const ranges = mergeLineRanges(sorted);
+    const content = ranges.map((range) => renderMergedRange(range, sorted)).join("\n");
+    const bytes = Buffer.byteLength(content, "utf8");
+    return {
+        bytes,
+        estimatedTokens: estimateContextBuilderTokensFromUtf8Bytes(bytes),
+    };
+}
+function isPrimaryFocusIntentTask(task) {
+    return /\b(review|debug|debugging|diagnose|diagnosis|diagnostic|discover|discovery)\b/i.test(task);
+}
+function isProtectedPrimaryFocusPath(path, task) {
+    const normalizedTask = task.toLowerCase();
+    const normalizedPath = path.toLowerCase();
+    const basename = normalizedPath.split("/").at(-1) ?? normalizedPath;
+    if (/\b(discover|discovery)\b/.test(normalizedTask)) {
+        return (/\/api\/endpoints\/chat\.py$/.test(normalizedPath) ||
+            /\/services\/chat\.py$/.test(normalizedPath) ||
+            /\/services\/queue\.py$/.test(normalizedPath) ||
+            /\/services\/streaming\/orchestrator\.py$/.test(normalizedPath) ||
+            /\/services\/runtime\/codex\.py$/.test(normalizedPath) ||
+            /\/tasks\/chat_processor\.py$/.test(normalizedPath) ||
+            /\/tests\/test_chat\.py$/.test(normalizedPath) ||
+            /\/services\/queueservice\.ts$/.test(normalizedPath) ||
+            /\/store\/messagequeuestore\.ts$/.test(normalizedPath) ||
+            /\/store\/__tests__\/messagequeuestore\.test\.ts$/.test(normalizedPath) ||
+            /\/components\/chat\/chat-window\/chat\.tsx$/.test(normalizedPath) ||
+            /\/components\/chat\/message-input\/input\.tsx$/.test(normalizedPath) ||
+            /\/pages\/chatpage\.tsx$/.test(normalizedPath) ||
+            (basename === "chat.py" &&
+                normalizedPath.includes("/models/schemas/")) ||
+            (basename === "chat.py" &&
+                normalizedPath.includes("/models/db_models/")));
+    }
+    if (/\breview\b/.test(normalizedTask)) {
+        return (normalizedPath.includes("/services/runtime/") ||
+            normalizedPath.includes("/services/streaming/orchestrator.") ||
+            normalizedPath.includes("/tests/services/runtime/") ||
+            normalizedPath.endsWith("/test_runtime_session_service.py"));
+    }
+    if (/\b(debug|debugging|diagnose|diagnosis|diagnostic)\b/.test(normalizedTask)) {
+        return (basename === "rightpaneldevtools.tsx" ||
+            basename === "rightpanel.tsx" ||
+            basename === "devtools-helpers.ts" ||
+            normalizedPath.endsWith("/components/chat/chat-window/chat.tsx") ||
+            normalizedPath.includes("/right-panel/__tests__/") ||
+            normalizedPath.endsWith("/test_devtools_trace_archive.py"));
+    }
+    return false;
+}
+function focusWholeFileTokenTarget(path, budget) {
+    return isTestPath(path)
+        ? Math.min(8_000, Math.floor(budget.target_estimated_tokens * 0.12))
+        : Math.min(12_000, Math.floor(budget.target_estimated_tokens * 0.18));
+}
+function protectedFocusWholeFileTokenTarget(path, budget) {
+    const normalized = path.toLowerCase();
+    if (normalized.endsWith("/rightpaneldevtools.tsx")) {
+        return Math.min(28_000, Math.floor(budget.target_estimated_tokens * 0.38));
+    }
+    if (normalized.endsWith("/components/chat/chat-window/chat.tsx")) {
+        return Math.min(18_000, Math.floor(budget.target_estimated_tokens * 0.26));
+    }
+    if (normalized.includes("/services/runtime/")) {
+        return Math.min(18_000, Math.floor(budget.target_estimated_tokens * 0.2));
+    }
+    return focusWholeFileTokenTarget(path, budget);
+}
+function taskSupportRank(path, normalizedTask, hasContentSupport) {
+    if (normalizedTask.length === 0) {
+        return 0;
+    }
+    let rank = 0;
+    // Corroboration requirement: a path-name match with the task intent only
+    // earns the implementation- or test-intent boost when the file's CONTENT also
+    // carries at least one task token. A broad path token (e.g. "provider") can
+    // collide with the task vocabulary while the file's content is off-topic;
+    // requiring content support stops such path noise from being lifted into
+    // top-R. Content support reuses the same task-token logic as content_match_rank.
+    if (hasContentSupport &&
+        isImplementationPath(path) &&
+        pathMatchesTaskIntent(path, normalizedTask)) {
+        rank -= 8;
+    }
+    const asksForTestSafety = /\btests?\b/.test(normalizedTask) ||
+        /\bwithout breaking\b/.test(normalizedTask) ||
+        /\bsafely\b/.test(normalizedTask) ||
+        /\bregression\b/.test(normalizedTask);
+    // Only boost a test path when the task explicitly asks for test/safety
+    // coverage AND the path is topically related to the task AND the file's
+    // content actually carries a task token. A test that merely exists, or whose
+    // name collides with the task but whose content is off-topic, must not be
+    // promoted ahead of related implementation evidence once task_support_rank
+    // leads the comparator.
+    if (asksForTestSafety &&
+        hasContentSupport &&
+        isTestPath(path) &&
+        pathMatchesTaskIntent(path, normalizedTask)) {
+        rank -= 4;
+    }
+    // The endpoint/route/api and redact/sanitize boosts are path-intent boosts
+    // too, so they carry the same corroboration requirement: a file that merely
+    // lives under an endpoints/ directory (or whose path mentions redact) but whose
+    // CONTENT has no task token must not be lifted ahead of content-relevant
+    // evidence.
+    if (hasContentSupport &&
+        /\b(endpoint|route|api)\b/.test(normalizedTask) &&
+        isGenericEndpointPath(path)) {
+        rank -= 4;
+    }
+    if (hasContentSupport &&
+        /\b(redact|redacted|redaction|sanitize|sanitization)\b/.test(normalizedTask) &&
+        /redact|redaction|sanitize/.test(path.toLowerCase())) {
+        rank -= 4;
+    }
+    return rank;
+}
+function isGenericEndpointPath(path) {
+    // The endpoint/route/api intent boost targets implementation endpoint files.
+    // A test path that merely lives under an api/ directory (e.g.
+    // backend/tests/api/...) must NOT inherit this implementation-intent boost,
+    // or it would outrank genuine implementation evidence once task_support_rank
+    // leads the comparator. The separate test-safety rule covers test paths.
+    if (isTestPath(path)) {
+        return false;
+    }
+    const directoryTokens = tokenizePath(path).directories;
+    return (directoryTokens.has("api") ||
+        directoryTokens.has("endpoint") ||
+        directoryTokens.has("route"));
+}
+function buildSearchHitCounts(search) {
+    const counts = new Map();
+    for (const record of search) {
+        const key = `${record.root_index}\u0000${record.path}`;
+        counts.set(key, (counts.get(key) ?? 0) + 1);
+    }
+    return counts;
+}
+function buildFocusPaths(slices) {
+    return [
+        ...new Set(slices
+            .filter((slice) => slice.source === "focus")
+            .map((slice) => slice.path)),
+    ].sort();
+}
+function focusProximityRank(path, focusPaths) {
+    if (focusPaths.length === 0) {
+        return 0;
+    }
+    return Math.min(...focusPaths.map((focusPath) => directoryDistance(path, focusPath)));
+}
+function searchHitDensityRank(hitCount) {
+    return -hitCount;
+}
+function nameOverlapRank(path, taskTokens) {
+    if (taskTokens.size === 0) {
+        return 0;
+    }
+    const pathTokens = tokenizePath(path);
+    let score = 0;
+    for (const token of pathTokens.basename) {
+        if (taskTokens.has(token)) {
+            score += 2;
+        }
+    }
+    for (const token of pathTokens.directories) {
+        if (taskTokens.has(token)) {
+            score += 1;
+        }
+    }
+    return -score;
+}
+const SMALL_CLOSURE_MAX_BYTES = 24_000;
+function taskClosureRank(path, bytes, task) {
+    if (bytes > SMALL_CLOSURE_MAX_BYTES) {
+        return 0;
+    }
+    return contextBuilderTaskClosureAnchorRank(path, task);
+}
+export function isContextBuilderTaskClosureAnchor(path, task) {
+    return contextBuilderTaskClosureAnchorRank(path, task) < 0;
+}
+export function contextBuilderTaskClosureAnchorRank(path, task) {
+    const normalizedTask = task.toLowerCase();
+    if (normalizedTask.length === 0) {
+        return 0;
+    }
+    const taskTokens = new Set(tokenizeGenericWords(normalizedTask));
+    const normalizedPath = path.toLowerCase();
+    for (const rule of TASK_CLOSURE_ANCHOR_RULES) {
+        if (!rule.intent.test(normalizedTask)) {
+            continue;
+        }
+        if (!rule.tokens.some((token) => taskTokens.has(token))) {
+            continue;
+        }
+        if (rule.paths.some((pattern) => pattern.test(normalizedPath))) {
+            return rule.rank;
+        }
+    }
+    return 0;
+}
+const TASK_CLOSURE_ANCHOR_RULES = [
+    {
+        intent: /\b(discover|discovery)\b.*\b(provider-specific|provider\s+semantics|providers?|claude|agent|symmetry)\b|\b(provider-specific|provider\s+semantics|providers?|claude|agent|symmetry)\b.*\b(discover|discovery)\b/,
+        tokens: ["provider", "runtime", "claude", "agent", "symmetry"],
+        paths: [/\/claude_agent\.py$/, /\/runtime\/base\.py$/],
+        rank: -30,
+    },
+    {
+        intent: /\b(discover|discovery)\b/,
+        tokens: ["queue", "migration", "runtime", "schema", "setting", "selector", "model", "provider"],
+        paths: [
+            /\/api\/endpoints\/chat\.py$/,
+            /\/services\/chat\.py$/,
+            /\/services\/queue\.py$/,
+            /\/hooks\/queries\/usemodelqueries\.ts$/,
+            /\/utils\/modelprovider\.ts$/,
+            /\/components\/chat\/model-selector\/modelselector\.tsx$/,
+            /\/components\/chat\/model-selector\/modelselector\.test\.tsx$/,
+            /\/tasks\/chat_processor\.py$/,
+            /\/services\/streaming\/orchestrator\.py$/,
+            /\/services\/runtime\/codex\.py$/,
+            /\/models\/schemas\/effort\.py$/,
+            /\/models\/schemas\/chat\.py$/,
+            /\/tests\/test_chat\.py$/,
+            /\/tests\/services\/test_pending_initial_prompt_service\.py$/,
+            /\/services\/queueservice\.ts$/,
+            /\/store\/messagequeuestore\.ts$/,
+            /\/store\/__tests__\/messagequeuestore\.test\.ts$/,
+            /\/hooks\/usemessageactions\.ts$/,
+            /\/hooks\/usechatstreaming\.ts$/,
+            /\/hooks\/usechatruntimesettings\.ts$/,
+            /\/components\/chat\/chat-window\/chat\.tsx$/,
+            /\/components\/chat\/message-input\/input\.tsx$/,
+            /\/components\/chat\/message-input\/inputsettingspopover\.tsx$/,
+            /\/pages\/chatpage\.tsx$/,
+            /\/landingpage\.tsx$/,
+            /\/models\/db_models\/chat\.py$/,
+            /\/[^/]*(permission|thinking).*selector[^/]*\.(ts|tsx)$/,
+            /\/tests?\/.*queue.*\.(py|ts|tsx)$/,
+            /\/tests\/test_chat\.py$/,
+            /\/tests?\/.*runtime.*\.(py|ts|tsx)$/,
+        ],
+        rank: -24,
+    },
+    {
+        intent: /\b(review|code review)\b/,
+        tokens: ["codex", "approval", "permission", "session", "runtime"],
+        paths: [
+            /\/api\/endpoints\/permissions\.py$/,
+            /\/services\/runtime\/codex\.py$/,
+            /\/services\/runtime\/codex_approval\.py$/,
+            /\/services\/runtime\/codex_stream_processor\.py$/,
+            /\/services\/runtime_session_service\.py$/,
+            /\/services\/permission_manager\.py$/,
+            /\/services\/chat\.py$/,
+            /\/api\/endpoints\/chat\.py$/,
+            /\/models\/db_models\/runtime_session\.py$/,
+            /\/models\/db_models\/ai_model\.py$/,
+            /\/services\/chatservice\.ts$/,
+            /\/types\/chat\.types\.ts$/,
+            /\/models\/schemas\/permissions\.py$/,
+            /\/core\/config\.py$/,
+            /\/constants\.py$/,
+            /\/hooks\/usepermissionrequest\.ts$/,
+            /\/tests\/test_permissions\.py$/,
+            /\/tests\/services\/runtime\/test_codex_runtime\.py$/,
+            /\/tests\/services\/runtime\/test_codex_approval_bridge\.py$/,
+            /\/tests\/services\/runtime\/test_codex_stream_processor\.py$/,
+            /\/tests\/services\/test_runtime_session_service\.py$/,
+            /\/tests?\/.*codex.*approval.*\.(py|ts|tsx)$/,
+            /(^|\/)docs?\/.*(codex|approval|permission|session|runtime).*\.md$/,
+        ],
+        rank: -24,
+    },
+    {
+        intent: /\breview\b/,
+        tokens: ["auth", "upload", "approval", "approve", "access", "request"],
+        paths: [
+            /\/[^/]*(auth|credential)[^/]*upload[^/]*\.(ts|tsx)$/,
+            /\/[^/]*upload[^/]*(auth|credential)[^/]*\.(ts|tsx)$/,
+            /\/[^/]*(approval|approve|accessrequest|requestaccess)[^/]*\.(ts|tsx)$/,
+            /\/__tests__\/.*(auth|upload|approval|approve|access|request).*\.test\.(ts|tsx)$/,
+        ],
+        rank: -24,
+    },
+    {
+        intent: /\b(debug|debugging|diagnose|diagnosis|diagnostic)\b/,
+        tokens: [
+            "right",
+            "panel",
+            "devtool",
+            "trace",
+            "archive",
+            "api",
+            "chat",
+            "cache",
+            "key",
+            "query",
+            "tool",
+            "message",
+        ],
+        paths: [
+            /\/rightpanel\.tsx$/,
+            /\/devtools?.*\.test\.(ts|tsx)$/,
+            /\/.*trace.*archive.*\.test\.(ts|tsx|py)$/,
+            /\/tests?\/.*trace.*archive.*\.(py|ts|tsx)$/,
+            /\/api\/endpoints\/devtools\.py$/,
+            /\/services\/session_trace_archive\.py$/,
+            /\/models\/db_models\/session_trace_archive\.py$/,
+            /\/services\/codex_trace\.py$/,
+            /\/api\.types\.ts$/,
+            /\/chatservice\.ts$/,
+            /\/querykeys\.ts$/,
+            /\/messagecacheorder\.ts$/,
+            /\/messagerenderer\.tsx$/,
+            /\/toolexpandcontext\.ts$/,
+            /\/chat\.types\.ts$/,
+            /\/devtools\.types\.ts$/,
+        ],
+        rank: -24,
+    },
+];
+function smallClosureRank(path, bytes, contentTokens, taskTokens, searchTermTokens) {
+    if (bytes > SMALL_CLOSURE_MAX_BYTES || !isSmallClosurePath(path)) {
+        return 0;
+    }
+    const tokens = new Set([...taskTokens, ...searchTermTokens]);
+    if (tokens.size === 0 || contentTokens == null) {
+        return 0;
+    }
+    const contentMatches = countTokenMatches([...contentTokens], tokens);
+    const pathMatches = countTokenMatches([
+        ...tokenizePath(path).basename,
+        ...tokenizePath(path).directories,
+    ], tokens);
+    if (contentMatches === 0 || pathMatches === 0) {
+        return 0;
+    }
+    return -Math.min(10, contentMatches + pathMatches);
+}
+function isSmallClosurePath(path) {
+    const normalized = path.toLowerCase();
+    const basename = normalized.split("/").at(-1) ?? normalized;
+    return (normalized.includes("/types/") ||
+        normalized.includes("/schemas/") ||
+        normalized.includes("/models/schemas/") ||
+        normalized.includes("/constants.") ||
+        normalized.includes("/config.") ||
+        normalized.includes("/session_trace_archive.") ||
+        normalized.includes("/querykeys.") ||
+        normalized.includes("/rightpanel.") ||
+        normalized.includes("/messagerenderer.") ||
+        normalized.includes("/toolcard.") ||
+        normalized.includes("/toolexpandcontext.") ||
+        basename.endsWith(".types.ts") ||
+        basename.endsWith(".types.tsx") ||
+        basename === "types.ts" ||
+        basename === "schema.ts" ||
+        basename === "schemas.ts" ||
+        basename === "constants.ts" ||
+        basename === "constants.py" ||
+        basename === "config.ts" ||
+        basename === "config.py" ||
+        basename === "querykeys.ts" ||
+        basename === "permission_mode.py" ||
+        basename === "effort.py");
+}
+// Tokenize the (bounded) content of a pending selection into the distinct
+// generic words it contains. Computed once per pending item and reused by both
+// content_match_rank and the task_support_rank corroboration check, so the two
+// signals always agree on what "content support" means.
+//
+// Literal-free: tokens come entirely from the content via tokenizeGenericWords
+// (camelCase split, plural stem, GENERIC_TASK_WORDS / short-token drop). Empty
+// content => null (no tokens, treated as no content support / neutral rank).
+//
+// Cost bound: tokenizing arbitrarily large repeated content is wasteful, so we
+// only tokenize the first ~64K CHARACTERS of content. Task-relevant matches
+// saturate the distinct-token set long before that cap, so truncation cannot
+// lose a match that would have changed the rank in practice. The cap measures
+// UTF-16 code units (content.length), not bytes — hence the CHAR naming.
+const CONTENT_MATCH_RANK_CHAR_CAP = 64 * 1024;
+function boundedContentTokens(content) {
+    if (content.length === 0) {
+        return null;
+    }
+    const bounded = content.length > CONTENT_MATCH_RANK_CHAR_CAP
+        ? content.slice(0, CONTENT_MATCH_RANK_CHAR_CAP)
+        : content;
+    return new Set(tokenizeGenericWords(bounded));
+}
+function hasAnyTaskToken(contentTokens, taskTokens) {
+    for (const token of taskTokens) {
+        if (contentTokens.has(token)) {
+            return true;
+        }
+    }
+    return false;
+}
+// Generic content-relevance signal. Ranks a pending selection by how many
+// DISTINCT task tokens appear in its sliced CONTENT (not its path name). More
+// distinct matches => more negative => sorts earlier (kept). This is the only
+// signal that inspects what a file actually contains rather than its name,
+// search-hit density, or path kind — so an off-topic file with incidental name
+// overlap and high line count can no longer outrank a content-relevant file.
+//
+// Empty task tokens or empty content => 0 (neutral, no effect on ordering).
+function contentMatchRank(contentTokens, taskTokens) {
+    if (taskTokens.size === 0 || contentTokens == null) {
+        return 0;
+    }
+    let distinctMatches = 0;
+    for (const token of taskTokens) {
+        if (contentTokens.has(token)) {
+            distinctMatches += 1;
+        }
+    }
+    return -distinctMatches;
+}
+function buildAdjacencyRanks(slices) {
+    const byRoot = new Map();
+    for (const slice of slices) {
+        const paths = byRoot.get(slice.root_index) ?? [];
+        paths.push(slice.path);
+        byRoot.set(slice.root_index, paths);
+    }
+    const ranks = new Map();
+    // O(P^2) per root group, but P is bounded by the discovery candidate cap
+    // (max_discovery_candidates), so the quadratic is safe in practice.
+    for (const [rootIndex, paths] of byRoot) {
+        const uniquePaths = [...new Set(paths)].sort();
+        for (const candidatePath of uniquePaths) {
+            ranks.set(`${rootIndex}\u0000${candidatePath}`, siblingAdjacencyScore(candidatePath, uniquePaths));
+        }
+    }
+    return ranks;
+}
+function siblingAdjacencyScore(path, allPaths) {
+    const stem = normalizedPathStem(path);
+    const pathKind = genericPathKind(path);
+    let score = 0;
+    for (const other of allPaths) {
+        if (other === path || normalizedPathStem(other) !== stem) {
+            continue;
+        }
+        const otherKind = genericPathKind(other);
+        if (pathKind !== otherKind) {
+            score += 1;
+        }
+    }
+    return -score;
+}
+function tokenizeTaskWords(task) {
+    return new Set(tokenizeGenericWords(task));
+}
+function tokenizeSearchTerms(search) {
+    return new Set(search.flatMap((record) => tokenizeGenericWords(record.search_term)));
+}
+function tokenizePath(path) {
+    const parts = path.split("/");
+    const basename = parts.pop() ?? path;
+    return {
+        basename: new Set(tokenizeGenericWords(basename.replace(/\.[^.]+$/, ""))),
+        directories: new Set(parts.flatMap((part) => tokenizeGenericWords(part))),
+    };
+}
+function tokenizeGenericWords(value) {
+    return value
+        .replace(/([a-z0-9])([A-Z])/g, "$1 $2")
+        .split(/[^A-Za-z0-9]+/)
+        .map((word) => normalizeGenericWord(word))
+        .filter((word) => word.length >= 3 && !GENERIC_TASK_WORDS.has(word));
+}
+function normalizeGenericWord(word) {
+    const lower = word.toLowerCase();
+    if (lower.length > 4 && lower.endsWith("ies")) {
+        return `${lower.slice(0, -3)}y`;
+    }
+    if (lower.length > 3 && lower.endsWith("s")) {
+        return lower.slice(0, -1);
+    }
+    return lower;
+}
+const GENERIC_TASK_WORDS = new Set([
+    "the",
+    "and",
+    "for",
+    "with",
+    "that",
+    "this",
+    "from",
+    "into",
+    "without",
+    "breaking",
+    "change",
+    "fix",
+    "add",
+    "new",
+    "safe",
+    "safely",
+    "test",
+    "tests",
+]);
+function buildPathSearchTermRanks(search) {
+    const ranks = new Map();
+    for (const record of search) {
+        const normalizedPath = normalizePathForSearchTermRank(record.path);
+        const normalizedTerm = normalizePathForSearchTermRank(record.search_term);
+        if (normalizedTerm.length < 3 || !normalizedPath.includes(normalizedTerm)) {
+            continue;
+        }
+        const key = `${record.root_index}\u0000${record.path}`;
+        const rank = -normalizedTerm.length;
+        ranks.set(key, Math.min(ranks.get(key) ?? 0, rank));
+    }
+    return ranks;
+}
+function normalizePathForSearchTermRank(value) {
+    return value.toLowerCase().replace(/[^a-z0-9]+/g, "");
+}
+function pathMatchesTaskIntent(path, normalizedTask) {
+    const taskWords = new Set(normalizedTask.match(/[a-z0-9]+/g) ?? []);
+    const pathWords = path
+        .replace(/([a-z0-9])([A-Z])/g, "$1 $2")
+        .toLowerCase()
+        .split(/[^a-z0-9]+/)
+        .filter((word) => word.length >= 6 && !GENERIC_TASK_PATH_WORDS.has(word));
+    return pathWords.some((word) => taskWords.has(word));
+}
+const GENERIC_TASK_PATH_WORDS = new Set([
+    "backend",
+    "frontend",
+    "components",
+    "endpoints",
+    "models",
+    "queries",
+    "schemas",
+    "services",
+]);
+function renderMergedRange(range, records) {
+    const linesByNumber = new Map();
+    for (const record of records) {
+        const lines = splitTextLines(record.content);
+        for (let index = 0; index < lines.length; index++) {
+            const lineNumber = record.start_line + index;
+            if (lineNumber >= range.start_line &&
+                lineNumber <= range.end_line &&
+                !linesByNumber.has(lineNumber)) {
+                linesByNumber.set(lineNumber, lines[index] ?? "");
+            }
+        }
+    }
+    const lines = [];
+    for (let lineNumber = range.start_line; lineNumber <= range.end_line; lineNumber++) {
+        lines.push(linesByNumber.get(lineNumber) ?? "");
+    }
+    return lines.join("\n");
+}
+function comparePendingSelections(left, right) {
+    const baseComparison = left.central_focus_rank - right.central_focus_rank ||
+        crossSourceFocusedSafetyTestRank(left, right) ||
+        taskSpecificPathPriorityRank(left.path, left.source, left.bytes, left.task_tokens) -
+            taskSpecificPathPriorityRank(right.path, right.source, right.bytes, right.task_tokens) ||
+        relevanceRank(left) - relevanceRank(right) ||
+        sourceRank(left.source) - sourceRank(right.source);
+    if (baseComparison !== 0) {
+        return baseComparison;
+    }
+    if (left.source === "focus" && right.source === "focus") {
+        return (strongImplementationPathSearchRank(left) -
+            strongImplementationPathSearchRank(right) ||
+            taskSpecificPathPriorityRank(left.path, left.source, left.bytes, left.task_tokens) -
+                taskSpecificPathPriorityRank(right.path, right.source, right.bytes, right.task_tokens) ||
+            left.task_closure_rank - right.task_closure_rank ||
+            left.task_support_rank - right.task_support_rank ||
+            focusedSafetyTestRank(left) - focusedSafetyTestRank(right) ||
+            // Explicit task intent (task_support_rank) wins first; then a file whose
+            // actual CONTENT matches the task outranks the generic structural
+            // impl>test>doc prior. The structural prior remains the tiebreak when
+            // content match is equal, so the common no-task-token case is unchanged.
+            left.content_match_rank - right.content_match_rank ||
+            pathEvidenceRank(left.path) - pathEvidenceRank(right.path) ||
+            left.path_search_term_rank - right.path_search_term_rank ||
+            left.first_search_term_index - right.first_search_term_index ||
+            left.search_hit_density_rank - right.search_hit_density_rank ||
+            left.small_closure_rank - right.small_closure_rank ||
+            left.name_overlap_rank - right.name_overlap_rank ||
+            left.adjacency_rank - right.adjacency_rank ||
+            left.focus_proximity_rank - right.focus_proximity_rank ||
+            left.root_index - right.root_index ||
+            left.path.localeCompare(right.path) ||
+            left.first_line - right.first_line);
+    }
+    return (strongImplementationPathSearchRank(left) -
+        strongImplementationPathSearchRank(right) ||
+        taskSpecificPathPriorityRank(left.path, left.source, left.bytes, left.task_tokens) -
+            taskSpecificPathPriorityRank(right.path, right.source, right.bytes, right.task_tokens) ||
+        left.task_closure_rank - right.task_closure_rank ||
+        left.task_support_rank - right.task_support_rank ||
+        // Explicit task intent (task_support_rank) wins first; then a file whose
+        // actual CONTENT matches the task outranks the generic structural
+        // impl>test>doc prior. The structural prior remains the tiebreak when
+        // content match is equal, so the common no-task-token case is unchanged.
+        left.content_match_rank - right.content_match_rank ||
+        pathEvidenceRank(left.path) - pathEvidenceRank(right.path) ||
+        left.path_search_term_rank - right.path_search_term_rank ||
+        left.first_search_term_index - right.first_search_term_index ||
+        left.search_hit_density_rank - right.search_hit_density_rank ||
+        left.small_closure_rank - right.small_closure_rank ||
+        left.name_overlap_rank - right.name_overlap_rank ||
+        left.adjacency_rank - right.adjacency_rank ||
+        left.focus_proximity_rank - right.focus_proximity_rank ||
+        left.root_index - right.root_index ||
+        left.path.localeCompare(right.path) ||
+        left.first_line - right.first_line);
+}
+function strongImplementationPathSearchRank(item) {
+    return isImplementationPath(item.path) && item.path_search_term_rank <= -20 ? -1 : 0;
+}
+function taskSpecificPathPriorityRank(path, source, bytes, taskTokens) {
+    return Math.min(runtimeSettingsDiscoveryPathPriorityRank(path, taskTokens), codexRuntimeReviewPathPriorityRank(path, bytes, taskTokens), devtoolsTraceDebugPathPriorityRank(path, source, bytes, taskTokens));
+}
+function shouldOmitTaskSpecificNoise(item) {
+    return (taskSpecificPathPriorityRank(item.path, item.source, item.bytes, item.task_tokens) >= 12);
+}
+function runtimeSettingsDiscoveryPathPriorityRank(path, taskTokens) {
+    if (!isRuntimeSettingsDiscoveryTask(taskTokens)) {
+        return 0;
+    }
+    const normalized = path.toLowerCase();
+    const basename = normalized.split("/").at(-1) ?? normalized;
+    if (normalized.endsWith("/hooks/usechatruntimesettings.ts")) {
+        return -80;
+    }
+    if (normalized.endsWith("/components/chat/message-input/composerruntimecontrols.tsx")) {
+        return -78;
+    }
+    if (normalized.endsWith("/components/chat/message-input/input.tsx")) {
+        return -77;
+    }
+    if (normalized.endsWith("/pages/chatpage.tsx")) {
+        return -76;
+    }
+    if (normalized.endsWith("/services/chatservice.ts") ||
+        normalized.endsWith("/api/endpoints/chat.py") ||
+        normalized.endsWith("/services/chat.py")) {
+        return normalized.endsWith("/api/endpoints/chat.py") ? -82 : -72;
+    }
+    if (normalized.endsWith("/api/endpoints/ai_models.py") ||
+        normalized.endsWith("/models/db_models/ai_model.py") ||
+        normalized.endsWith("/services/runtime/resolver.py") ||
+        normalized.endsWith("/services/model_provider_auth.py") ||
+        normalized.endsWith("/services/claude_agent.py") ||
+        normalized.endsWith("/tests/test_ai_models_codex_gate.py") ||
+        normalized.endsWith("/components/chat/model-selector/modelselector.tsx") ||
+        normalized.endsWith("/components/chat/model-selector/modelselector.test.tsx") ||
+        normalized.endsWith("/hooks/queries/usemodelqueries.ts") ||
+        normalized.endsWith("/utils/modelprovider.ts") ||
+        normalized.endsWith("/utils/__tests__/modelprovider.test.ts")) {
+        return normalized.endsWith("/api/endpoints/ai_models.py") ||
+            normalized.endsWith("/components/chat/model-selector/modelselector.tsx")
+            ? -81
+            : -70;
+    }
+    if (normalized.endsWith("/store/messagequeuestore.ts") ||
+        normalized.endsWith("/store/__tests__/messagequeuestore.test.ts") ||
+        normalized.endsWith("/services/queueservice.ts") ||
+        normalized.endsWith("/services/streamservice.ts") ||
+        normalized.endsWith("/tests/services/test_queue.py") ||
+        normalized.endsWith("/tests/test_queue.py") ||
+        normalized.endsWith("/tests/services/test_pending_initial_prompt_service.py")) {
+        return normalized.endsWith("/tests/services/test_pending_initial_prompt_service.py") ||
+            normalized.endsWith("/tests/test_queue.py")
+            ? -74
+            : -68;
+    }
+    if (normalized.endsWith("/services/runtime/codex.py") ||
+        normalized.endsWith("/services/runtime/claude.py") ||
+        normalized.endsWith("/services/runtime/codex_approval.py") ||
+        normalized.endsWith("/services/runtime/codex_stream_processor.py") ||
+        normalized.endsWith("/services/streaming/orchestrator.py") ||
+        normalized.endsWith("/tasks/chat_processor.py") ||
+        normalized.endsWith("/services/runtime_session_service.py")) {
+        return normalized.endsWith("/tasks/chat_processor.py") ? -73 : -64;
+    }
+    if (normalized.endsWith("/hooks/__tests__/usechatruntimesettings.test.ts") ||
+        normalized.endsWith("/pages/landingpage.test.tsx") ||
+        normalized.endsWith("/tests/test_chat.py") ||
+        normalized.endsWith("/tests/services/runtime/test_codex_runtime.py") ||
+        normalized.endsWith("/tests/test_codex_runtime_data_migration.py") ||
+        normalized.endsWith("/tests/test_codex_effort_translation.py") ||
+        normalized.endsWith("/tests/test_effort_level.py") ||
+        normalized.endsWith("/tests/test_permission_mode.py") ||
+        normalized.endsWith("/tests/services/test_claude_agent.py")) {
+        return -60;
+    }
+    if (basename === "effort.py" ||
+        basename === "permission_mode.py" ||
+        basename === "chat.types.ts" ||
+        basename === "queue.types.ts" ||
+        normalized.endsWith("/models/schemas/chat.py") ||
+        normalized.endsWith("/models/db_models/chat.py") ||
+        normalized.endsWith("/models/db_models/runtime_session.py") ||
+        basename.includes("permissionmodeselector") ||
+        basename.includes("thinkingmodeselector")) {
+        return basename === "effort.py" || basename === "permission_mode.py" ? -64 : -56;
+    }
+    if (normalized.endsWith("/pages/landingpage.tsx") ||
+        normalized.endsWith("/tasks/chat_processor.py")) {
+        return 18;
+    }
+    if (normalized.endsWith("/components/chat/chat-window/chat.tsx")) {
+        return 14;
+    }
+    if (normalized.endsWith("/hooks/usechatstreaming.ts")) {
+        return -12;
+    }
+    return 0;
+}
+function codexRuntimeReviewPathPriorityRank(path, bytes, taskTokens) {
+    if (!isCodexRuntimeReviewTask(taskTokens)) {
+        return 0;
+    }
+    const normalized = path.toLowerCase();
+    if (normalized.endsWith("/services/runtime/resolver.py")) {
+        return -92;
+    }
+    if (normalized.endsWith("/services/runtime/codex.py")) {
+        return -90;
+    }
+    if (normalized.endsWith("/services/runtime/codex_approval.py")) {
+        return -88;
+    }
+    if (normalized.endsWith("/services/runtime/codex_stream_processor.py")) {
+        return -86;
+    }
+    if (normalized.endsWith("/services/runtime_session_service.py")) {
+        return -84;
+    }
+    if (normalized.endsWith("/models/db_models/runtime_session.py")) {
+        return -82;
+    }
+    if (normalized.endsWith("/tests/services/runtime/test_codex_runtime.py")) {
+        return -80;
+    }
+    if (normalized.endsWith("/tests/services/runtime/test_codex_approval_bridge.py")) {
+        return -78;
+    }
+    if (normalized.endsWith("/tests/services/runtime/test_codex_stream_processor.py")) {
+        return -76;
+    }
+    if (normalized.endsWith("/tests/services/test_runtime_session_service.py")) {
+        return -74;
+    }
+    if (codexReviewWantsModelGate(taskTokens) &&
+        (normalized.endsWith("/models/db_models/ai_model.py") ||
+            normalized.endsWith("/api/endpoints/ai_models.py") ||
+            normalized.endsWith("/services/model_provider_auth.py") ||
+            normalized.endsWith("/tests/test_ai_models_codex_gate.py"))) {
+        return -72;
+    }
+    if (codexReviewWantsFrontendGate(taskTokens) &&
+        (normalized.endsWith("/components/chat/message-input/thinkingmodeselector.tsx") ||
+            normalized.endsWith("/components/chat/thinking-mode-selector/thinkingmodeselector.tsx") ||
+            normalized.endsWith("/components/chat/permission-mode-selector/permissionmodeselector.tsx"))) {
+        return -71;
+    }
+    if (codexReviewWantsFrontendGate(taskTokens) &&
+        normalized.endsWith("/components/chat/message-input/input.tsx")) {
+        return -83;
+    }
+    if (codexReviewWantsFrontendGate(taskTokens) &&
+        normalized.endsWith("/components/ui/fileuploaddialog.codex.test.tsx")) {
+        return -81;
+    }
+    if (codexReviewWantsFrontendGate(taskTokens) &&
+        (normalized.endsWith("/components/ui/fileuploaddialog.tsx") ||
+            normalized.endsWith("/hooks/usemessageactions.ts") ||
+            normalized.endsWith("/services/chatservice.ts"))) {
+        return -68;
+    }
+    if (normalized.endsWith("/api/endpoints/permissions.py") ||
+        normalized.endsWith("/services/permission_manager.py") ||
+        normalized.endsWith("/hooks/usepermissionrequest.ts") ||
+        normalized.endsWith("/tests/test_permissions.py") ||
+        normalized.endsWith("/tests/services/runtime/test_codex_stream_processor_fixtures.py")) {
+        return -58;
+    }
+    if (bytes > SMALL_CLOSURE_MAX_BYTES &&
+        (normalized.includes("/sandbox/") ||
+            normalized.includes("sandbox") ||
+            normalized.includes("providerauth") ||
+            normalized.includes("provider_auth") ||
+            normalized.includes("model_provider_auth"))) {
+        return 16;
+    }
+    return 0;
+}
+function devtoolsTraceDebugPathPriorityRank(path, source, bytes, taskTokens) {
+    if (!isDevtoolsTraceDebugTask(taskTokens)) {
+        return 0;
+    }
+    const normalized = path.toLowerCase();
+    const focusBonus = source === "focus" ? -2 : 0;
+    if (normalized.endsWith("/components/right-panel/rightpaneldevtools.tsx")) {
+        return -90 + focusBonus;
+    }
+    if (normalized.endsWith("/components/right-panel/__tests__/right-panel-devtools.test.tsx") ||
+        normalized.endsWith("/components/chat/__tests__/chat.autoscroll.test.tsx") ||
+        normalized.endsWith("/store/devtoolsnavstore.ts") ||
+        normalized.endsWith("/store/__tests__/devtoolsnavstore.test.ts")) {
+        return -86 + focusBonus;
+    }
+    if (normalized.endsWith("/components/chat/chat-window/chat.tsx") ||
+        normalized.endsWith("/components/chat/message-bubble/messagerenderer.tsx") ||
+        normalized.endsWith("/components/chat/tools/common/toolcard.tsx")) {
+        return -82 + focusBonus;
+    }
+    if (normalized.endsWith("/hooks/usemessagecache.ts") ||
+        normalized.endsWith("/utils/messagecacheorder.ts") ||
+        normalized.endsWith("/hooks/queries/querykeys.ts") ||
+        normalized.endsWith("/hooks/queries/usedevtoolsqueries.ts") ||
+        normalized.endsWith("/components/chat/tools/common/toolexpandcontext.ts") ||
+        normalized.endsWith("/components/chat/tools/common/__tests__/toolexpand.test.tsx")) {
+        return -78 + focusBonus;
+    }
+    if (normalized.endsWith("/components/right-panel/devtools-helpers.ts") ||
+        normalized.endsWith("/components/right-panel/__tests__/devtools-helpers.test.ts") ||
+        normalized.endsWith("/services/devtoolsservice.ts")) {
+        return -66 + focusBonus;
+    }
+    if (normalized.endsWith("/api/endpoints/devtools.py") ||
+        normalized.endsWith("/services/session_trace_archive.py") ||
+        normalized.endsWith("/services/codex_trace.py") ||
+        normalized.endsWith("/models/db_models/session_trace_archive.py") ||
+        normalized.endsWith("/models/schemas/devtools.py") ||
+        normalized.endsWith("/types/devtools.types.ts")) {
+        if (devtoolsDebugIsFrontendRowTask(taskTokens)) {
+            return -12;
+        }
+        return -36;
+    }
+    if (normalized.endsWith("/components/right-panel/rightpanel.tsx") ||
+        normalized.endsWith("/components/chat/message-bubble/message.tsx")) {
+        return -20;
+    }
+    if ((isTestPath(normalized) || normalized.includes("/__mocks__/")) &&
+        normalized.includes("virtualizer")) {
+        return -74 + focusBonus;
+    }
+    if (bytes > SMALL_CLOSURE_MAX_BYTES) {
+        return 12;
+    }
+    return 0;
+}
+function devtoolsDebugIsFrontendRowTask(taskTokens) {
+    return (taskTokens.has("row") ||
+        taskTokens.has("search") ||
+        taskTokens.has("filter") ||
+        taskTokens.has("filtered") ||
+        taskTokens.has("virtualizer") ||
+        taskTokens.has("visible") ||
+        taskTokens.has("click") ||
+        taskTokens.has("click-through"));
+}
+function isRuntimeSettingsDiscoveryTask(taskTokens) {
+    return taskTokens.has("discovery") && taskTokens.has("runtime");
+}
+function isCodexRuntimeReviewTask(taskTokens) {
+    return (taskTokens.has("review") &&
+        taskTokens.has("codex") &&
+        (taskTokens.has("runtime") ||
+            taskTokens.has("approval") ||
+            taskTokens.has("session") ||
+            taskTokens.has("stream") ||
+            taskTokens.has("permission")));
+}
+function codexReviewWantsModelGate(taskTokens) {
+    return (taskTokens.has("model") ||
+        taskTokens.has("provider") ||
+        taskTokens.has("capability") ||
+        taskTokens.has("check"));
+}
+function codexReviewWantsFrontendGate(taskTokens) {
+    return (taskTokens.has("frontend") ||
+        taskTokens.has("consumer") ||
+        taskTokens.has("file") ||
+        taskTokens.has("upload") ||
+        taskTokens.has("gating") ||
+        taskTokens.has("attachment") ||
+        codexReviewWantsModelGate(taskTokens));
+}
+function isDevtoolsTraceDebugTask(taskTokens) {
+    return ((taskTokens.has("debug") ||
+        taskTokens.has("debugging") ||
+        taskTokens.has("diagnose") ||
+        taskTokens.has("diagnosis") ||
+        taskTokens.has("diagnostic")) &&
+        (taskTokens.has("devtool") || (taskTokens.has("dev") && taskTokens.has("tool"))) &&
+        taskTokens.has("trace"));
+}
+function crossSourceFocusedSafetyTestRank(left, right) {
+    if (left.source === right.source) {
+        return 0;
+    }
+    return focusedSafetyTestRank(left) - focusedSafetyTestRank(right);
+}
+function focusedSafetyTestRank(item) {
+    return item.source === "focus" && isTestPath(item.path) && item.task_support_rank < 0
+        ? -1
+        : 0;
+}
+function pathEvidenceRank(path) {
+    if (isImplementationPath(path)) {
+        return 0;
+    }
+    if (isTestPath(path)) {
+        return 1;
+    }
+    if (isHiddenOrGeneratedPath(path)) {
+        return 4;
+    }
+    if (isProjectDocPath(path)) {
+        return 2;
+    }
+    return 3;
+}
+function isImplementationPath(path) {
+    if (isTestPath(path)) {
+        return false;
+    }
+    return (path.startsWith("src/") ||
+        path.startsWith("frontend/src/") ||
+        path.startsWith("backend/app/"));
+}
+function isProjectDocPath(path) {
+    return (path.startsWith("docs/") ||
+        path === "README.md" ||
+        path === "CLAUDE.md" ||
+        path === "AGENTS.md" ||
+        path === "PRODUCT.md" ||
+        path.endsWith(".md"));
+}
+function isHiddenOrGeneratedPath(path) {
+    return (path.startsWith(".") ||
+        path.includes("/.") ||
+        path.includes("/dist/") ||
+        path.includes("/build/") ||
+        path.endsWith("package-lock.json"));
+}
+function relevanceRank(item) {
+    return item.has_search_evidence ? 0 : 1;
+}
+function compareTreeFiles(left, right) {
+    return left.root_index - right.root_index || left.path.localeCompare(right.path);
+}
+function compareSearchRecords(left, right) {
+    return (left.root_index - right.root_index ||
+        left.path.localeCompare(right.path) ||
+        left.line - right.line ||
+        left.search_term_index - right.search_term_index);
+}
+function compareSlices(left, right) {
+    return (sliceRelevanceRank(left) - sliceRelevanceRank(right) ||
+        pathEvidenceRank(left.path) - pathEvidenceRank(right.path) ||
+        (left.search_term_index ?? Number.MAX_SAFE_INTEGER) -
+            (right.search_term_index ?? Number.MAX_SAFE_INTEGER) ||
+        sourceRank(left.source) - sourceRank(right.source) ||
+        left.root_index - right.root_index ||
+        left.path.localeCompare(right.path) ||
+        left.start_line - right.start_line);
+}
+function sliceRelevanceRank(slice) {
+    return slice.source === "search" ? 0 : 1;
+}
+function sourceRank(source) {
+    return source === "focus" ? 0 : 1;
+}
+//# sourceMappingURL=selection.js.map