clinkx 0.2.3 → 1.0.0

package/dist/context-builder/delegate-packet.js

@@ -0,0 +1,1190 @@
+import { boundContextBuilderOmissions, isRequestedEvidenceOmission, requestedEvidenceOmission, } from "./diagnostics.js";
+import { normalizeContextBuilderRootRelativePath, } from "./paths.js";
+import { orderEvidenceClasses, } from "./review-coverage.js";
+import { hasConservativeResidualSecret, scanSecretPath } from "./secrets.js";
+import { estimateContextBuilderTokensFromUtf8Bytes } from "./token-estimate.js";
+export const CONTEXT_BUILDER_DELEGATE_PACKET_CAP_DEFAULTS = Object.freeze({
+    max_candidates: 300,
+    max_search_records: 300,
+    max_slice_records: 300,
+    max_omissions: 200,
+    max_paths_per_omission: 20,
+    max_total_evidence_bytes: 120_000,
+    max_preview_bytes: 500,
+    max_slice_excerpt_bytes: 1_000,
+    max_task_chars: 4_000,
+    max_packet_estimated_tokens: 44_000,
+});
+export const CONTEXT_BUILDER_DELEGATE_PACKET_CAP_PROFILE_DEFAULTS = Object.freeze({
+    handoff_small: {
+        max_candidates: 120,
+        max_search_records: 120,
+        max_slice_records: 120,
+        max_total_evidence_bytes: 60_000,
+        max_preview_bytes: 400,
+        max_slice_excerpt_bytes: 800,
+        max_packet_estimated_tokens: 22_000,
+    },
+    implementation_medium: {
+        max_candidates: 300,
+        max_search_records: 300,
+        max_slice_records: 300,
+        max_total_evidence_bytes: 120_000,
+        max_preview_bytes: 500,
+        max_slice_excerpt_bytes: 1_000,
+        max_packet_estimated_tokens: 44_000,
+    },
+    review_deep: {
+        max_candidates: 260,
+        max_search_records: 260,
+        max_slice_records: 260,
+        max_total_evidence_bytes: 100_000,
+        max_preview_bytes: 500,
+        max_slice_excerpt_bytes: 900,
+        max_packet_estimated_tokens: 40_000,
+    },
+});
+const MAX_CURATOR_PROPOSAL_SELECTED = 50;
+const MAX_CURATOR_PROPOSAL_RANGES_PER_SELECTION = 20;
+const MAX_CURATOR_PROPOSAL_WARNINGS = 50;
+const MAX_CURATOR_PROPOSAL_OPEN_QUESTIONS = 50;
+const MAX_DELEGATE_PACKET_JSON_BYTES = 92_000;
+export function buildContextBuilderCuratorPacket(input) {
+    return buildContextBuilderDelegatePacket("curator", input);
+}
+export function buildContextBuilderFinalizerPacket(input) {
+    return buildContextBuilderDelegatePacket("finalizer", input);
+}
+export function contextBuilderCandidateId(rootIndex, path) {
+    return `c:${rootIndex}:${path}`;
+}
+export function contextBuilderRangeId(candidateId, startLine, endLine) {
+    return `r:${candidateId}:${startLine}-${endLine}`;
+}
+function buildContextBuilderDelegatePacket(purpose, input) {
+    const caps = normalizeCaps(input.caps, input.budget);
+    // Packet BUILD defaults allow-secrets ON to match the feature's global
+    // default (resolveAllowSecrets → true); the delegate VALIDATOR defaults
+    // fail-closed (?? false) as a conservative validation boundary. These never
+    // diverge on the live path — the handler always passes the resolved boolean
+    // to both. The asymmetry is intentional, not a missed seam.
+    const allowSecrets = input.allowSecrets ?? true;
+    const state = {
+        caps,
+        allowSecrets,
+        evidenceBytes: 0,
+        evidenceByteCapHit: false,
+        searchIncluded: 0,
+        searchOmitted: 0,
+        sliceIncluded: 0,
+        sliceOmitted: 0,
+    };
+    const selectedIds = new Set(input.selection.selected.map((selected) => contextBuilderCandidateId(selected.root_index, selected.path)));
+    const selectedRanks = new Map(input.selection.selected.map((selected, index) => [
+        contextBuilderCandidateId(selected.root_index, selected.path),
+        index,
+    ]));
+    const selectedRanges = buildSelectedRangeIndex(input.selection.selected, allowSecrets);
+    const evidence = buildCandidateEvidenceIndex(input, allowSecrets);
+    const coveragePolicy = normalizeCoveragePolicy(input.coveragePolicy, input.discovery.review_obligations, caps);
+    const seeds = orderCandidateSeedsForCoverage(buildCandidateSeeds(input, selectedIds, selectedRanks, evidence).filter(shouldIncludeDelegateCandidateSeed), coveragePolicy);
+    const requestedCoverage = buildRequestedPacketCoverage(input, selectedRanges);
+    const requestedCoverageIndex = buildRequestedCoverageIndex(requestedCoverage);
+    const protection = buildPacketProtectionIndex(input, allowSecrets);
+    const candidates = seeds
+        .map((seed) => buildPacketCandidate(seed, input, selectedRanges, requestedCoverageIndex, state))
+        .filter((candidate) => candidate.ranges.length > 0)
+        .slice(0, caps.max_candidates);
+    const candidatesOmittedByCountCap = Math.max(0, seeds.length - candidates.length);
+    const candidateLineCounts = new Map(candidates.map((candidate) => [candidate.id, candidate.line_count]));
+    const candidateIds = new Set(candidateLineCounts.keys());
+    const deterministicSelection = buildDeterministicSelection(input.selection.selected, candidateIds, allowSecrets);
+    const packet = {
+        version: "context-builder.delegate-packet.v1",
+        purpose,
+        task: sanitizePacketText(input.task, caps.max_task_chars, allowSecrets).text,
+        rules: {
+            local_candidate_universe_only: true,
+            provider_must_not_discover_paths: true,
+            source_authority: "server",
+            absolute_paths_included: false,
+            raw_full_content_included: false,
+        },
+        budget: input.budget,
+        coverage_policy: coveragePolicy,
+        candidates,
+        deterministic_selection: {
+            metrics: input.selection.metrics,
+            selected: deterministicSelection,
+        },
+        omissions: buildPacketOmissions(input.discovery.omissions, input.selection.omissions, caps, allowSecrets),
+        metrics: {
+            discovery: input.discovery.metrics,
+            selection: input.selection.metrics,
+            candidates_included: candidates.length,
+            candidates_omitted_by_packet_cap: candidatesOmittedByCountCap,
+            search_records_included: state.searchIncluded,
+            search_records_omitted_by_packet_cap: state.searchOmitted,
+            slice_records_included: state.sliceIncluded,
+            slice_records_omitted_by_packet_cap: state.sliceOmitted,
+            evidence_bytes: state.evidenceBytes,
+            evidence_byte_cap_hit: state.evidenceByteCapHit,
+            packet_estimated_tokens: 0,
+            packet_token_cap_hit: false,
+            compaction: {
+                candidates_before_compaction: candidates.length,
+                candidates_after_compaction: candidates.length,
+                candidates_evicted_by_compaction: 0,
+                evidence_bytes_before_compaction: 0,
+                evidence_bytes_after_compaction: 0,
+                search_records_before_compaction: 0,
+                search_records_after_compaction: 0,
+                slice_records_before_compaction: 0,
+                slice_records_after_compaction: 0,
+                all_non_focus_candidates_evidence_free: false,
+            },
+        },
+        ...(purpose === "finalizer" && "curator_proposal" in input
+            ? {
+                curator_proposal: sanitizeCuratorProposal(input.curator_proposal, candidateLineCounts, caps, allowSecrets),
+                local_selection_summary: {
+                    selected: deterministicSelection,
+                },
+            }
+            : {}),
+    };
+    syncSelectionSummariesToCandidateRanges(packet);
+    enforcePacketTokenCap(packet, caps, requestedCoverageIndex, protection);
+    syncCandidateCoverageToPacketRanges(packet);
+    syncSelectionSummariesToCandidateRanges(packet);
+    appendMissingRequestedCoverageOmissions(packet, requestedCoverage);
+    return packet;
+}
+function buildCandidateSeeds(input, selectedIds, selectedRanks, evidence) {
+    const allowSecrets = input.allowSecrets ?? true;
+    const eligibleTree = new Map();
+    for (const file of input.discovery.tree) {
+        const normalized = normalizePacketPath(file.path, allowSecrets);
+        if (normalized == null ||
+            !file.eligible ||
+            !file.content_eligible ||
+            file.omission_reason != null) {
+            continue;
+        }
+        eligibleTree.set(candidateKey(file.root_index, normalized), {
+            ...file,
+            path: normalized,
+        });
+    }
+    const seeds = [];
+    for (const candidate of input.discovery.content_candidates) {
+        const normalized = normalizePacketPath(candidate.path, allowSecrets);
+        if (normalized == null) {
+            continue;
+        }
+        const treeFile = eligibleTree.get(candidateKey(candidate.root_index, normalized));
+        if (treeFile == null) {
+            continue;
+        }
+        const id = contextBuilderCandidateId(candidate.root_index, normalized);
+        const classifiedCandidate = candidate;
+        seeds.push({
+            id,
+            root_index: candidate.root_index,
+            path: normalized,
+            line_count: Math.max(0, candidate.line_count),
+            size_bytes: Math.max(0, treeFile.size_bytes),
+            estimated_tokens: estimateContextBuilderTokensFromUtf8Bytes(Math.max(0, treeFile.size_bytes)),
+            deterministic_selected: selectedIds.has(id),
+            deterministic_rank: selectedRanks.get(id) ?? Number.MAX_SAFE_INTEGER,
+            has_focus_evidence: evidence.focusIds.has(id),
+            has_slice_evidence: evidence.sliceIds.has(id),
+            has_search_evidence: evidence.searchIds.has(id),
+            evidence_classes: orderEvidenceClasses(classifiedCandidate.evidence_classes ?? []),
+        });
+    }
+    return seeds.sort(compareCandidateSeeds);
+}
+function shouldIncludeDelegateCandidateSeed(seed) {
+    if (seed.has_focus_evidence) {
+        return true;
+    }
+    return !isWorkbenchArtifactPath(seed.path);
+}
+function isWorkbenchArtifactPath(path) {
+    return path.startsWith(".ai/") || path.includes("/.ai/");
+}
+function buildCandidateEvidenceIndex(input, allowSecrets) {
+    const focusIds = new Set(input.discovery.slices
+        .filter((slice) => slice.source === "focus")
+        .map((slice) => contextBuilderCandidateId(slice.root_index, slice.path)));
+    for (const candidate of input.discovery.content_candidates) {
+        const normalized = normalizePacketPath(candidate.path, allowSecrets);
+        if (normalized != null &&
+            candidateMatchesFocusPath(candidate.root_index, normalized, input.focus_paths ?? [])) {
+            focusIds.add(contextBuilderCandidateId(candidate.root_index, normalized));
+        }
+    }
+    return {
+        focusIds,
+        sliceIds: new Set(input.discovery.slices.map((slice) => contextBuilderCandidateId(slice.root_index, slice.path))),
+        searchIds: new Set(input.discovery.search.map((hit) => contextBuilderCandidateId(hit.root_index, hit.path))),
+    };
+}
+function candidateMatchesFocusPath(rootIndex, path, focusPaths) {
+    return focusPaths.some((focus) => {
+        if (focus.root_index !== rootIndex) {
+            return false;
+        }
+        if (focus.kind === "file") {
+            return path === focus.root_relative_path;
+        }
+        return (path === focus.root_relative_path ||
+            path.startsWith(`${focus.root_relative_path}/`));
+    });
+}
+function buildPacketCandidate(seed, input, selectedRanges, requestedCoverage, state) {
+    const ranges = buildRanges(seed, input.discovery.slices, selectedRanges.get(seed.id) ?? [], state);
+    const searchHits = buildSearchHits(seed, input.discovery.search, state);
+    const coverage = buildDeterministicCoverage(ranges, selectedRanges.get(seed.id) ?? []);
+    const requiredFocusRanges = (requestedCoverage.get(seed.id) ?? [])
+        .filter((range) => isCoveredByPacketRanges(ranges, range))
+        .map((range) => ({ ...range }));
+    return {
+        id: seed.id,
+        root_index: seed.root_index,
+        path: seed.path,
+        line_count: seed.line_count,
+        size_bytes: seed.size_bytes,
+        estimated_tokens: seed.estimated_tokens,
+        discovery_reason: discoveryReason(ranges, searchHits),
+        evidence_classes: [...seed.evidence_classes],
+        focus_requested: seed.has_focus_evidence,
+        ...(requiredFocusRanges.length === 0
+            ? {}
+            : { required_focus_ranges: requiredFocusRanges }),
+        deterministic_selected: seed.deterministic_selected,
+        deterministic_coverage: coverage.status,
+        deterministic_ranges: coverage.selected,
+        uncovered_packet_ranges: coverage.uncovered,
+        ranges,
+        search_hits: searchHits,
+    };
+}
+function buildSelectedRangeIndex(selected, allowSecrets) {
+    const byCandidate = new Map();
+    for (const file of selected) {
+        const normalized = normalizePacketPath(file.path, allowSecrets);
+        if (normalized == null) {
+            continue;
+        }
+        const candidateId = contextBuilderCandidateId(file.root_index, normalized);
+        byCandidate.set(candidateId, file.ranges.map((range) => ({
+            id: contextBuilderRangeId(candidateId, range.start_line, range.end_line),
+            start_line: range.start_line,
+            end_line: range.end_line,
+        })));
+    }
+    return byCandidate;
+}
+function buildRequestedPacketCoverage(input, selectedRanges) {
+    const requestedByCandidate = new Map();
+    const appendRange = (rootIndex, path, range) => {
+        const candidateId = contextBuilderCandidateId(rootIndex, path);
+        const coverage = requestedByCandidate.get(candidateId) ??
+            {
+                candidate_id: candidateId,
+                root_index: rootIndex,
+                path,
+                ranges: [],
+            };
+        if (!coverage.ranges.some((existing) => existing.start_line === range.start_line &&
+            existing.end_line === range.end_line)) {
+            coverage.ranges.push(range);
+        }
+        requestedByCandidate.set(candidateId, coverage);
+    };
+    for (const [candidateId, ranges] of selectedRanges) {
+        const selection = input.selection.selected.find((file) => {
+            const normalized = normalizePacketPath(file.path, input.allowSecrets ?? true);
+            return (normalized != null &&
+                contextBuilderCandidateId(file.root_index, normalized) === candidateId);
+        });
+        if (selection == null) {
+            continue;
+        }
+        const normalized = normalizePacketPath(selection.path, input.allowSecrets ?? true);
+        if (normalized == null) {
+            continue;
+        }
+        if (!candidateMatchesFocusPath(selection.root_index, normalized, input.focus_paths ?? [])) {
+            continue;
+        }
+        for (const range of ranges) {
+            appendRange(selection.root_index, normalized, range);
+        }
+    }
+    for (const slice of input.discovery.slices) {
+        const normalized = normalizePacketPath(slice.path, input.allowSecrets ?? true);
+        if (normalized == null) {
+            continue;
+        }
+        const isRequested = slice.source === "focus" ||
+            candidateMatchesFocusPath(slice.root_index, normalized, input.focus_paths ?? []);
+        if (!isRequested) {
+            continue;
+        }
+        const candidateId = contextBuilderCandidateId(slice.root_index, normalized);
+        appendRange(slice.root_index, normalized, {
+            id: contextBuilderRangeId(candidateId, slice.start_line, slice.end_line),
+            start_line: slice.start_line,
+            end_line: slice.end_line,
+        });
+    }
+    for (const target of input.discovery.review_obligations?.targets ?? []) {
+        for (const range of target.ranges) {
+            appendRange(target.root_index, target.path, {
+                id: contextBuilderRangeId(target.candidate_id, range.start_line, range.end_line),
+                start_line: range.start_line,
+                end_line: range.end_line,
+            });
+        }
+        for (const link of target.regression_links) {
+            for (const range of link.ranges) {
+                appendRange(link.root_index, link.path, {
+                    id: contextBuilderRangeId(link.candidate_id, range.start_line, range.end_line),
+                    start_line: range.start_line,
+                    end_line: range.end_line,
+                });
+            }
+        }
+    }
+    return [...requestedByCandidate.values()].map((coverage) => ({
+        ...coverage,
+        ranges: coverage.ranges.sort((left, right) => left.start_line - right.start_line || left.end_line - right.end_line),
+    }));
+}
+function buildDeterministicCoverage(packetRanges, selectedRanges) {
+    const selected = selectedRanges.filter((range) => isCoveredByPacketRanges(packetRanges, range));
+    const uncovered = packetRanges
+        .filter((range) => !isCoveredByPacketRanges(selected, range))
+        .map((range) => ({
+        id: range.id,
+        start_line: range.start_line,
+        end_line: range.end_line,
+    }));
+    const status = selected.length === 0
+        ? "none"
+        : uncovered.length === 0
+            ? "complete"
+            : "partial";
+    return { status, selected, uncovered };
+}
+function buildRanges(seed, slices, deterministicRanges, state) {
+    const ranges = [];
+    const sortedSlices = [...slices].sort((left, right) => {
+        const leftDeterministic = sliceCoveredByRanges(left, deterministicRanges) ? 0 : 1;
+        const rightDeterministic = sliceCoveredByRanges(right, deterministicRanges) ? 0 : 1;
+        return leftDeterministic - rightDeterministic || compareSlicesForPacket(left, right);
+    });
+    for (const slice of sortedSlices) {
+        if (slice.root_index !== seed.root_index || slice.path !== seed.path) {
+            continue;
+        }
+        if (state.sliceIncluded >= state.caps.max_slice_records) {
+            state.sliceOmitted += 1;
+            continue;
+        }
+        if (!isValidRange(slice.start_line, slice.end_line, seed.line_count)) {
+            state.sliceOmitted += 1;
+            continue;
+        }
+        const excerpt = takeEvidenceText(slice.content, state.caps.max_slice_excerpt_bytes, state);
+        ranges.push({
+            id: contextBuilderRangeId(seed.id, slice.start_line, slice.end_line),
+            start_line: slice.start_line,
+            end_line: slice.end_line,
+            source: slice.source,
+            estimated_tokens: estimateContextBuilderTokensFromUtf8Bytes(Buffer.byteLength(slice.content, "utf8")),
+            excerpt: excerpt.text,
+            excerpt_truncated: excerpt.truncated,
+        });
+        state.sliceIncluded += 1;
+    }
+    return ranges;
+}
+function sliceCoveredByRanges(slice, ranges) {
+    return ranges.some((range) => range.start_line <= slice.start_line && range.end_line >= slice.end_line);
+}
+function buildSearchHits(seed, search, state) {
+    const hits = [];
+    for (const hit of [...search].sort(compareSearchForPacket)) {
+        if (hit.root_index !== seed.root_index || hit.path !== seed.path) {
+            continue;
+        }
+        if (state.searchIncluded >= state.caps.max_search_records) {
+            state.searchOmitted += 1;
+            continue;
+        }
+        if (!isValidLine(hit.line, seed.line_count)) {
+            state.searchOmitted += 1;
+            continue;
+        }
+        const preview = takeEvidenceText(hit.preview, state.caps.max_preview_bytes, state);
+        hits.push({
+            line: hit.line,
+            column: Math.max(1, hit.column),
+            search_term_index: Math.max(0, hit.search_term_index),
+            preview: preview.text,
+            preview_truncated: preview.truncated,
+        });
+        state.searchIncluded += 1;
+    }
+    return hits;
+}
+function buildDeterministicSelection(selected, candidateIds, allowSecrets) {
+    return selected
+        .map((file) => {
+        const normalized = normalizePacketPath(file.path, allowSecrets);
+        if (normalized == null) {
+            return undefined;
+        }
+        const candidateId = contextBuilderCandidateId(file.root_index, normalized);
+        if (!candidateIds.has(candidateId)) {
+            return undefined;
+        }
+        return {
+            candidate_id: candidateId,
+            root_index: file.root_index,
+            path: normalized,
+            ranges: file.ranges.map((range) => ({
+                id: contextBuilderRangeId(candidateId, range.start_line, range.end_line),
+                start_line: range.start_line,
+                end_line: range.end_line,
+            })),
+            source: file.source,
+            bytes: file.bytes,
+            estimated_tokens: file.estimated_tokens,
+        };
+    })
+        .filter((item) => item != null);
+}
+function sanitizeCuratorProposal(proposal, candidateLineCounts, caps, allowSecrets) {
+    const maxSelected = Math.min(caps.max_candidates, MAX_CURATOR_PROPOSAL_SELECTED);
+    const maxRangesPerSelection = Math.min(caps.max_paths_per_omission, MAX_CURATOR_PROPOSAL_RANGES_PER_SELECTION);
+    const maxWarnings = Math.min(caps.max_omissions, MAX_CURATOR_PROPOSAL_WARNINGS);
+    const maxOpenQuestions = Math.min(caps.max_omissions, MAX_CURATOR_PROPOSAL_OPEN_QUESTIONS);
+    return {
+        selected: proposal.selected
+            .map((selection) => {
+            const lineCount = candidateLineCounts.get(selection.candidate_id);
+            if (lineCount == null) {
+                return undefined;
+            }
+            return {
+                candidate_id: selection.candidate_id,
+                ranges: selection.ranges
+                    .filter((range) => isValidRange(range.start_line, range.end_line, lineCount))
+                    .slice(0, maxRangesPerSelection)
+                    .map((range) => ({
+                    start_line: range.start_line,
+                    end_line: range.end_line,
+                    reason: sanitizePacketText(range.reason, caps.max_preview_bytes, allowSecrets).text,
+                })),
+                reason: sanitizePacketText(selection.reason, caps.max_preview_bytes, allowSecrets).text,
+            };
+        })
+            .filter((selection) => selection != null && selection.ranges.length > 0)
+            .sort((left, right) => left.candidate_id.localeCompare(right.candidate_id))
+            .slice(0, maxSelected),
+        warnings: proposal.warnings
+            .slice(0, maxWarnings)
+            .map((warning) => sanitizePacketText(warning, caps.max_preview_bytes, allowSecrets).text),
+        open_questions: proposal.open_questions
+            .slice(0, maxOpenQuestions)
+            .map((question) => sanitizePacketText(question, caps.max_preview_bytes, allowSecrets).text),
+    };
+}
+function buildPacketOmissions(discoveryOmissions, selectionOmissions, caps, allowSecrets) {
+    return boundContextBuilderOmissions([...discoveryOmissions, ...selectionOmissions].map((omission) => ({
+        ...(omission.root_index == null ? {} : { root_index: omission.root_index }),
+        reason: omission.reason,
+        message: omission.message,
+        ...(omission.paths == null
+            ? {}
+            : {
+                paths: omission.paths
+                    .map((path) => normalizePacketPath(path, allowSecrets))
+                    .filter((item) => item != null),
+            }),
+    })), {
+        max_omissions: caps.max_omissions,
+        max_paths_per_omission: caps.max_paths_per_omission,
+    });
+}
+function enforcePacketTokenCap(packet, caps, requestedCoverage, protection) {
+    const maxTokens = Math.max(1, caps.max_packet_estimated_tokens);
+    const before = countPacketEvidence(packet);
+    const compaction = packet.metrics.compaction;
+    compaction.candidates_before_compaction = packet.candidates.length;
+    compaction.evidence_bytes_before_compaction = before.evidenceBytes;
+    compaction.search_records_before_compaction = before.searchRecords;
+    compaction.slice_records_before_compaction = before.sliceRecords;
+    refreshPacketCompactionState(packet);
+    packet.metrics.packet_estimated_tokens = estimatePacketTokens(packet);
+    while (packet.metrics.packet_estimated_tokens > maxTokens ||
+        estimatePacketJsonBytes(packet) > MAX_DELEGATE_PACKET_JSON_BYTES) {
+        // Reduction ladder: evict low-value candidates before touching evidence,
+        // preserve one discriminative evidence item on protected candidates
+        // (focus, deterministic-baseline, exact-caller-hit) for as long as they
+        // remain in the packet, and only fall back to unrestricted stripping when
+        // nothing else can shrink the packet — caps stay hard.
+        const reduced = evictOneCompactionCandidate(packet, requestedCoverage, protection, "no_evidence") ||
+            evictOneCompactionCandidate(packet, requestedCoverage, protection, "unprotected") ||
+            dropOneCuratorProposalMetadata(packet) ||
+            dropOneEvidence(packet, protection) ||
+            dropOneCandidateRecord(packet, requestedCoverage, protection) ||
+            dropOneCandidate(packet, requestedCoverage) ||
+            dropOneEvidence(packet, null) ||
+            dropOneCandidateRecord(packet, requestedCoverage, null);
+        packet.metrics.packet_token_cap_hit = true;
+        refreshPacketCompactionState(packet);
+        packet.metrics.packet_estimated_tokens = estimatePacketTokens(packet);
+        if (!reduced) {
+            return;
+        }
+    }
+}
+function countPacketEvidence(packet) {
+    let evidenceBytes = 0;
+    let searchRecords = 0;
+    let sliceRecords = 0;
+    for (const candidate of packet.candidates) {
+        sliceRecords += candidate.ranges.length;
+        searchRecords += candidate.search_hits.length;
+        for (const range of candidate.ranges) {
+            evidenceBytes += Buffer.byteLength(range.excerpt, "utf8");
+        }
+        for (const hit of candidate.search_hits) {
+            evidenceBytes += Buffer.byteLength(hit.preview, "utf8");
+        }
+    }
+    return { evidenceBytes, searchRecords, sliceRecords };
+}
+function refreshPacketCompactionState(packet) {
+    const counts = countPacketEvidence(packet);
+    const compaction = packet.metrics.compaction;
+    compaction.candidates_after_compaction = packet.candidates.length;
+    compaction.candidates_evicted_by_compaction = Math.max(0, compaction.candidates_before_compaction - packet.candidates.length);
+    compaction.evidence_bytes_after_compaction = counts.evidenceBytes;
+    compaction.search_records_after_compaction = counts.searchRecords;
+    compaction.slice_records_after_compaction = counts.sliceRecords;
+    const nonFocusCandidates = packet.candidates.filter((candidate) => candidate.focus_requested !== true);
+    const evidenceFree = nonFocusCandidates.length > 0 &&
+        nonFocusCandidates.every((candidate) => !candidateHasEvidence(candidate));
+    compaction.all_non_focus_candidates_evidence_free = evidenceFree;
+    if (evidenceFree) {
+        packet.evidence_warning = {
+            code: "all_non_focus_candidates_evidence_free",
+            message: "packet compaction left every non-focus candidate without a search-hit preview or slice excerpt; non-focus candidates carry path metadata only",
+            non_focus_candidate_count: nonFocusCandidates.length,
+        };
+    }
+    else {
+        delete packet.evidence_warning;
+    }
+}
+function buildPacketProtectionIndex(input, allowSecrets) {
+    const callerTerms = new Set((input.caller_search_terms ?? [])
+        .map((term) => term.trim())
+        .filter((term) => term.length > 0));
+    const callerHitIds = new Set();
+    const callerTermIndexes = new Set();
+    if (callerTerms.size > 0) {
+        for (const record of input.discovery.search) {
+            if (!callerTerms.has(record.search_term.trim())) {
+                continue;
+            }
+            callerTermIndexes.add(record.search_term_index);
+            const normalized = normalizePacketPath(record.path, allowSecrets);
+            if (normalized != null) {
+                callerHitIds.add(contextBuilderCandidateId(record.root_index, normalized));
+            }
+        }
+    }
+    return { callerHitIds, callerTermIndexes };
+}
+function isProtectedPacketCandidate(candidate, protection) {
+    return (candidate.focus_requested === true ||
+        candidate.deterministic_selected ||
+        protection.callerHitIds.has(candidate.id));
+}
+function candidateHasEvidence(candidate) {
+    return (candidate.ranges.some((range) => range.excerpt.length > 0) ||
+        candidate.search_hits.some((hit) => hit.preview.length > 0));
+}
+function reservedEvidenceFor(candidate, protection) {
+    if (!isProtectedPacketCandidate(candidate, protection)) {
+        return null;
+    }
+    if (protection.callerHitIds.has(candidate.id)) {
+        const callerHitIndex = candidate.search_hits.findIndex((hit) => hit.preview.length > 0 &&
+            protection.callerTermIndexes.has(hit.search_term_index));
+        if (callerHitIndex >= 0) {
+            return { kind: "hit", index: callerHitIndex };
+        }
+    }
+    const rangeIndex = candidate.ranges.findIndex((range) => range.excerpt.length > 0);
+    if (rangeIndex >= 0) {
+        return { kind: "range", index: rangeIndex };
+    }
+    const hitIndex = candidate.search_hits.findIndex((hit) => hit.preview.length > 0);
+    if (hitIndex >= 0) {
+        return { kind: "hit", index: hitIndex };
+    }
+    return null;
+}
+function evictOneCompactionCandidate(packet, requestedCoverage, protection, mode) {
+    if (packet.candidates.length <= 1) {
+        return false;
+    }
+    for (let index = packet.candidates.length - 1; index >= 0; index -= 1) {
+        const candidate = packet.candidates[index];
+        if (candidate == null || isProtectedPacketCandidate(candidate, protection)) {
+            continue;
+        }
+        if (mode === "no_evidence" && candidateHasEvidence(candidate)) {
+            continue;
+        }
+        if (requestedCoverage.has(candidate.id) ||
+            wouldRemoveCuratorProposalSelection(packet, candidate.id) ||
+            wouldRemoveRequiredEvidenceClass(packet, candidate)) {
+            continue;
+        }
+        evictPacketCandidateAt(packet, index);
+        return true;
+    }
+    return false;
+}
+function evictPacketCandidateAt(packet, index) {
+    const candidate = packet.candidates[index];
+    if (candidate == null) {
+        return;
+    }
+    packet.candidates.splice(index, 1);
+    packet.metrics.candidates_included = packet.candidates.length;
+    packet.metrics.candidates_omitted_by_packet_cap += 1;
+    for (const range of candidate.ranges) {
+        packet.metrics.evidence_bytes -= Buffer.byteLength(range.excerpt, "utf8");
+    }
+    for (const hit of candidate.search_hits) {
+        packet.metrics.evidence_bytes -= Buffer.byteLength(hit.preview, "utf8");
+    }
+    packet.metrics.search_records_omitted_by_packet_cap += candidate.search_hits.length;
+    packet.metrics.slice_records_omitted_by_packet_cap += candidate.ranges.length;
+    pruneReferencesToCandidate(packet, candidate.id);
+}
+function dropOneEvidence(packet, protection) {
+    for (const candidate of [...packet.candidates].reverse()) {
+        const reserved = protection == null ? null : reservedEvidenceFor(candidate, protection);
+        for (let index = candidate.ranges.length - 1; index >= 0; index -= 1) {
+            if (reserved?.kind === "range" && reserved.index === index) {
+                continue;
+            }
+            const range = candidate.ranges[index];
+            if (range == null || range.excerpt.length === 0) {
+                continue;
+            }
+            packet.metrics.evidence_bytes -= Buffer.byteLength(range.excerpt, "utf8");
+            range.excerpt = "";
+            range.excerpt_truncated = true;
+            packet.metrics.evidence_byte_cap_hit = true;
+            return true;
+        }
+        for (let index = candidate.search_hits.length - 1; index >= 0; index -= 1) {
+            if (reserved?.kind === "hit" && reserved.index === index) {
+                continue;
+            }
+            const hit = candidate.search_hits[index];
+            if (hit == null || hit.preview.length === 0) {
+                continue;
+            }
+            packet.metrics.evidence_bytes -= Buffer.byteLength(hit.preview, "utf8");
+            hit.preview = "";
+            hit.preview_truncated = true;
+            packet.metrics.evidence_byte_cap_hit = true;
+            return true;
+        }
+    }
+    return false;
+}
+function dropOneCuratorProposalMetadata(packet) {
+    const proposal = packet.curator_proposal;
+    if (proposal == null) {
+        return false;
+    }
+    if (proposal.open_questions.pop() != null) {
+        return true;
+    }
+    if (proposal.warnings.pop() != null) {
+        return true;
+    }
+    for (const selection of [...proposal.selected].reverse()) {
+        for (const range of [...selection.ranges].reverse()) {
+            if (range.reason.length > 0) {
+                range.reason = "";
+                return true;
+            }
+        }
+        if (selection.reason.length > 0) {
+            selection.reason = "";
+            return true;
+        }
+    }
+    return false;
+}
+function dropOneCandidateRecord(packet, requestedCoverage, protection) {
+    for (const candidate of [...packet.candidates].reverse()) {
+        const reserved = protection == null ? null : reservedEvidenceFor(candidate, protection);
+        for (let index = candidate.search_hits.length - 1; index >= 0; index -= 1) {
+            if (reserved?.kind === "hit" && reserved.index === index) {
+                continue;
+            }
+            const hit = candidate.search_hits[index];
+            if (hit == null) {
+                continue;
+            }
+            candidate.search_hits.splice(index, 1);
+            packet.metrics.evidence_bytes -= Buffer.byteLength(hit.preview, "utf8");
+            packet.metrics.search_records_omitted_by_packet_cap += 1;
+            return true;
+        }
+        if (candidate.ranges.length > 1) {
+            for (let index = candidate.ranges.length - 1; index >= 0; index -= 1) {
+                if (reserved?.kind === "range" && reserved.index === index) {
+                    continue;
+                }
+                const range = candidate.ranges[index];
+                if (range == null) {
+                    continue;
+                }
+                const remaining = candidate.ranges.filter((_, rangeIndex) => rangeIndex !== index);
+                if (!curatorProposalStillCovered(packet, candidate.id, remaining) ||
+                    !requestedCoverageStillCovered(requestedCoverage, candidate.id, remaining)) {
+                    continue;
+                }
+                candidate.ranges.splice(index, 1);
+                packet.metrics.evidence_bytes -= Buffer.byteLength(range.excerpt, "utf8");
+                packet.metrics.slice_records_omitted_by_packet_cap += 1;
+                pruneReferencesToRange(packet, candidate.id, range.id);
+                return true;
+            }
+        }
+    }
+    return false;
+}
+function dropOneCandidate(packet, requestedCoverage) {
+    if (packet.candidates.length <= 1) {
+        return false;
+    }
+    for (let index = packet.candidates.length - 1; index >= 0; index -= 1) {
+        const candidate = packet.candidates[index];
+        if (candidate == null ||
+            requestedCoverage.has(candidate.id) ||
+            wouldRemoveCuratorProposalSelection(packet, candidate.id) ||
+            wouldRemoveRequiredEvidenceClass(packet, candidate)) {
+            continue;
+        }
+        evictPacketCandidateAt(packet, index);
+        return true;
+    }
+    return false;
+}
+function wouldRemoveRequiredEvidenceClass(packet, candidate) {
+    const required = new Set(packet.coverage_policy.required_when_available);
+    return candidate.evidence_classes.some((evidenceClass) => required.has(evidenceClass) &&
+        !packet.candidates.some((other) => other.id !== candidate.id &&
+            other.evidence_classes.includes(evidenceClass)));
+}
+function buildRequestedCoverageIndex(requestedCoverage) {
+    return new Map(requestedCoverage.map((coverage) => [coverage.candidate_id, coverage.ranges]));
+}
+function requestedCoverageStillCovered(requestedCoverage, candidateId, remainingRanges) {
+    const requiredRanges = requestedCoverage.get(candidateId);
+    if (requiredRanges == null || requiredRanges.length === 0) {
+        return true;
+    }
+    return requiredRanges.every((range) => isCoveredByPacketRanges(remainingRanges, range));
+}
+function curatorProposalStillCovered(packet, candidateId, remainingRanges) {
+    const proposalSelections = packet.curator_proposal?.selected.filter((selection) => selection.candidate_id === candidateId) ?? [];
+    return proposalSelections.every((selection) => selection.ranges.every((range) => isCoveredByPacketRanges(remainingRanges, range)));
+}
+function isCoveredByPacketRanges(ranges, target) {
+    let nextLine = target.start_line;
+    for (const range of [...ranges].sort((left, right) => left.start_line - right.start_line || left.end_line - right.end_line)) {
+        if (range.end_line < nextLine) {
+            continue;
+        }
+        if (range.start_line > nextLine) {
+            return false;
+        }
+        nextLine = Math.max(nextLine, range.end_line + 1);
+        if (nextLine > target.end_line) {
+            return true;
+        }
+    }
+    return false;
+}
+function wouldRemoveCuratorProposalSelection(packet, candidateId) {
+    const proposal = packet.curator_proposal;
+    if (proposal == null || proposal.selected.length === 0) {
+        return false;
+    }
+    return proposal.selected.some((selection) => selection.candidate_id === candidateId);
+}
+function syncSelectionSummariesToCandidateRanges(packet) {
+    const synced = buildCandidateRangeSelectionSummary(packet);
+    packet.deterministic_selection.selected = synced;
+    if (packet.local_selection_summary != null) {
+        packet.local_selection_summary.selected = synced.map((selection) => ({
+            ...selection,
+            ranges: selection.ranges.map((range) => ({ ...range })),
+        }));
+    }
+}
+function appendMissingRequestedCoverageOmissions(packet, requestedCoverage) {
+    if (requestedCoverage.length === 0) {
+        return;
+    }
+    const candidateById = new Map(packet.candidates.map((candidate) => [candidate.id, candidate]));
+    const existingRequestedOmissionPaths = new Set(packet.omissions
+        .filter(isRequestedEvidenceOmission)
+        .flatMap((omission) => omission.paths ?? []));
+    for (const coverage of requestedCoverage) {
+        const candidate = candidateById.get(coverage.candidate_id);
+        const missingRanges = candidate == null
+            ? coverage.ranges
+            : coverage.ranges.filter((range) => !isCoveredByPacketRanges(candidate.ranges, range));
+        if (missingRanges.length === 0 || existingRequestedOmissionPaths.has(coverage.path)) {
+            continue;
+        }
+        packet.omissions.push(requestedEvidenceOmission({
+            root_index: coverage.root_index,
+            kind: packet.metrics.packet_token_cap_hit
+                ? "packet_token_cap"
+                : "candidate_cap",
+            message: packet.metrics.packet_token_cap_hit
+                ? "focused or selected coverage was pruned from the delegate packet token budget"
+                : "focused or selected coverage could not be represented within delegate packet candidate caps",
+            paths: [coverage.path],
+        }));
+        existingRequestedOmissionPaths.add(coverage.path);
+    }
+}
+function syncCandidateCoverageToPacketRanges(packet) {
+    for (const candidate of packet.candidates) {
+        candidate.deterministic_ranges = (candidate.deterministic_ranges ?? []).filter((range) => isCoveredByPacketRanges(candidate.ranges, range));
+        candidate.uncovered_packet_ranges = (candidate.uncovered_packet_ranges ?? []).filter((range) => isCoveredByPacketRanges(candidate.ranges, range));
+        candidate.deterministic_coverage =
+            candidate.deterministic_ranges.length === 0
+                ? "none"
+                : candidate.uncovered_packet_ranges.length === 0
+                    ? "complete"
+                    : "partial";
+    }
+}
+function buildCandidateRangeSelectionSummary(packet) {
+    const existing = new Map(packet.deterministic_selection.selected.map((selection) => [
+        selection.candidate_id,
+        selection,
+    ]));
+    return packet.candidates
+        .filter((candidate) => candidate.deterministic_selected)
+        .map((candidate) => {
+        const ranges = (candidate.deterministic_ranges ?? []).filter((range) => isCoveredByPacketRanges(candidate.ranges, range));
+        if (ranges.length === 0) {
+            return undefined;
+        }
+        const prior = existing.get(candidate.id);
+        return {
+            candidate_id: candidate.id,
+            root_index: candidate.root_index,
+            path: candidate.path,
+            ranges: ranges.map((range) => ({
+                id: range.id,
+                start_line: range.start_line,
+                end_line: range.end_line,
+            })),
+            source: prior?.source ?? candidate.ranges[0]?.source ?? "search",
+            bytes: prior?.bytes ?? candidate.size_bytes,
+            estimated_tokens: prior?.estimated_tokens ?? candidate.estimated_tokens,
+        };
+    })
+        .filter((selection) => selection != null);
+}
+function pruneReferencesToRange(packet, candidateId, rangeId) {
+    pruneCandidateRangeReferences(packet, candidateId, rangeId);
+    pruneSelectionRangeReferences(packet.deterministic_selection.selected, candidateId, rangeId);
+    if (packet.local_selection_summary != null) {
+        pruneSelectionRangeReferences(packet.local_selection_summary.selected, candidateId, rangeId);
+    }
+}
+function pruneCandidateRangeReferences(packet, candidateId, rangeId) {
+    const candidate = packet.candidates.find((item) => item.id === candidateId);
+    if (candidate == null) {
+        return;
+    }
+    candidate.deterministic_ranges = (candidate.deterministic_ranges ?? []).filter((range) => range.id !== rangeId);
+    candidate.uncovered_packet_ranges = (candidate.uncovered_packet_ranges ?? []).filter((range) => range.id !== rangeId);
+    candidate.deterministic_coverage =
+        candidate.deterministic_ranges.length === 0
+            ? "none"
+            : candidate.uncovered_packet_ranges.length === 0
+                ? "complete"
+                : "partial";
+}
+function pruneSelectionRangeReferences(selections, candidateId, rangeId) {
+    for (let index = selections.length - 1; index >= 0; index -= 1) {
+        const selection = selections[index];
+        if (selection == null || selection.candidate_id !== candidateId) {
+            continue;
+        }
+        selection.ranges = selection.ranges.filter((range) => range.id !== rangeId);
+        if (selection.ranges.length === 0) {
+            selections.splice(index, 1);
+        }
+    }
+}
+function pruneReferencesToCandidate(packet, candidateId) {
+    packet.deterministic_selection.selected =
+        packet.deterministic_selection.selected.filter((selection) => selection.candidate_id !== candidateId);
+    if (packet.local_selection_summary != null) {
+        packet.local_selection_summary.selected =
+            packet.local_selection_summary.selected.filter((selection) => selection.candidate_id !== candidateId);
+    }
+    if (packet.curator_proposal != null) {
+        packet.curator_proposal.selected = packet.curator_proposal.selected.filter((selection) => selection.candidate_id !== candidateId);
+    }
+}
+function takeEvidenceText(text, maxBytes, state) {
+    if (state.evidenceBytes >= state.caps.max_total_evidence_bytes) {
+        state.evidenceByteCapHit = true;
+        return { text: "", truncated: true };
+    }
+    const remaining = state.caps.max_total_evidence_bytes - state.evidenceBytes;
+    const bounded = sanitizePacketText(text, Math.min(maxBytes, remaining), state.allowSecrets);
+    state.evidenceBytes += Buffer.byteLength(bounded.text, "utf8");
+    if (bounded.truncated || state.evidenceBytes >= state.caps.max_total_evidence_bytes) {
+        state.evidenceByteCapHit = true;
+    }
+    return bounded;
+}
+function sanitizePacketText(text, maxBytes, allowSecrets) {
+    const secretSafe = !allowSecrets && hasConservativeResidualSecret(text)
+        ? "[redacted-sensitive]"
+        : redactAbsolutePaths(text);
+    return boundUtf8(secretSafe.replace(/\u0000/g, "?"), maxBytes);
+}
+function boundUtf8(text, maxBytes) {
+    const safeMax = Math.max(0, maxBytes);
+    let output = "";
+    let bytes = 0;
+    for (const char of text) {
+        const charBytes = Buffer.byteLength(char, "utf8");
+        if (bytes + charBytes > safeMax) {
+            return { text: output, truncated: true };
+        }
+        output += char;
+        bytes += charBytes;
+    }
+    return { text: output, truncated: false };
+}
+function normalizePacketPath(input, allowSecrets) {
+    if (input.includes("\u0000") ||
+        input.startsWith("/") ||
+        input.startsWith("\\") ||
+        /^[A-Za-z]:[\\/]/.test(input)) {
+        return undefined;
+    }
+    try {
+        const normalized = normalizeContextBuilderRootRelativePath(input);
+        if (normalized === "" ||
+            (!allowSecrets && scanSecretPath(normalized).length > 0)) {
+            return undefined;
+        }
+        return normalized;
+    }
+    catch {
+        return undefined;
+    }
+}
+function normalizeCaps(caps, budget) {
+    const merged = {
+        ...CONTEXT_BUILDER_DELEGATE_PACKET_CAP_DEFAULTS,
+        max_packet_estimated_tokens: Math.min(budget.target_estimated_tokens, CONTEXT_BUILDER_DELEGATE_PACKET_CAP_DEFAULTS.max_packet_estimated_tokens),
+        ...caps,
+    };
+    return {
+        max_candidates: positiveInteger(merged.max_candidates),
+        max_search_records: positiveInteger(merged.max_search_records),
+        max_slice_records: positiveInteger(merged.max_slice_records),
+        max_omissions: positiveInteger(merged.max_omissions),
+        max_paths_per_omission: positiveInteger(merged.max_paths_per_omission),
+        max_total_evidence_bytes: positiveInteger(merged.max_total_evidence_bytes),
+        max_preview_bytes: positiveInteger(merged.max_preview_bytes),
+        max_slice_excerpt_bytes: positiveInteger(merged.max_slice_excerpt_bytes),
+        max_task_chars: positiveInteger(merged.max_task_chars),
+        max_packet_estimated_tokens: positiveInteger(merged.max_packet_estimated_tokens),
+    };
+}
+function normalizeCoveragePolicy(policy, obligations, caps) {
+    if (policy?.id !== "review_deep_v1") {
+        return { policy_id: null, required_when_available: [] };
+    }
+    return {
+        policy_id: policy.id,
+        required_when_available: orderEvidenceClasses(policy.required_when_available),
+        ...(obligations == null
+            ? {}
+            : {
+                obligations: {
+                    targets: obligations.targets.slice(0, caps.max_candidates).map((target) => ({
+                        ...target,
+                        ranges: target.ranges.slice(0, caps.max_paths_per_omission),
+                        regression_links: target.regression_links
+                            .slice(0, caps.max_candidates)
+                            .map((link) => ({
+                            ...link,
+                            ranges: link.ranges.slice(0, caps.max_paths_per_omission),
+                        })),
+                    })),
+                },
+            }),
+    };
+}
+function orderCandidateSeedsForCoverage(seeds, policy) {
+    if (policy.policy_id === null || policy.required_when_available.length === 0) {
+        return [...seeds];
+    }
+    const ordered = [];
+    const included = new Set();
+    for (const target of policy.obligations?.targets ?? []) {
+        for (const candidateId of [
+            target.candidate_id,
+            ...target.regression_links.map((link) => link.candidate_id),
+        ]) {
+            const seed = seeds.find((candidate) => candidate.id === candidateId);
+            if (seed != null && !included.has(seed.id)) {
+                ordered.push(seed);
+                included.add(seed.id);
+            }
+        }
+    }
+    for (const evidenceClass of policy.required_when_available) {
+        if (ordered.some((seed) => seed.evidence_classes.includes(evidenceClass))) {
+            continue;
+        }
+        const representative = seeds.find((seed) => seed.evidence_classes.includes(evidenceClass));
+        if (representative != null && !included.has(representative.id)) {
+            ordered.push(representative);
+            included.add(representative.id);
+        }
+    }
+    for (const seed of seeds) {
+        if (!included.has(seed.id)) {
+            ordered.push(seed);
+        }
+    }
+    return ordered;
+}
+function positiveInteger(value) {
+    return Number.isSafeInteger(value) && value > 0 ? value : 1;
+}
+function discoveryReason(ranges, searchHits) {
+    if (ranges.some((range) => range.source === "focus")) {
+        return "focus_path";
+    }
+    if (searchHits.length > 0 || ranges.some((range) => range.source === "search")) {
+        return "search_hit";
+    }
+    return "eligible_candidate";
+}
+function candidateKey(rootIndex, path) {
+    return `${rootIndex}\u0000${path}`;
+}
+function isValidRange(startLine, endLine, lineCount) {
+    return lineCount > 0 && startLine >= 1 && endLine >= startLine && endLine <= lineCount;
+}
+function isValidLine(line, lineCount) {
+    return lineCount > 0 && line >= 1 && line <= lineCount;
+}
+function estimatePacketTokens(packet) {
+    return estimateContextBuilderTokensFromUtf8Bytes(estimatePacketJsonBytes(packet));
+}
+function estimatePacketJsonBytes(packet) {
+    return Buffer.byteLength(JSON.stringify(packet), "utf8");
+}
+function redactAbsolutePaths(text) {
+    return text
+        .replace(/\b[A-Za-z]:[\\/][^\s"'`)]+/g, "[redacted-absolute-path]")
+        .replace(/(^|[\s"'(])(\/[^\s"'`)]+)/g, (_match, boundary, token) => {
+        // Compact comments and slash-led paths share the same token shape, so
+        // classify the complete token instead of inferring intent via lookahead.
+        if (token === "/*") {
+            return `${boundary}${token}`;
+        }
+        if (token.startsWith("/*") && token[2] !== "/") {
+            const closeIndex = token.indexOf("*/", 2);
+            if (closeIndex >= 0) {
+                const commentEnd = closeIndex + 2;
+                const suffix = token.slice(commentEnd);
+                return /^[\\/]/.test(suffix)
+                    ? `${boundary}${token.slice(0, commentEnd)}[redacted-absolute-path]`
+                    : `${boundary}${token}`;
+            }
+        }
+        // A bare //host is indistinguishable from //comment; preserving it is
+        // an accepted residual limitation needed for compact comment fidelity.
+        if (/^\/\/[^/\\]*$/.test(token)) {
+            return `${boundary}${token}`;
+        }
+        return `${boundary}[redacted-absolute-path]`;
+    });
+}
+function compareCandidateSeeds(left, right) {
+    return (booleanRank(right.has_focus_evidence) - booleanRank(left.has_focus_evidence) ||
+        booleanRank(right.deterministic_selected) -
+            booleanRank(left.deterministic_selected) ||
+        left.deterministic_rank - right.deterministic_rank ||
+        booleanRank(right.has_slice_evidence) - booleanRank(left.has_slice_evidence) ||
+        booleanRank(right.has_search_evidence) - booleanRank(left.has_search_evidence) ||
+        left.root_index - right.root_index ||
+        left.path.localeCompare(right.path));
+}
+function booleanRank(value) {
+    return value ? 1 : 0;
+}
+function compareSlicesForPacket(left, right) {
+    return (left.root_index - right.root_index ||
+        left.path.localeCompare(right.path) ||
+        left.start_line - right.start_line ||
+        left.end_line - right.end_line ||
+        sourceRank(left.source) - sourceRank(right.source) ||
+        (left.search_term_index ?? Number.MAX_SAFE_INTEGER) -
+            (right.search_term_index ?? Number.MAX_SAFE_INTEGER));
+}
+function compareSearchForPacket(left, right) {
+    return (left.root_index - right.root_index ||
+        left.path.localeCompare(right.path) ||
+        left.line - right.line ||
+        left.column - right.column ||
+        left.search_term_index - right.search_term_index);
+}
+function comparePacketSelections(left, right) {
+    return left.root_index - right.root_index || left.path.localeCompare(right.path);
+}
+function sourceRank(source) {
+    return source === "focus" ? 0 : 1;
+}
+//# sourceMappingURL=delegate-packet.js.map