clinkx 0.2.3 → 1.0.0

package/dist/context-builder/selection.js

@@ -0,0 +1,1111 @@
+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 rankedPending = buildPendingSelections(input.slices, input.search, input.task ?? "", input.budget);
+    const obligationRanges = input.coverage_policy?.id === "review_deep_v1"
+        ? buildObligationRangeIndex(input.review_obligations)
+        : new Map();
+    const pending = reserveRequiredCoverageCandidates({
+        pending: rankedPending,
+        budget: input.budget,
+        policy: input.coverage_policy,
+        evidenceClassesByCandidate: input.evidence_classes_by_candidate,
+        obligations: input.review_obligations,
+        obligationRanges,
+    });
+    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 (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 }, obligationRanges.get(contextReviewCandidateId(item)));
+        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,
+            ...(selectedItem.file.disposition == null
+                ? {}
+                : { disposition: selectedItem.file.disposition }),
+        });
+        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 reserveRequiredCoverageCandidates(input) {
+    const policy = input.policy;
+    if (policy?.id == null ||
+        policy.required_when_available.length === 0) {
+        return input.pending;
+    }
+    const reserved = [];
+    const reservedKeys = new Set();
+    const pendingByCandidateId = new Map();
+    for (const item of input.pending) {
+        const candidateId = contextReviewCandidateId(item);
+        if (!pendingByCandidateId.has(candidateId)) {
+            pendingByCandidateId.set(candidateId, item);
+        }
+    }
+    let totalBytes = 0;
+    let totalTokens = 0;
+    const reserveCandidate = (candidateIds) => {
+        if (reserved.length >= input.budget.max_files) {
+            return false;
+        }
+        for (const candidateId of candidateIds) {
+            const item = pendingByCandidateId.get(candidateId);
+            if (item == null) {
+                continue;
+            }
+            const key = pendingCandidateKey(item);
+            if (reservedKeys.has(key)) {
+                return true;
+            }
+            const budgeted = budgetedSelectionForItem(item, input.budget, { totalBytes, totalTokens }, input.obligationRanges.get(candidateId));
+            if (budgeted.kind === "omitted") {
+                continue;
+            }
+            reserved.push(item);
+            reservedKeys.add(key);
+            totalBytes += budgeted.file.bytes;
+            totalTokens += budgeted.file.estimated_tokens;
+            return true;
+        }
+        return false;
+    };
+    if (input.obligations != null) {
+        for (const target of input.obligations.targets) {
+            reserveCandidate([target.candidate_id]);
+            if (target.regression_links.length > 0) {
+                reserveCandidate(target.regression_links.map((link) => link.candidate_id));
+            }
+        }
+    }
+    else if (input.evidenceClassesByCandidate != null) {
+        const evidenceClassesByCandidate = input.evidenceClassesByCandidate;
+        for (const evidenceClass of policy.required_when_available) {
+            if (reserved.some((item) => evidenceClassesForPending(item, evidenceClassesByCandidate).includes(evidenceClass))) {
+                continue;
+            }
+            if (reserved.length >= input.budget.max_files) {
+                break;
+            }
+            for (const item of input.pending) {
+                const key = pendingCandidateKey(item);
+                if (reservedKeys.has(key) ||
+                    !evidenceClassesForPending(item, evidenceClassesByCandidate).includes(evidenceClass)) {
+                    continue;
+                }
+                const budgeted = budgetedSelectionForItem(item, input.budget, {
+                    totalBytes,
+                    totalTokens,
+                });
+                if (budgeted.kind === "omitted") {
+                    continue;
+                }
+                reserved.push(item);
+                reservedKeys.add(key);
+                totalBytes += budgeted.file.bytes;
+                totalTokens += budgeted.file.estimated_tokens;
+                break;
+            }
+        }
+    }
+    if (reserved.length === 0) {
+        return input.pending;
+    }
+    return [
+        ...reserved,
+        ...input.pending.filter((item) => !reservedKeys.has(pendingCandidateKey(item))),
+    ];
+}
+function evidenceClassesForPending(item, byCandidate) {
+    return byCandidate.get(pendingCandidateKey(item)) ?? [];
+}
+function pendingCandidateKey(item) {
+    return `${item.root_index}\u0000${item.path}`;
+}
+function contextReviewCandidateId(item) {
+    return `c:${String(item.root_index)}:${item.path}`;
+}
+function buildObligationRangeIndex(obligations) {
+    const ranges = new Map();
+    for (const target of obligations?.targets ?? []) {
+        appendObligationRanges(ranges, target.candidate_id, target.ranges);
+        for (const link of target.regression_links) {
+            appendObligationRanges(ranges, link.candidate_id, link.ranges);
+        }
+    }
+    return ranges;
+}
+function appendObligationRanges(index, candidateId, ranges) {
+    index.set(candidateId, mergeLineRanges([...(index.get(candidateId) ?? []), ...ranges]));
+}
+function budgetedSelectionForItem(item, budget, totals, preferredRanges) {
+    const full = selectedFileFromPending(item);
+    const obligationSelection = preferredRanges == null
+        ? null
+        : budgetFittingSelectionForRanges(item, preferredRanges, budget, totals);
+    if (obligationSelection != null) {
+        return {
+            kind: "selected",
+            file: obligationSelection,
+            tier: obligationSelection.bytes === full.bytes
+                ? "full_file"
+                : "signature_slices",
+            ...(obligationSelection.bytes === full.bytes
+                ? {}
+                : { reason: "review_coverage_obligation" }),
+        };
+    }
+    if (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 degraded = item.source === "focus" && !item.has_search_evidence
+        ? 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),
+    };
+}
+function budgetFittingSelectionForRanges(item, requestedRanges, budget, totals) {
+    let best = null;
+    const admitted = [];
+    for (const range of [...requestedRanges].sort((left, right) => left.start_line - right.start_line || left.end_line - right.end_line)) {
+        const candidate = selectionForRanges(item, [...admitted, range]);
+        if (candidate == null || !fitsBudget(candidate, budget, totals)) {
+            continue;
+        }
+        admitted.push(range);
+        best = candidate;
+    }
+    return best;
+}
+function selectionForRanges(item, requestedRanges) {
+    const renderedLineNumbers = renderedContentLineNumbers(item.ranges);
+    const lines = splitTextLines(item.content);
+    const linesByOriginalLine = linesByOriginalLineNumber(lines, renderedLineNumbers);
+    const selectedLines = new Set();
+    for (const requested of requestedRanges) {
+        for (let line = requested.start_line; line <= requested.end_line; line++) {
+            if (linesByOriginalLine.has(line)) {
+                selectedLines.add(line);
+            }
+        }
+    }
+    if (selectedLines.size === 0) {
+        return null;
+    }
+    const ranges = mergeLineRanges([...selectedLines].map((line) => ({ start_line: line, end_line: line })));
+    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,
+    };
+}
+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 maxLines = 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)
+        : [];
+    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 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 rawEvidenceRecords = (focusRecords.length > 0 &&
+            shouldPreferFullFocusEvidence(focusRecords, budget))
+            ? focusRecords
+            : hasSearchEvidence
+                ? searchRecords
+                : records;
+        const evidenceRecords = rawEvidenceRecords;
+        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,
+            small_closure_rank: smallClosureRank(first.path, bytes, contentTokens, taskTokens, searchTermTokens),
+            has_search_evidence: hasSearchEvidence,
+            task_tokens: taskTokens,
+            search_term_tokens: searchTermTokens,
+        });
+    }
+    return pending.sort(comparePendingSelections);
+}
+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 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 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 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 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 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.") ||
+        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");
+}
+// 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 = crossSourceFocusedSafetyTestRank(left, right) ||
+        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) ||
+            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) ||
+        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 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.includes("/src/") ||
+        path.includes("/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