clinkx 0.2.3 → 1.0.0

package/dist/context-builder/bundle.js

@@ -0,0 +1,1498 @@
+import { boundContextBuilderOmissions, boundContextBuilderPathList, boundContextBuilderWarnings, sanitizeDiagnosticText, } from "./diagnostics.js";
+import { createContextBuilderReceipt, cloneContextBuilderDelegateReceiptMetadata, } from "./receipt.js";
+import { assertTaskSecretsGated, hasConservativeResidualSecret, } from "./secrets.js";
+import { capEventsFromContextBuilderMetrics, reduceContextBuilderStatus, } from "./status.js";
+import { writeContextBuilderArtifactsAndCommit, } from "./storage.js";
+import { contextBuilderTokenCountingMethod, estimateContextBuilderTokens, } from "./token-estimate.js";
+import { contextBuilderInternalCapsForManifest, } from "./config.js";
+import { buildFileCodemap, remapCodemapToSourceCoordinates, renderCodemapJsonl, } from "./codemap.js";
+// Folded into the cache key so bundle markdown format changes invalidate stale cache entries.
+export const CONTEXT_BUILDER_RENDERER_VERSION = 2;
+export function renderContextBuilderBundle(input) {
+    const allowSecrets = input.allowSecrets ?? true;
+    assertTaskSecretsGated(input.task, allowSecrets);
+    const selected = input.selected_context.map((file) => sanitizeSelectedFile(file, allowSecrets));
+    const tree = input.tree.map((file) => sanitizeTreeFile(file, allowSecrets));
+    const search = input.search.map((record) => sanitizeSearchRecord(record, allowSecrets));
+    const slices = input.slices.map((record) => sanitizeSliceRecord(record, allowSecrets));
+    const presentationSelected = promoteTaskPresentationEvidence(filterTaskPresentationSelected(selected, input.task), input.task, slices);
+    const omissions = boundContextBuilderOmissions([...(input.omissions ?? [])], contextBuilderInternalCapsForManifest(input.internal_caps));
+    const warnings = boundContextBuilderWarnings([...(input.warnings ?? [])], contextBuilderInternalCapsForManifest(input.internal_caps));
+    const presentationOmissions = reconcileSelectedOmissions(filterTaskPresentationOmissions(omissions, input.task), presentationSelected);
+    const openQuestions = buildPresentationOpenQuestions(boundOpenQuestions(input.open_questions ?? []), presentationSelected, presentationOmissions);
+    const showRootLabels = input.roots.length > 1;
+    return [
+        "# Context Bundle",
+        "",
+        "## Original Task",
+        "",
+        input.task,
+        "",
+        "## How To Use This Bundle",
+        "",
+        "- Start with top must-read ranges and verify the cited evidence directly.",
+        "- Inspect selected files, repository shape, and search evidence before editing.",
+        "- Treat omissions and open questions as follow-up checks, not as resolved facts.",
+        "",
+        "## Top Must-Read Ranges",
+        "",
+        renderTopMustReadRanges({
+            task: input.task,
+            selected: presentationSelected,
+            search,
+            showRootLabels,
+        }),
+        "",
+        "## Selected Files",
+        "",
+        renderSelectedFilesList({
+            task: input.task,
+            selected: presentationSelected,
+            search,
+            showRootLabels,
+        }),
+        "",
+        "## Repository Shape",
+        "",
+        renderRepositoryShape({
+            tree,
+            selected: presentationSelected,
+            showRootLabels,
+        }),
+        "",
+        "## Search Evidence",
+        "",
+        renderSearchEvidence({
+            search,
+            selected: presentationSelected,
+            showRootLabels,
+        }),
+        "",
+        "## File Context",
+        "",
+        renderFileContext(presentationSelected, search, showRootLabels),
+        "",
+        "## Open Questions",
+        "",
+        renderOpenQuestions(openQuestions),
+        "",
+        "## Omissions And Budget Notes",
+        "",
+        renderOmissionsAndBudgetNotes({
+            omissions: presentationOmissions,
+            warnings,
+            metrics: input.metrics,
+        }),
+        "",
+    ].join("\n");
+}
+export function buildContextBuilderStatus(input) {
+    return reduceContextBuilderStatus(buildContextBuilderStatusEvidence(input));
+}
+export function buildContextBuilderStatusEvidence(input, boundedDiagnostics = {}) {
+    const omissions = boundedDiagnostics.omissions ?? input.omissions ?? [];
+    const warnings = boundedDiagnostics.warnings ?? input.warnings ?? [];
+    return {
+        ...(input.status_evidence ?? {}),
+        omissions: [
+            ...omissions.map(omissionEventFromDiagnostic),
+            ...(input.status_evidence?.omissions ?? []),
+        ],
+        warnings: [
+            ...warnings.map(warningEventFromDiagnostic),
+            ...(input.status_evidence?.warnings ?? []),
+        ],
+        caps: [
+            ...capEventsFromContextBuilderMetrics(input.metrics, input.search_coverage == null
+                ? {}
+                : { search_coverage: input.search_coverage }),
+            ...(input.status_evidence?.caps ?? []),
+        ],
+        storage: [
+            ...(input.metrics.truncated
+                ? [{ reason: "artifact_truncated" }]
+                : []),
+            ...(input.status_evidence?.storage ?? []),
+        ],
+        delegate: [
+            ...(input.delegate?.fallback_used === true
+                ? [{ reason: "delegate_fallback", fallback: true }]
+                : []),
+            ...(input.status_evidence?.delegate ?? []),
+        ],
+    };
+}
+export function renderContextBuilderArtifactContents(input) {
+    const allowSecrets = input.allowSecrets ?? true;
+    assertTaskSecretsGated(input.task, allowSecrets);
+    const tree = input.tree.map((file) => sanitizeTreeFile(file, allowSecrets));
+    const search = input.search.map((record) => sanitizeSearchRecord(record, allowSecrets));
+    const slices = input.slices.map((record) => sanitizeSliceRecord(record, allowSecrets));
+    const selectedContext = input.selected_context.map((file) => sanitizeSelectedFile(file, allowSecrets));
+    const summary = buildContextBuilderSummary(input);
+    return {
+        bundle_md: renderContextBuilderBundle(input),
+        selected_context_jsonl: renderSelectedContextJsonl(selectedContext),
+        tree_json: `${JSON.stringify({
+            schema_version: 1,
+            roots: input.roots.map((root) => sanitizeRoot(root, allowSecrets)),
+            files: tree,
+        })}\n`,
+        search_jsonl: renderJsonl(search),
+        slices_jsonl: renderJsonl(slices),
+        codemap_jsonl: renderCodemapJsonl(selectedContext.map((file) => remapCodemapToSourceCoordinates(buildFileCodemap(file.path, file.content), file.ranges))),
+        summary_json: `${JSON.stringify({
+            ...summary,
+            selected_context: selectedContext.map(stripSelectedContent),
+        })}\n`,
+    };
+}
+export function buildContextBuilderManifestDraft(input) {
+    const allowSecrets = input.allowSecrets ?? true;
+    const internalCaps = contextBuilderInternalCapsForManifest(input.internal_caps);
+    const omissions = boundContextBuilderOmissions([...(input.omissions ?? [])], internalCaps);
+    const warnings = boundContextBuilderWarnings([...(input.warnings ?? [])], internalCaps);
+    const status = reduceContextBuilderStatus(buildContextBuilderStatusEvidence(input));
+    return {
+        status,
+        created_at: input.created_at,
+        task: validateTaskForRendering(input.task, allowSecrets),
+        // Echo the RESOLVED secret profile (per-call > workflow > env > true) so
+        // artifact-only readers do not have to infer it from omission behavior.
+        // Additive: manifest validation is required-key based and every known
+        // reader picks named keys.
+        allow_secrets_resolved: allowSecrets,
+        roots: input.roots.map((root) => sanitizeRoot(root, allowSecrets)),
+        inputs: sanitizeJsonValue(input.inputs, allowSecrets),
+        budget: { ...input.budget },
+        internal_caps: internalCaps,
+        token_counting: contextBuilderTokenCountingMethod(),
+        selected_context: input.selected_context
+            .map((file) => sanitizeSelectedFile(file, allowSecrets))
+            .map(stripSelectedContent),
+        omissions,
+        warnings,
+        metrics: { ...input.metrics },
+        ...(input.search_coverage == null
+            ? {}
+            : {
+                search_coverage: sanitizeSearchCoverage(input.search_coverage, allowSecrets),
+            }),
+        ...(input.coverage == null ? {} : { coverage: input.coverage }),
+        ...(input.parent_run_id == null
+            ? {}
+            : { parent_run_id: input.parent_run_id }),
+        ...(input.refine_ops == null
+            ? {}
+            : { refine_ops: input.refine_ops.map((op) => ({ ...op })) }),
+        ...(input.file_fingerprints == null
+            ? {}
+            : {
+                file_fingerprints: input.file_fingerprints.map((fingerprint) => ({
+                    ...fingerprint,
+                })),
+            }),
+        ...(input.delegate == null
+            ? {}
+            : { delegate: cloneContextBuilderDelegateReceiptMetadata(input.delegate) }),
+        ...(input.observability == null
+            ? {}
+            : { observability: { ...input.observability } }),
+        ...(input.debug === true
+            ? {
+                debug_diagnostics: boundDebugDiagnostics(input.debug_diagnostics, internalCaps),
+            }
+            : {}),
+    };
+}
+export async function writeContextBuilderFinalArtifacts(storage, input, options = {}) {
+    const { contents, metrics } = renderContentsWithStableByteMetric(input);
+    const writeInput = { ...input, metrics };
+    await writeContextBuilderArtifactsAndCommit(storage, contents, buildContextBuilderManifestDraft(writeInput), {
+        ...(options.signal == null ? {} : { signal: options.signal }),
+        ...(options.ownerNonce == null ? {} : { ownerNonce: options.ownerNonce }),
+        ...(options.ops == null ? {} : { ops: options.ops }),
+        ...(options.beforeManifestCommit == null
+            ? {}
+            : { beforeManifestCommit: options.beforeManifestCommit }),
+    });
+    const internalCaps = contextBuilderInternalCapsForManifest(input.internal_caps);
+    const warnings = boundContextBuilderWarnings(input.warnings == null ? [] : [...input.warnings], internalCaps);
+    const omissions = boundContextBuilderOmissions(input.omissions == null ? [] : [...input.omissions], internalCaps);
+    return createContextBuilderReceipt({
+        run_id: storage.runId,
+        status: reduceContextBuilderStatus(buildContextBuilderStatusEvidence({ ...input, metrics })),
+        artifact_dir: storage.artifactDir,
+        artifacts: storage.artifacts,
+        metrics,
+        warnings,
+        omissions,
+        ...(input.delegate == null
+            ? {}
+            : { delegate: cloneContextBuilderDelegateReceiptMetadata(input.delegate) }),
+    });
+}
+function renderContentsWithStableByteMetric(input) {
+    let metrics = { ...input.metrics, bytes_written: 0 };
+    let contents = renderContextBuilderArtifactContents({ ...input, metrics });
+    for (let attempt = 0; attempt < 4; attempt += 1) {
+        const bytesWritten = Object.values(contents).reduce((total, content) => total + Buffer.byteLength(content, "utf8"), 0);
+        const nextMetrics = { ...metrics, bytes_written: bytesWritten };
+        const nextContents = renderContextBuilderArtifactContents({
+            ...input,
+            metrics: nextMetrics,
+        });
+        if (bytesWritten === metrics.bytes_written &&
+            JSON.stringify(nextContents) === JSON.stringify(contents)) {
+            return { contents, metrics };
+        }
+        metrics = nextMetrics;
+        contents = nextContents;
+    }
+    return { contents, metrics };
+}
+function buildContextBuilderSummary(input) {
+    const allowSecrets = input.allowSecrets ?? true;
+    const selected = input.selected_context.map((file) => sanitizeSelectedFile(file, allowSecrets));
+    const omissions = reconcileSelectedOmissions(filterTaskPresentationOmissions(boundContextBuilderOmissions([...(input.omissions ?? [])], contextBuilderInternalCapsForManifest(input.internal_caps)), input.task), selected);
+    const openQuestions = buildPresentationOpenQuestions(boundOpenQuestions(input.open_questions ?? []), selected, omissions);
+    return {
+        schema_version: 1,
+        run_id: input.run_id,
+        created_at: input.created_at,
+        status: reduceContextBuilderStatus(buildContextBuilderStatusEvidence(input)),
+        // Mirror of the manifest's resolved secret-profile echo, so summary-only
+        // readers get the same explicit benchmark/run profile.
+        allow_secrets_resolved: allowSecrets,
+        token_counting: contextBuilderTokenCountingMethod(),
+        metrics: { ...input.metrics },
+        selected_file_count: input.selected_context.length,
+        warning_count: input.warnings?.length ?? 0,
+        omission_count: omissions.length,
+        open_questions: openQuestions,
+        ...(input.search_coverage == null
+            ? {}
+            : {
+                search_coverage: sanitizeSearchCoverage(input.search_coverage, allowSecrets),
+            }),
+        ...(input.delegate == null
+            ? {}
+            : { delegate: cloneContextBuilderDelegateReceiptMetadata(input.delegate) }),
+    };
+}
+function sanitizeRoot(root, allowSecrets) {
+    return {
+        root_index: root.root_index,
+        ...(root.input_path == null
+            ? {}
+            : { input_path: safePath(root.input_path, allowSecrets) }),
+        path: safePath(root.path, allowSecrets),
+    };
+}
+function sanitizeTreeFile(file, allowSecrets) {
+    return {
+        root_index: file.root_index,
+        path: safePath(file.path, allowSecrets),
+        size_bytes: file.size_bytes,
+        eligible: file.eligible,
+        content_eligible: file.content_eligible,
+        ...(file.omission_reason == null
+            ? {}
+            : { omission_reason: sanitizeDiagnosticText(file.omission_reason) }),
+    };
+}
+function sanitizeSearchRecord(record, allowSecrets) {
+    return {
+        root_index: record.root_index,
+        path: safePath(record.path, allowSecrets),
+        line: record.line,
+        column: record.column,
+        search_term: sanitizeDiagnosticText(record.search_term, allowSecrets),
+        search_term_index: record.search_term_index,
+        preview: safeContent(record.preview, allowSecrets),
+    };
+}
+// Defensive bound matching the public caller search-term cap; T1's coverage
+// rows are already bounded by it, so this only guards a malformed producer.
+const MAX_SEARCH_COVERAGE_CALLER_TERM_ROWS = 20;
+function sanitizeSearchCoverage(coverage, allowSecrets) {
+    return {
+        eligible_candidate_count: coverage.eligible_candidate_count,
+        searched_candidate_count: coverage.searched_candidate_count,
+        unsearched_candidate_count: coverage.unsearched_candidate_count,
+        caller_term_count: coverage.caller_term_count,
+        derived_term_count: coverage.derived_term_count,
+        caller_record_count: coverage.caller_record_count,
+        derived_record_count: coverage.derived_record_count,
+        caller_coverage_complete: coverage.caller_coverage_complete,
+        caller_terms: coverage.caller_terms
+            .slice(0, MAX_SEARCH_COVERAGE_CALLER_TERM_ROWS)
+            .map((term) => ({
+            term: sanitizeDiagnosticText(term.term, allowSecrets),
+            search_term_index: term.search_term_index,
+            hit_count: term.hit_count,
+            scan_complete: term.scan_complete,
+        })),
+    };
+}
+function sanitizeSliceRecord(record, allowSecrets) {
+    return {
+        root_index: record.root_index,
+        path: safePath(record.path, allowSecrets),
+        start_line: record.start_line,
+        end_line: record.end_line,
+        source: record.source,
+        content: safeContent(record.content, allowSecrets),
+        ...(record.search_term_index == null
+            ? {}
+            : { search_term_index: record.search_term_index }),
+    };
+}
+function sanitizeSelectedFile(file, allowSecrets) {
+    return {
+        root_index: file.root_index,
+        path: safePath(file.path, allowSecrets),
+        ranges: file.ranges.map(sanitizeRange),
+        content: safeContent(file.content, allowSecrets),
+        bytes: file.bytes,
+        estimated_tokens: file.estimated_tokens > 0
+            ? file.estimated_tokens
+            : estimateContextBuilderTokens(file.content),
+        source: file.source,
+        ...(file.disposition == null ? {} : { disposition: file.disposition }),
+    };
+}
+function sanitizeRange(range) {
+    return {
+        start_line: range.start_line,
+        end_line: range.end_line,
+    };
+}
+function stripSelectedContent(file) {
+    return {
+        root_index: file.root_index,
+        path: file.path,
+        ranges: file.ranges.map(sanitizeRange),
+        bytes: file.bytes,
+        estimated_tokens: file.estimated_tokens,
+        source: file.source,
+        ...(file.disposition == null ? {} : { disposition: file.disposition }),
+    };
+}
+function renderSelectedFilesList(input) {
+    const { task, selected, search, showRootLabels } = input;
+    if (selected.length === 0) {
+        return "- None selected.";
+    }
+    const visible = selected.slice(0, 18);
+    const hiddenCount = selected.length - visible.length;
+    const rendered = visible
+        .map((file) => {
+        return [
+            `- ${renderRootPrefix(file.root_index, showRootLabels)}${file.path} (${file.source})`,
+            `  purpose: ${selectedFilePurpose(task, file, search)}`,
+        ].join("\n");
+    })
+        .join("\n");
+    return hiddenCount > 0
+        ? `${rendered}\n- ${hiddenCount} more selected files are listed in manifest.json and selected-context.jsonl.`
+        : rendered;
+}
+function selectedFilePurpose(_task, file, search) {
+    const source = file.source === "focus" ? "requested focus evidence" : "matched task anchors";
+    const clauses = [
+        source,
+        pathPurpose(file.path),
+        rangePurpose(file.ranges),
+    ];
+    const symbols = selectedFileSymbols(file);
+    if (symbols.length > 0) {
+        clauses.push(`symbols: ${symbols.join(", ")}`);
+    }
+    else {
+        const terms = selectedFileSearchTerms(file, search);
+        if (terms.length > 0) {
+            clauses.push(`search-backed slice`);
+        }
+    }
+    return `${clauses.join("; ")}.`;
+}
+function selectedFileRangeNotes(task, file, search) {
+    const sourceLines = splitSelectedFileContentByRange(file);
+    const searchTerms = selectedFileSearchTerms(file, search);
+    return file.ranges.slice(0, 4).map((range, index) => {
+        const symbols = symbolsFromLines(sourceLines[index] ?? []);
+        const rangeHits = search.filter((record) => record.root_index === file.root_index &&
+            record.path === file.path &&
+            record.line >= range.start_line &&
+            record.line <= range.end_line);
+        const label = range.start_line === range.end_line
+            ? `${range.start_line}`
+            : `${range.start_line}-${range.end_line}`;
+        return `${label}: ${rangeEvidenceSummary({
+            task,
+            path: file.path,
+            source: file.source,
+            symbols,
+            searchTerms,
+            rangeHits,
+        })}`;
+    });
+}
+function rangeEvidenceSummary(input) {
+    const hitSummary = rangeHitSummary(input.rangeHits ?? []);
+    if (hitSummary != null) {
+        return hitSummary;
+    }
+    if (input.searchTerms.length > 0) {
+        return `${pathPurpose(input.path)} selected by matching task evidence`;
+    }
+    if (input.symbols.length > 0) {
+        return `${input.source} evidence around ${input.symbols.slice(0, 4).join(", ")}`;
+    }
+    return "bounded supporting evidence for the task";
+}
+function rangeHitSummary(hits) {
+    if (hits.length === 0) {
+        return undefined;
+    }
+    const byTerm = new Map();
+    for (const hit of hits) {
+        const term = hit.search_term.trim();
+        if (term.length === 0) {
+            continue;
+        }
+        const lines = byTerm.get(term) ?? [];
+        if (!lines.includes(hit.line)) {
+            lines.push(hit.line);
+        }
+        byTerm.set(term, lines);
+        if (byTerm.size >= 3) {
+            break;
+        }
+    }
+    const rendered = [...byTerm.entries()]
+        .slice(0, 3)
+        .map(([term, lines]) => `"${term}" at ${lines.slice(0, 3).join(",")}`);
+    return rendered.length === 0 ? undefined : `matches ${rendered.join("; ")}`;
+}
+function selectedFileSymbols(file) {
+    return symbolsFromLines(splitTextLinesForBundle(file.content)).slice(0, 6);
+}
+function splitSelectedFileContentByRange(file) {
+    const lines = splitTextLinesForBundle(file.content);
+    if (file.ranges.length <= 1) {
+        return [lines];
+    }
+    const totalRangeLines = file.ranges.reduce((total, range) => total + Math.max(0, range.end_line - range.start_line + 1), 0);
+    if (totalRangeLines !== lines.length) {
+        return file.ranges.map(() => []);
+    }
+    const output = [];
+    let offset = 0;
+    for (const range of file.ranges) {
+        const count = Math.max(0, range.end_line - range.start_line + 1);
+        output.push(lines.slice(offset, offset + count));
+        offset += count;
+    }
+    return output;
+}
+function renderSelectedContextJsonl(selected) {
+    return renderJsonl(selected.flatMap((file) => {
+        const rangeBodies = splitSelectedFileContentByRange(file);
+        return file.ranges.map((range, index) => ({
+            root_index: file.root_index,
+            path: file.path,
+            start_line: range.start_line,
+            end_line: range.end_line,
+            source: file.source,
+            ...(file.disposition == null ? {} : { disposition: file.disposition }),
+            content: isCodemapOnlyDisposition(file.disposition)
+                ? ""
+                : (rangeBodies[index] ?? []).join("\n"),
+        }));
+    }));
+}
+function splitTextLinesForBundle(text) {
+    if (text.length === 0) {
+        return [];
+    }
+    const withoutFinalNewline = text.endsWith("\n")
+        ? text.slice(0, text.endsWith("\r\n") ? -2 : -1)
+        : text;
+    return withoutFinalNewline.length === 0
+        ? [""]
+        : withoutFinalNewline.split(/\r\n|\n/);
+}
+function symbolsFromLines(lines) {
+    const symbols = [];
+    const seen = new Set();
+    for (const line of lines) {
+        for (const symbol of symbolsFromLine(line)) {
+            if (seen.has(symbol)) {
+                continue;
+            }
+            seen.add(symbol);
+            symbols.push(symbol);
+            if (symbols.length >= 8) {
+                return symbols;
+            }
+        }
+    }
+    return symbols;
+}
+function symbolsFromLine(line) {
+    const patterns = [
+        /\b(?:async\s+)?(?:def|function|class)\s+([A-Za-z_][A-Za-z0-9_]*)/g,
+        /\b(?:const|let|var)\s+([A-Za-z_][A-Za-z0-9_]*)\s*=/g,
+        /\bexport\s+(?:async\s+)?(?:function|class|const)\s+([A-Za-z_][A-Za-z0-9_]*)/g,
+        /\bit\(\s*['"]([^'"]{8,90})['"]/g,
+        /\bdescribe\(\s*['"]([^'"]{8,90})['"]/g,
+    ];
+    const symbols = [];
+    for (const pattern of patterns) {
+        for (const match of line.matchAll(pattern)) {
+            const value = match[1]?.trim();
+            if (value != null && value.length > 0) {
+                symbols.push(value);
+            }
+        }
+    }
+    return symbols;
+}
+function selectedFileSearchTerms(file, search) {
+    const terms = [];
+    const seen = new Set();
+    for (const record of search) {
+        if (record.root_index !== file.root_index || record.path !== file.path) {
+            continue;
+        }
+        const term = record.search_term.trim();
+        if (term.length === 0 || seen.has(term)) {
+            continue;
+        }
+        seen.add(term);
+        terms.push(term);
+        if (terms.length >= 4) {
+            break;
+        }
+    }
+    return terms;
+}
+function pathPurpose(path) {
+    const normalized = path.toLowerCase();
+    const basename = normalized.split("/").at(-1) ?? normalized;
+    const language = languagePurpose(basename);
+    if (isTestPath(normalized, basename)) {
+        return `${language} test coverage`;
+    }
+    if (normalized.startsWith("docs/") || normalized.includes("/docs/")) {
+        return `${language} documentation`;
+    }
+    if (isClosurePath(normalized)) {
+        return `${language} contract or configuration`;
+    }
+    if (normalized.startsWith("frontend/") || normalized.includes("/frontend/")) {
+        return `${language} frontend implementation`;
+    }
+    if (normalized.startsWith("backend/") || normalized.includes("/backend/")) {
+        return `${language} backend implementation`;
+    }
+    if (normalized.startsWith("src/") || normalized.includes("/src/")) {
+        return `${language} source implementation`;
+    }
+    return `${language} selected context`;
+}
+function languagePurpose(basename) {
+    if (basename.endsWith(".tsx")) {
+        return "TSX";
+    }
+    if (basename.endsWith(".ts")) {
+        return "TypeScript";
+    }
+    if (basename.endsWith(".jsx")) {
+        return "JSX";
+    }
+    if (basename.endsWith(".js")) {
+        return "JavaScript";
+    }
+    if (basename.endsWith(".py")) {
+        return "Python";
+    }
+    if (basename.endsWith(".rs")) {
+        return "Rust";
+    }
+    if (basename.endsWith(".md") || basename.endsWith(".mdx")) {
+        return "Markdown";
+    }
+    if (basename.endsWith(".json")) {
+        return "JSON";
+    }
+    if (basename.endsWith(".yml") || basename.endsWith(".yaml")) {
+        return "YAML";
+    }
+    return "file";
+}
+function isTestPath(path, basename) {
+    return (path.startsWith("test/") ||
+        path.startsWith("tests/") ||
+        path.includes("/test/") ||
+        path.includes("/tests/") ||
+        path.includes("/__tests__/") ||
+        basename.includes(".test.") ||
+        basename.includes(".spec.") ||
+        basename.startsWith("test_"));
+}
+function rangePurpose(ranges) {
+    if (ranges.length === 0) {
+        return "full-file context";
+    }
+    const rendered = ranges
+        .slice(0, 3)
+        .map((range) => range.start_line === range.end_line
+        ? `${range.start_line}`
+        : `${range.start_line}-${range.end_line}`);
+    const suffix = ranges.length > rendered.length ? ` +${ranges.length - rendered.length}` : "";
+    return `ranges ${rendered.join(", ")}${suffix}`;
+}
+function renderTopMustReadRanges(input) {
+    if (input.selected.length === 0) {
+        return "- No selected ranges available.";
+    }
+    const candidates = topMustReadRangeCandidates(input)
+        .sort((left, right) => right.score - left.score || left.order - right.order)
+        .slice(0, 8);
+    return candidates
+        .map((candidate, index) => {
+        const header = `${index + 1}. ${renderRootPrefix(candidate.file.root_index, input.showRootLabels)}${candidate.file.path}:${singleRangeLabel(candidate.range)} - ${candidate.reason}`;
+        const snippet = renderTopMustReadSnippet(candidate, index, input.task);
+        return snippet.length === 0 ? header : `${header}\n\n${snippet}`;
+    })
+        .join("\n");
+}
+function topMustReadRangeCandidates(input) {
+    const candidates = [];
+    let order = 0;
+    for (const file of input.selected) {
+        const searchTerms = selectedFileSearchTerms(file, input.search);
+        const searchHitCount = input.search.filter((record) => record.root_index === file.root_index && record.path === file.path).length;
+        const sourceLines = splitSelectedFileContentByRange(file);
+        for (const [rangeIndex, range] of file.ranges.entries()) {
+            const symbols = symbolsFromLines(sourceLines[rangeIndex] ?? []);
+            const summary = rangeEvidenceSummary({
+                task: input.task,
+                path: file.path,
+                source: file.source,
+                symbols,
+                searchTerms,
+            });
+            const score = (file.source === "focus" ? 40 : 20)
+                + Math.min(searchHitCount, 6) * 3
+                + (pathLooksLikeTest(file.path) ? 8 : 0)
+                - rangeIndex;
+            const hitText = searchHitCount === 0
+                ? ""
+                : `; ${searchHitCount} selected-file search hit${searchHitCount === 1 ? "" : "s"}`;
+            candidates.push({
+                file,
+                range,
+                score,
+                order,
+                reason: `${summary}${hitText}`,
+            });
+            order += 1;
+        }
+    }
+    return candidates;
+}
+function singleRangeLabel(range) {
+    return range.start_line === range.end_line
+        ? `${range.start_line}`
+        : `${range.start_line}-${range.end_line}`;
+}
+function renderTopMustReadSnippet(candidate, index, task) {
+    if (isCodemapOnlyDisposition(candidate.file.disposition)) {
+        return "";
+    }
+    if (index >= 3) {
+        return "";
+    }
+    const rangeIndex = candidate.file.ranges.findIndex((range) => range.start_line === candidate.range.start_line &&
+        range.end_line === candidate.range.end_line);
+    const rangeLines = splitSelectedFileContentByRange(candidate.file)[rangeIndex] ?? [];
+    const numbered = topMustReadSnippetLines(candidate.range, rangeLines, evidenceTermsForTask(task), candidate.file.path);
+    if (numbered.length === 0) {
+        return "";
+    }
+    return ["```text", ...numbered, "```"].join("\n");
+}
+function topMustReadSnippetLines(range, rangeLines, terms, path) {
+    const evidenceLines = rangeLines
+        .map((line, lineIndex) => ({
+        lineNumber: range.start_line + lineIndex,
+        rangeIndex: 0,
+        text: line.trimEnd(),
+    }))
+        .filter((line) => line.text.trim().length > 0);
+    const scored = evidenceLines
+        .map((line, index) => ({
+        index,
+        score: evidenceLineScore(line.text, terms, path),
+    }))
+        .filter((candidate) => candidate.score > 0)
+        .sort((left, right) => right.score - left.score ||
+        evidenceLines[left.index].lineNumber -
+            evidenceLines[right.index].lineNumber);
+    if (scored.length > 0) {
+        const rendered = renderEvidenceLineWindows(mergedEvidenceWindows(evidenceLines, scored.slice(0, 2).map((candidate) => candidate.index)), evidenceLines)
+            .split("\n")
+            .filter((line) => line.length > 0)
+            .slice(0, 8);
+        if (rendered.length > 0) {
+            return rendered;
+        }
+    }
+    return evidenceLines
+        .slice(0, 8)
+        .map((line) => `${line.lineNumber}: ${trimEvidenceLine(line.text)}`);
+}
+function pathLooksLikeTest(path) {
+    return /(?:^|\/)(?:tests?|__tests__)\//.test(path) || /\.test\.[^.]+$/.test(path);
+}
+const SOURCE_EVIDENCE_WINDOW_RADIUS = 4;
+function mergedEvidenceWindows(lines, anchors) {
+    const windows = anchors
+        .map((anchor) => evidenceWindowAroundAnchor(lines, anchor))
+        .sort((left, right) => left.startIndex - right.startIndex);
+    const merged = [];
+    for (const window of windows) {
+        const previous = merged.at(-1);
+        if (previous != null &&
+            lines[previous.endIndex]?.rangeIndex === lines[window.startIndex]?.rangeIndex &&
+            window.startIndex <= previous.endIndex + 1) {
+            previous.endIndex = Math.max(previous.endIndex, window.endIndex);
+            continue;
+        }
+        merged.push({ ...window });
+    }
+    return merged;
+}
+function evidenceWindowAroundAnchor(lines, anchor) {
+    const anchorLine = lines[anchor];
+    if (anchorLine == null) {
+        return { startIndex: anchor, endIndex: anchor };
+    }
+    let startIndex = anchor;
+    let before = SOURCE_EVIDENCE_WINDOW_RADIUS;
+    while (before > 0 &&
+        startIndex > 0 &&
+        lines[startIndex - 1]?.rangeIndex === anchorLine.rangeIndex) {
+        startIndex -= 1;
+        before -= 1;
+    }
+    let endIndex = anchor;
+    let after = SOURCE_EVIDENCE_WINDOW_RADIUS;
+    while (after > 0 &&
+        endIndex + 1 < lines.length &&
+        lines[endIndex + 1]?.rangeIndex === anchorLine.rangeIndex) {
+        endIndex += 1;
+        after -= 1;
+    }
+    return { startIndex, endIndex };
+}
+function renderEvidenceLineWindows(windows, lines) {
+    const rendered = [];
+    let previousRenderedLine;
+    for (const window of windows) {
+        for (let index = window.startIndex; index <= window.endIndex; index += 1) {
+            const line = lines[index];
+            if (line == null || line.text.trim().length === 0) {
+                continue;
+            }
+            if (previousRenderedLine != null &&
+                (previousRenderedLine.rangeIndex !== line.rangeIndex ||
+                    previousRenderedLine.lineNumber !== line.lineNumber - 1) &&
+                rendered.at(-1) !== "...") {
+                rendered.push("...");
+            }
+            rendered.push(`${line.lineNumber}: ${trimEvidenceLine(line.text)}`);
+            previousRenderedLine = line;
+        }
+    }
+    return rendered.join("\n");
+}
+function evidenceTermsForTask(task) {
+    return task
+        .toLowerCase()
+        .split(/[^a-z0-9_]+/)
+        .filter((term) => term.length >= 4)
+        .slice(0, 8);
+}
+function evidenceLineScore(line, terms, _path) {
+    const normalized = line.toLowerCase();
+    let score = 0;
+    for (const term of terms) {
+        if (normalized.includes(term.toLowerCase())) {
+            score += 10;
+        }
+    }
+    if (score === 0) {
+        return 0;
+    }
+    if (/^\s*import\b/.test(line)) {
+        score -= 20;
+    }
+    if (/^\s*(const|let|return|if|await|async|def|function|type|interface)\b/.test(line)) {
+        score += 4;
+    }
+    if (/[.=:(]\s*[^=]|=>|append|values|request|response|onChange|value=/.test(line)) {
+        score += 3;
+    }
+    return score;
+}
+function trimEvidenceLine(line) {
+    const maxLength = 180;
+    if (line.length <= maxLength) {
+        return line;
+    }
+    return `${line.slice(0, maxLength - 3)}...`;
+}
+function isClosurePath(path) {
+    const normalized = path.toLowerCase();
+    const basename = normalized.split("/").at(-1) ?? normalized;
+    return (normalized.includes("/types/") ||
+        normalized.includes("/schemas/") ||
+        normalized.includes("/constants.") ||
+        normalized.includes("/config.") ||
+        normalized.includes("/querykeys.") ||
+        basename.endsWith(".types.ts") ||
+        basename === "types.ts" ||
+        basename === "schema.ts" ||
+        basename === "schemas.ts" ||
+        basename === "constants.ts" ||
+        basename === "constants.py" ||
+        basename === "config.ts" ||
+        basename === "config.py" ||
+        basename === "querykeys.ts");
+}
+function renderRepositoryShape(input) {
+    const { tree, selected, showRootLabels } = input;
+    if (tree.length === 0) {
+        return "- No files discovered.";
+    }
+    const selectedKeys = selectedFileKeys(selected);
+    const selectedTree = tree.filter((file) => selectedKeys.has(fileKey(file)));
+    if (selectedTree.length === 0) {
+        return "- Full repository shape is available in tree.json; no selected files were present in the discovered tree.";
+    }
+    return [
+        "- Full repository shape is available in tree.json; inline shape is limited to selected files.",
+        ...selectedTree
+            .map((file) => {
+            const flags = [
+                file.eligible ? "eligible" : "omitted",
+                file.content_eligible ? "content" : "metadata-only",
+            ].join(", ");
+            return `- ${renderRootPrefix(file.root_index, showRootLabels)}${file.path} (${file.size_bytes} bytes; ${flags})`;
+        }),
+    ].join("\n");
+}
+function renderSearchEvidence(input) {
+    const { search, selected, showRootLabels } = input;
+    if (search.length === 0) {
+        return "- No search hits recorded.";
+    }
+    const selectedPathKeys = selectedFileKeys(selected);
+    const selectedHits = search.filter((record) => selectedPathKeys.has(fileKey(record)));
+    const repoWideHits = search.filter((record) => !selectedPathKeys.has(fileKey(record)));
+    const lines = [];
+    lines.push(renderSelectedSearchSummary(selectedHits, showRootLabels));
+    if (repoWideHits.length > 0) {
+        lines.push(`- Repo-wide hits suppressed from inline bundle: ${repoWideHits.length} hits across ${countSearchPaths(repoWideHits)} unselected files; see search.jsonl.`);
+    }
+    return lines.join("\n");
+}
+function renderSelectedSearchSummary(selectedHits, showRootLabels) {
+    if (selectedHits.length === 0) {
+        return "- Selected-file hits: none.";
+    }
+    const countByPath = new Map();
+    for (const record of selectedHits) {
+        const path = `${renderRootPrefix(record.root_index, showRootLabels)}${record.path}`;
+        countByPath.set(path, (countByPath.get(path) ?? 0) + 1);
+    }
+    const topPaths = [...countByPath.entries()]
+        .sort((left, right) => right[1] - left[1] || left[0].localeCompare(right[0]))
+        .slice(0, 12)
+        .map(([path, count]) => `${path}=${count}`)
+        .join(", ");
+    const suppressed = countByPath.size > 12 ? `; ${countByPath.size - 12} more selected files in search.jsonl` : "";
+    return `- Selected-file hits: ${selectedHits.length} hits across ${countByPath.size} selected files (${topPaths}${suppressed}).`;
+}
+function countSearchPaths(search) {
+    return new Set(search.map(fileKey)).size;
+}
+function renderFileContext(selected, search, showRootLabels) {
+    if (selected.length === 0) {
+        return "No file context selected.";
+    }
+    const totalRanges = selected.reduce((total, file) => total + file.ranges.length, 0);
+    const totalBytes = selected.reduce((total, file) => total + file.bytes, 0);
+    const previewFiles = selected.slice(0, 12).map((file) => {
+        const ranges = file.ranges
+            .slice(0, 4)
+            .map((range) => `${range.start_line}-${range.end_line}`)
+            .join(", ");
+        const suffix = file.ranges.length > 4 ? ` +${file.ranges.length - 4}` : "";
+        return `- ${renderRootPrefix(file.root_index, showRootLabels)}${file.path}: ${ranges}${suffix}`;
+    });
+    const hidden = selected.length > previewFiles.length
+        ? [`- ${selected.length - previewFiles.length} more selected files are listed in manifest.json and selected-context.jsonl.`]
+        : [];
+    const selectedHitPreviews = renderSelectedHitPreviews({
+        selected,
+        search,
+        showRootLabels,
+    });
+    const selectedRangeLandmarks = selected.length > 12
+        ? []
+        : renderSelectedRangeLandmarks({
+            selected,
+            showRootLabels,
+        });
+    const selectedCodemapOutlines = selected.length > 12
+        ? []
+        : renderSelectedCodemapOutlines({
+            selected,
+            showRootLabels,
+        });
+    return [
+        "- Full selected source is stored in `selected-context.jsonl`; `slices.jsonl` is the bounded candidate/debug universe and may include unselected files or ranges.",
+        `- Selected source payload: ${selected.length} files, ${totalRanges} ranges, ${totalBytes} bytes before artifact serialization.`,
+        "- Range index:",
+        ...previewFiles,
+        ...hidden,
+        ...(selectedRangeLandmarks.length === 0
+            ? []
+            : ["", "- Range landmarks:", ...selectedRangeLandmarks]),
+        ...(selectedCodemapOutlines.length === 0
+            ? []
+            : ["", "- Codemap outlines:", ...selectedCodemapOutlines]),
+        ...(selected.length > 12 || selectedHitPreviews.length === 0
+            ? []
+            : ["", "- Selected hit previews:", ...selectedHitPreviews]),
+    ].join("\n");
+}
+function renderSelectedRangeLandmarks(input) {
+    const rendered = [];
+    const seen = new Set();
+    for (const file of input.selected) {
+        if (isCodemapOnlyDisposition(file.disposition)) {
+            continue;
+        }
+        let fileCount = 0;
+        const rangeLines = splitSelectedFileContentByRange(file);
+        file.ranges.forEach((range, rangeIndex) => {
+            const lines = rangeLines[rangeIndex] ?? [];
+            let rangeCount = 0;
+            lines.forEach((line, offset) => {
+                const preview = line.trim();
+                if (preview.length === 0 || !isRangeLandmarkLine(preview)) {
+                    return;
+                }
+                const lineNumber = range.start_line + offset;
+                const key = `${file.root_index}\u0000${file.path}\u0000${lineNumber}\u0000${preview}`;
+                if (seen.has(key)) {
+                    return;
+                }
+                seen.add(key);
+                rendered.push(`  - ${renderRootPrefix(file.root_index, input.showRootLabels)}${file.path}:${lineNumber} ${preview}`);
+                fileCount += 1;
+                rangeCount += 1;
+            });
+        });
+        if (fileCount >= 16 || rendered.length >= 48) {
+            break;
+        }
+    }
+    return rendered.slice(0, 48);
+}
+function isRangeLandmarkLine(line) {
+    return symbolsFromLine(line).length > 0;
+}
+function renderSelectedCodemapOutlines(input) {
+    const rendered = [];
+    for (const file of input.selected) {
+        if (!isCodemapOnlyDisposition(file.disposition)) {
+            continue;
+        }
+        const map = selectedFileCodemap(file);
+        const prefix = renderRootPrefix(file.root_index, input.showRootLabels);
+        if (map.symbols.length === 0) {
+            rendered.push(`  - ${prefix}${file.path}: no symbols detected`);
+            continue;
+        }
+        rendered.push(`  - ${prefix}${file.path}:`);
+        rendered.push(...map.symbols
+            .slice(0, 24)
+            .map((symbol) => `    - ${renderCodemapSymbolLine(symbol)}`));
+        if (map.symbols.length > 24) {
+            rendered.push(`    - +${map.symbols.length - 24} more symbols`);
+        }
+    }
+    return rendered;
+}
+function selectedFileCodemap(file) {
+    return remapCodemapToSourceCoordinates(buildFileCodemap(file.path, file.content), file.ranges);
+}
+function renderCodemapSymbolLine(symbol) {
+    return `${symbol.kind} ${symbol.name} ${singleRangeLabel({
+        start_line: symbol.start_line,
+        end_line: symbol.end_line,
+    })}`;
+}
+function isCodemapOnlyDisposition(disposition) {
+    return disposition === "codemap_only";
+}
+function renderSelectedHitPreviews(input) {
+    const selectedPaths = new Set(input.selected
+        .filter((file) => !isCodemapOnlyDisposition(file.disposition))
+        .map((file) => `${file.root_index}\u0000${file.path}`));
+    const rendered = [];
+    const seen = new Set();
+    const perFileCount = new Map();
+    for (const record of input.search) {
+        const fileKey = `${record.root_index}\u0000${record.path}`;
+        if (!selectedPaths.has(fileKey)) {
+            continue;
+        }
+        if ((perFileCount.get(fileKey) ?? 0) >= 4) {
+            continue;
+        }
+        const preview = record.preview.trim();
+        if (preview.length === 0) {
+            continue;
+        }
+        const hitKey = `${fileKey}\u0000${record.line}\u0000${preview}`;
+        if (seen.has(hitKey)) {
+            continue;
+        }
+        seen.add(hitKey);
+        perFileCount.set(fileKey, (perFileCount.get(fileKey) ?? 0) + 1);
+        rendered.push(`  - ${renderRootPrefix(record.root_index, input.showRootLabels)}${record.path}:${record.line}:${record.column} matches "${record.search_term}": ${preview}`);
+        if (rendered.length >= 24) {
+            break;
+        }
+    }
+    return rendered;
+}
+function renderRootPrefix(rootIndex, showRootLabels) {
+    return showRootLabels ? `root ${rootIndex}: ` : "";
+}
+function renderOpenQuestions(questions) {
+    if (questions.length === 0) {
+        return "- None.";
+    }
+    return questions.map((question) => `- ${question}`).join("\n");
+}
+function renderOmissionsAndBudgetNotes(input) {
+    const maxMaterialOmissions = 12;
+    const maxPathsPerMaterialOmission = 5;
+    const notes = [];
+    notes.push(`- Metrics: selected ${input.metrics.files_selected} files, recorded ${input.omissions.length} omissions, estimated ${input.metrics.estimated_tokens} tokens.`);
+    if (input.metrics.truncated) {
+        notes.push("- Output was truncated or budget-limited.");
+    }
+    for (const warning of input.warnings.filter(isHumanUsefulWarning)) {
+        notes.push(`- Warning ${warning.code}: ${warning.message}`);
+    }
+    const materialOmissions = input.omissions.filter(isMaterialOmission);
+    const incidentalOmissions = input.omissions.filter((omission) => !isMaterialOmission(omission));
+    if (materialOmissions.length > 0) {
+        notes.push("- Material omissions:");
+    }
+    for (const omission of materialOmissions.slice(0, maxMaterialOmissions)) {
+        notes.push(`  - ${humanOmissionReason(omission.reason)}: ${omission.message}${renderOmissionPathSuffix(omission.paths, maxPathsPerMaterialOmission)}`);
+    }
+    if (materialOmissions.length > maxMaterialOmissions) {
+        const hidden = materialOmissions.length - maxMaterialOmissions;
+        const countByReason = summarizeOmissionReasons(materialOmissions.slice(maxMaterialOmissions));
+        notes.push(`  - ${hidden} additional material omissions summarized: ${countByReason}. Full details are in manifest.json and summary.json.`);
+    }
+    if (incidentalOmissions.length > 0) {
+        notes.push(`- Incidental omissions summarized: ${summarizeOmissionReasons(incidentalOmissions)}.`);
+    }
+    return notes.join("\n");
+}
+function isHumanUsefulWarning(warning) {
+    if (warning.code === "delegate_curator_warning" ||
+        warning.code === "delegate_finalizer_warning") {
+        const normalized = warning.message.toLowerCase();
+        return !(normalized.includes("no filesystem inspection") ||
+            normalized.includes("no filesystem discovery") ||
+            normalized.includes("budget-pruned") ||
+            normalized.includes("packet-provided") ||
+            normalized.includes("packet candidates") ||
+            normalized.includes("packet.candidates") ||
+            normalized.includes("candidate ids and ranges") ||
+            normalized.includes("packet budget") ||
+            normalized.includes("packet ranges") ||
+            normalized.includes("packet did not provide complete source") ||
+            normalized.includes("partial because the packet") ||
+            normalized.includes("empty excerpts") ||
+            normalized.includes("large files were kept") ||
+            normalized.includes("excerpt-only for many slices") ||
+            normalized.includes("packet authority was enforced") ||
+            normalized.includes("curator selected fewer local candidates") ||
+            normalized.includes("server-expanded") ||
+            normalized.includes("server-retained") ||
+            normalized.includes("server-evicted") ||
+            normalized.includes("full ranges were selected") ||
+            normalized.includes("selection intentionally keeps deterministic candidates") ||
+            normalized.includes("full source") ||
+            normalized.includes("full excerpts") ||
+            normalized.includes("expected anchor") ||
+            normalized.includes("intentionally excluded") ||
+            normalized.includes("intentionally excludes") ||
+            normalized.includes("broad search") ||
+            normalized.includes("search spillover") ||
+            normalized.includes("packet slices") ||
+            normalized.includes("short packet ranges") ||
+            normalized.includes("narrow ranges") ||
+            normalized.includes("search-discovered candidates") ||
+            normalized.includes("partial deterministic ranges") ||
+            normalized.includes("sparse for many deterministic ranges") ||
+            normalized.includes("narrow eligible ranges") ||
+            normalized.includes("targeted slices"));
+    }
+    return true;
+}
+function renderOmissionPathSuffix(paths, limit) {
+    if (paths == null || paths.length === 0) {
+        return "";
+    }
+    const uniquePaths = [...new Set(paths)];
+    const rendered = uniquePaths.slice(0, limit);
+    const omitted = uniquePaths.length - rendered.length;
+    return ` (${rendered.join(", ")}${omitted > 0 ? ` +${omitted} more` : ""})`;
+}
+function humanOmissionReason(reason) {
+    if (reason === "target_estimated_tokens") {
+        return "budget-limited";
+    }
+    if (reason === "max_files") {
+        return "file-count-limited";
+    }
+    if (reason === "max_total_bytes" || reason === "max_bytes_per_file") {
+        return "byte-budget-limited";
+    }
+    return reason;
+}
+function summarizeOmissionReasons(omissions) {
+    const countByReason = new Map();
+    for (const omission of omissions) {
+        const reason = humanOmissionReason(omission.reason);
+        countByReason.set(reason, (countByReason.get(reason) ?? 0) + 1);
+    }
+    return [...countByReason.entries()]
+        .sort(([left], [right]) => left.localeCompare(right))
+        .map(([reason, count]) => `${reason}=${count}`)
+        .join(", ");
+}
+function isMaterialOmission(omission) {
+    if (new Set([
+        "binary_file",
+        "content_secret",
+        "exclude_glob",
+        "secret_path",
+        "symlink",
+    ]).has(omission.reason)) {
+        return false;
+    }
+    return omissionEventBaseFromReason(omission.reason).material === true;
+}
+function reconcileSelectedOmissions(omissions, selected) {
+    if (omissions.length === 0 || selected.length === 0) {
+        return [...omissions];
+    }
+    const selectedKeys = selectedFileKeys(selected);
+    const selectedPaths = new Set(selected.map((file) => file.path));
+    const reconciled = [];
+    for (const omission of omissions) {
+        if (omission.paths == null || omission.paths.length === 0) {
+            reconciled.push(omission);
+            continue;
+        }
+        const paths = omission.paths.filter((path) => {
+            if (omission.root_index == null) {
+                return !selectedPaths.has(path);
+            }
+            return !selectedKeys.has(fileKey({ root_index: omission.root_index, path }));
+        });
+        if (paths.length > 0) {
+            reconciled.push({ ...omission, paths });
+        }
+    }
+    return reconciled;
+}
+function filterTaskPresentationOmissions(omissions, _task) {
+    return [...omissions];
+}
+function filterTaskPresentationSelected(selected, _task) {
+    return [...selected];
+}
+function promoteTaskPresentationEvidence(selected, _task, _slices) {
+    return [...selected];
+}
+function reconcileSelectedOpenQuestions(questions, selected) {
+    if (questions.length === 0 || selected.length === 0) {
+        return [...questions];
+    }
+    const refs = selectedQuestionReferences(selected);
+    return questions.filter((question) => {
+        if (isConceptualQuestionAnsweredBySelectedContext(question, selected)) {
+            return false;
+        }
+        if (!isSelectedEvidenceQuestion(question)) {
+            return true;
+        }
+        return !questionReferencesSelectedContext(question, refs);
+    });
+}
+function buildPresentationOpenQuestions(questions, selected, omissions) {
+    const reconciled = reconcileSelectedOpenQuestions(questions, selected);
+    const seen = new Set(reconciled);
+    const output = [...reconciled];
+    for (const question of omissionFollowUpQuestions(omissions)) {
+        if (seen.has(question)) {
+            continue;
+        }
+        seen.add(question);
+        output.push(question);
+        if (output.length >= 20) {
+            break;
+        }
+    }
+    return output;
+}
+function omissionFollowUpQuestions(omissions) {
+    return omissions
+        .filter(isMaterialOmission)
+        .slice(0, 3)
+        .map((omission) => {
+        const reason = humanOmissionReason(omission.reason);
+        const paths = renderOmissionQuestionPaths(omission.paths);
+        if (paths.length === 0) {
+            return `What task-relevant evidence is missing from the ${reason} omission: ${omission.message}?`;
+        }
+        return `Can the omitted ${reason} paths (${paths}) change the answer, risk assessment, or required tests for this task?`;
+    });
+}
+function renderOmissionQuestionPaths(paths) {
+    if (paths == null || paths.length === 0) {
+        return "";
+    }
+    const uniquePaths = [...new Set(paths)];
+    const rendered = uniquePaths.slice(0, 3);
+    const omitted = uniquePaths.length - rendered.length;
+    return `${rendered.join(", ")}${omitted > 0 ? ` +${omitted} more` : ""}`;
+}
+function isConceptualQuestionAnsweredBySelectedContext(_question, _selected) {
+    return false;
+}
+function isSelectedEvidenceQuestion(question) {
+    return /\b(?:missing|missed|omitted|not selected|not present|unavailable|outside packet|need|needs|verify|confirm|include|includes|contain|contains|selected|available|additional|represented|constraints?|excerpt)\b/i.test(question);
+}
+function selectedQuestionReferences(selected) {
+    const refs = new Set();
+    for (const file of selected) {
+        for (const value of selectedQuestionReferenceValues(file.path)) {
+            const normalized = normalizeQuestionReference(value);
+            if (isConcreteQuestionReference(normalized)) {
+                refs.add(normalized);
+            }
+        }
+    }
+    return refs;
+}
+function selectedQuestionReferenceValues(path) {
+    const parts = path.split("/");
+    const basename = parts.at(-1) ?? path;
+    const stem = basename.split(".")[0] ?? basename;
+    return [path, basename, stem];
+}
+function questionReferencesSelectedContext(question, refs) {
+    const normalized = normalizeQuestionReference(question);
+    for (const ref of refs) {
+        if (normalized.includes(ref)) {
+            return true;
+        }
+    }
+    return false;
+}
+function normalizeQuestionReference(value) {
+    return value.toLowerCase().replace(/[^a-z0-9]+/g, "");
+}
+function isConcreteQuestionReference(value) {
+    if (value.length < 4) {
+        return false;
+    }
+    return !new Set([
+        "backend",
+        "frontend",
+        "schema",
+        "schemas",
+        "service",
+        "services",
+        "source",
+        "test",
+        "tests",
+        "types",
+    ]).has(value);
+}
+function selectedFileKeys(selected) {
+    return new Set(selected.map(fileKey));
+}
+function fileKey(file) {
+    return `${file.root_index}\u0000${file.path}`;
+}
+function boundOpenQuestions(questions) {
+    return questions.slice(0, 20).map((question) => sanitizeDiagnosticText(typeof question === "string" ? question : question.question));
+}
+function omissionEventFromDiagnostic(omission) {
+    const base = omissionEventBaseFromReason(omission.reason);
+    const rootIndex = omission.root_index;
+    return {
+        ...base,
+        ...(rootIndex !== undefined && Number.isInteger(rootIndex) && rootIndex >= 0
+            ? { root_index: rootIndex }
+            : {}),
+        ...(omission.paths == null || omission.paths.length === 0
+            ? {}
+            : { paths: [...omission.paths] }),
+    };
+}
+function warningEventFromDiagnostic(warning) {
+    return {
+        reason: "non_material_notice",
+        material: false,
+        code: warning.code,
+        message: warning.message,
+    };
+}
+function omissionEventBaseFromReason(reason) {
+    if (reason === "excluded" ||
+        reason === "exclude_glob" ||
+        reason === "caller_include_glob" ||
+        reason === "symlink_omitted" ||
+        reason === "symlink_file" ||
+        reason === "binary_file" ||
+        reason === "duplicate_root") {
+        return { reason: "incidental_skip", material: false };
+    }
+    if (reason === "noisy_file" ||
+        reason === "default_exclude" ||
+        reason === "default_noisy_exclude") {
+        return { reason: "default_noisy_exclude", material: false };
+    }
+    if (reason === "focus_sliced" || reason === "focus_over_cap") {
+        return { reason: "budget_omission", material: true };
+    }
+    if (reason.includes("secret")) {
+        return { reason: "secret_skip", material: true };
+    }
+    if (reason.includes("unreadable")) {
+        return { reason: "unreadable_file", material: true };
+    }
+    if (reason.includes("max_scan_files") ||
+        reason.includes("max_discovery_bytes") ||
+        reason.includes("max_candidate") ||
+        reason.includes("discovery_byte_cap") ||
+        reason.includes("candidate_cap") ||
+        reason.includes("search_cap") ||
+        reason.includes("scan_cap")) {
+        return { reason: "cap_omission", material: true };
+    }
+    if (reason.startsWith("max_") ||
+        reason.includes("budget") ||
+        reason === "target_estimated_tokens" ||
+        reason === "file_too_large") {
+        return { reason: "budget_omission", material: true };
+    }
+    return { reason: "requested_evidence_omission", material: true };
+}
+function boundDebugDiagnostics(diagnostics, caps) {
+    if (diagnostics == null) {
+        return {};
+    }
+    return {
+        ...(diagnostics.notes == null
+            ? {}
+            : {
+                notes: diagnostics.notes
+                    .slice(0, caps.max_warnings)
+                    .map((note) => sanitizeDiagnosticText(note)),
+            }),
+        ...(diagnostics.counters == null
+            ? {}
+            : { counters: sanitizeCounters(diagnostics.counters) }),
+    };
+}
+function sanitizeCounters(counters) {
+    return Object.fromEntries(Object.entries(counters)
+        .slice(0, 50)
+        .map(([key, value]) => [
+        sanitizeDiagnosticText(key),
+        typeof value === "string" ? sanitizeDiagnosticText(value) : value,
+    ]));
+}
+function renderJsonl(records) {
+    return records.map((record) => JSON.stringify(record)).join("\n")
+        + (records.length === 0 ? "" : "\n");
+}
+function validateTaskForRendering(task, allowSecrets) {
+    assertTaskSecretsGated(task, allowSecrets);
+    return task;
+}
+function safePath(path, allowSecrets) {
+    if (allowSecrets) {
+        return path;
+    }
+    return boundContextBuilderPathList([path], 1)[0] ?? "[redacted-sensitive-path]";
+}
+function safeContent(content, allowSecrets) {
+    if (allowSecrets) {
+        return content;
+    }
+    return hasConservativeResidualSecret(content)
+        ? "[redacted-sensitive-content]"
+        : content;
+}
+function sanitizeJsonValue(value, allowSecrets) {
+    if (typeof value === "string") {
+        const pathSafe = safePath(value, allowSecrets);
+        return pathSafe === "[redacted-sensitive-path]"
+            ? pathSafe
+            : sanitizeDiagnosticText(value, allowSecrets);
+    }
+    if (typeof value === "number" || typeof value === "boolean" || value == null) {
+        return value;
+    }
+    if (Array.isArray(value)) {
+        return value.slice(0, 200).map((item) => sanitizeJsonValue(item, allowSecrets));
+    }
+    if (typeof value === "object") {
+        return Object.fromEntries(Object.entries(value)
+            .slice(0, 200)
+            .map(([key, entryValue]) => [
+            sanitizeDiagnosticText(key, allowSecrets),
+            sanitizeJsonValue(entryValue, allowSecrets),
+        ]));
+    }
+    return String(value);
+}
+function markdownFenceFor(content) {
+    const longest = Math.max(3, ...Array.from(content.matchAll(/`+/g), (match) => match[0].length + 1));
+    return "`".repeat(longest);
+}
+//# sourceMappingURL=bundle.js.map