clinkx 0.2.2 → 0.3.0

package/dist/context-builder/bundle.js

@@ -0,0 +1,3573 @@
+import { boundContextBuilderOmissions, boundContextBuilderPathList, boundContextBuilderWarnings, sanitizeDiagnosticText, } from "./diagnostics.js";
+import { createContextBuilderReceipt, cloneContextBuilderDelegateReceiptMetadata, } from "./receipt.js";
+import { assertNoHighConfidenceSecretsInTask, hasHighConfidenceSecret, } 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";
+export function renderContextBuilderBundle(input) {
+    assertNoHighConfidenceSecretsInTask(input.task);
+    const selected = input.selected_context.map(sanitizeSelectedFile);
+    const tree = input.tree.map(sanitizeTreeFile);
+    const search = input.search.map(sanitizeSearchRecord);
+    const slices = input.slices.map(sanitizeSliceRecord);
+    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, then verify the generated answer against the source evidence immediately below it.",
+        "- Inspect selected files, repository shape, and search evidence before editing.",
+        "- Treat remaining omissions and open questions as follow-up checks before editing.",
+        "",
+        "## Top Must-Read Ranges",
+        "",
+        renderTopMustReadRanges({
+            task: input.task,
+            selected: presentationSelected,
+            search,
+            showRootLabels,
+        }),
+        "",
+        "## Generated Answer",
+        "",
+        renderGeneratedAnswer({
+            task: input.task,
+            selected: presentationSelected,
+            omissions: presentationOmissions,
+            showRootLabels,
+        }),
+        "",
+        "### Source Evidence",
+        "",
+        renderGeneratedAnswerSourceEvidence({
+            task: input.task,
+            selected: presentationSelected,
+            slices,
+            showRootLabels,
+        }),
+        "",
+        "## Relationships And Risks",
+        "",
+        renderRelationshipsAndRisks({
+            task: input.task,
+            selected: presentationSelected,
+            omissions: presentationOmissions,
+            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.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) {
+    assertNoHighConfidenceSecretsInTask(input.task);
+    const tree = input.tree.map(sanitizeTreeFile);
+    const search = input.search.map(sanitizeSearchRecord);
+    const slices = input.slices.map(sanitizeSliceRecord);
+    const selectedContext = input.selected_context.map(sanitizeSelectedFile);
+    const summary = buildContextBuilderSummary(input);
+    return {
+        bundle_md: renderContextBuilderBundle(input),
+        tree_json: `${JSON.stringify({
+            schema_version: 1,
+            roots: input.roots.map(sanitizeRoot),
+            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 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),
+        roots: input.roots.map(sanitizeRoot),
+        inputs: sanitizeJsonValue(input.inputs),
+        budget: { ...input.budget },
+        internal_caps: internalCaps,
+        token_counting: contextBuilderTokenCountingMethod(),
+        selected_context: input.selected_context
+            .map(sanitizeSelectedFile)
+            .map(stripSelectedContent),
+        omissions,
+        warnings,
+        metrics: { ...input.metrics },
+        ...(input.delegate == null
+            ? {}
+            : { delegate: cloneContextBuilderDelegateReceiptMetadata(input.delegate) }),
+        ...(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 }),
+    });
+    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 selected = input.selected_context.map(sanitizeSelectedFile);
+    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)),
+        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.delegate == null
+            ? {}
+            : { delegate: cloneContextBuilderDelegateReceiptMetadata(input.delegate) }),
+    };
+}
+function sanitizeRoot(root) {
+    return {
+        root_index: root.root_index,
+        ...(root.input_path == null ? {} : { input_path: safePath(root.input_path) }),
+        path: safePath(root.path),
+    };
+}
+function sanitizeTreeFile(file) {
+    return {
+        root_index: file.root_index,
+        path: safePath(file.path),
+        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) {
+    return {
+        root_index: record.root_index,
+        path: safePath(record.path),
+        line: record.line,
+        column: record.column,
+        search_term: sanitizeDiagnosticText(record.search_term),
+        search_term_index: record.search_term_index,
+        preview: safeContent(record.preview),
+    };
+}
+function sanitizeSliceRecord(record) {
+    return {
+        root_index: record.root_index,
+        path: safePath(record.path),
+        start_line: record.start_line,
+        end_line: record.end_line,
+        source: record.source,
+        content: safeContent(record.content),
+        ...(record.search_term_index == null
+            ? {}
+            : { search_term_index: record.search_term_index }),
+    };
+}
+function sanitizeSelectedFile(file) {
+    return {
+        root_index: file.root_index,
+        path: safePath(file.path),
+        ranges: file.ranges.map(sanitizeRange),
+        content: safeContent(file.content),
+        bytes: file.bytes,
+        estimated_tokens: file.estimated_tokens > 0
+            ? file.estimated_tokens
+            : estimateContextBuilderTokens(file.content),
+        source: file.source,
+    };
+}
+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,
+    };
+}
+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 slices.jsonl.`
+        : rendered;
+}
+function selectedFilePurpose(task, file, search) {
+    const action = taskActionCue(task);
+    const source = file.source === "focus" ? "requested focus evidence" : "matched task anchors";
+    const role = taskSpecificFileRole(task, file.path);
+    const clauses = [
+        action == null ? source : `${source} for ${action}`,
+        ...(role == null ? [] : [role]),
+        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 semantic = taskSpecificRangeRole(input.task, input.path);
+    const hitSummary = rangeHitSummary(input.rangeHits ?? []);
+    if (semantic != null) {
+        return [
+            semantic,
+            ...(hitSummary == null ? [] : [hitSummary]),
+            ...(input.symbols.length === 0
+                ? []
+                : [`key symbols ${input.symbols.slice(0, 4).join(", ")}`]),
+        ].join("; ");
+    }
+    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 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 taskSpecificFileRole(task, path) {
+    const normalizedTask = task.toLowerCase();
+    const branch = classifyTaskBranch(normalizedTask);
+    const normalized = path.toLowerCase();
+    if (branch === "runtime") {
+        if (normalized.includes("model_provider_auth") || normalized.includes("ai_models.py")) {
+            return "gates model exposure and Codex availability from provider metadata";
+        }
+        if (normalized.includes("/runtime/resolver.py") || normalized.includes("ai_model.py")) {
+            return "routes model/provider metadata into Claude vs Codex runtime selection";
+        }
+        if (normalized.includes("thinkingmodeselector") || normalized.includes("permissionmodeselector")) {
+            return "defines visible effort/permission controls whose values feed runtime settings";
+        }
+        if (normalized.includes("message-input") || normalized.includes("usechatruntime")) {
+            return "captures frontend runtime-setting controls";
+        }
+        if (normalized.includes("messagequeue") || normalized.includes("queue")) {
+            return "checks queued-send persistence and retry behavior";
+        }
+        if (normalized.endsWith("/api/endpoints/chat.py")) {
+            return "validates backend chat request ingestion";
+        }
+        if (normalized.endsWith("/services/chat.py")) {
+            return "connects persisted settings to completion dispatch";
+        }
+        if (normalized.includes("test_claude_agent")) {
+            return "tests Claude permission and effort translation semantics";
+        }
+        if (normalized.includes("/runtime/") || normalized.includes("claude_agent")) {
+            return "anchors provider-specific permission and effort semantics";
+        }
+    }
+    if (branch === "review") {
+        if (normalized.includes("codex_approval") || normalized.includes("permissions")) {
+            return "anchors approval and permission contract risk";
+        }
+        if (normalized.includes("/runtime/") || normalized.includes("runtime_session")) {
+            return "anchors Codex runtime/session behavior";
+        }
+        if (normalized.includes("fileupload") || normalized.includes("usemessageactions")) {
+            return "anchors frontend provider and attachment contract";
+        }
+    }
+    if (branch === "debug") {
+        if (normalized.includes("rightpaneldevtools") || normalized.includes("devtoolsnavstore")) {
+            return "anchors trace row identity and navigation state";
+        }
+        if (normalized.includes("trace_archive") || normalized.includes("devtools.py")) {
+            return "anchors backend trace entry shape";
+        }
+        if (normalized.includes("chat-window") || normalized.includes("message") || normalized.includes("tool")) {
+            return "anchors message or tool highlight target resolution";
+        }
+    }
+    return undefined;
+}
+function taskSpecificRangeRole(task, path) {
+    const normalizedTask = task.toLowerCase();
+    const branch = classifyTaskBranch(normalizedTask);
+    const normalized = path.toLowerCase();
+    if (branch === "runtime") {
+        if (normalized.includes("model_provider_auth") || normalized.includes("ai_models.py")) {
+            return "checks model exposure and provider capability gating for Codex runtime";
+        }
+        if (normalized.includes("/runtime/resolver.py") || normalized.includes("ai_model.py")) {
+            return "resolves selected model metadata into the provider runtime boundary";
+        }
+        if (normalized.includes("modelprovider.ts")) {
+            return "maps frontend model/provider capability checks driving runtime controls";
+        }
+        if (normalized.includes("thinkingmodeselector") || normalized.includes("permissionmodeselector")) {
+            return "owns the visible effort/permission mode choices and stale-value reset behavior";
+        }
+        if (normalized.includes("input.tsx")) {
+            return "owns composer send wiring and runtime-setting handoff from UI state";
+        }
+        if (normalized.includes("chatpage")) {
+            return "connects chat creation, initial prompt dispatch, and page-level runtime state";
+        }
+        if (normalized.includes("composerruntimecontrols")) {
+            return "defines visible permission and effort controls";
+        }
+        if (normalized.includes("inputsettingspopover")) {
+            return "maps stored runtime settings into composer controls";
+        }
+        if (normalized.includes("usechatruntime")) {
+            return "reads and writes chat-scoped runtime snapshots";
+        }
+        if (normalized.includes("usemessageactions")) {
+            return "serializes runtime settings on normal send and queued append";
+        }
+        if (normalized.includes("chatservice")) {
+            return "defines create-chat runtime fields and send/queue compatibility fields";
+        }
+        if (normalized.includes("messagequeue") || normalized.includes("queueservice")) {
+            return "preserves permission and effort across local queue replay";
+        }
+        if (normalized.includes("streamservice")) {
+            return "streams backend responses after send/queue runtime settings are accepted";
+        }
+        if (normalized.endsWith("/api/endpoints/chat.py")) {
+            return "parses create-chat runtime fields and send/queue compatibility fields";
+        }
+        if (normalized.endsWith("/models/schemas/chat.py") || normalized.endsWith("chat.types.ts")) {
+            return "defines the request/response contract fields that must not drift";
+        }
+        if (normalized.endsWith("queue.types.ts")) {
+            return "defines queued-send payload fields carried through replay";
+        }
+        if (normalized.endsWith("/services/chat.py")) {
+            return "persists runtime snapshots and redispatches pending initial prompts";
+        }
+        if (normalized.includes("test_queue")) {
+            return "guards queue replay of runtime permission and effort payloads";
+        }
+        if (normalized.includes("test_effort_level") || normalized.includes("test_permission_mode")) {
+            return "guards backend validation of runtime setting values";
+        }
+        if (normalized.includes("test_codex_runtime") || normalized.includes("test_codex_effort")) {
+            return "guards Codex runtime translation and migration behavior";
+        }
+        if (normalized.includes("usepermissionrequest")) {
+            return "shows frontend permission request consumption during runtime approval flows";
+        }
+        if (normalized.includes("usesettingsqueries")) {
+            return "shows how persisted settings are fetched back into runtime controls";
+        }
+        if (normalized.includes("test_claude_agent")) {
+            return "verifies Claude permission mapping, bypass sentinel handling, and effort levels";
+        }
+        if (normalized.includes("/runtime/") || normalized.includes("claude_agent")) {
+            return "translates normalized runtime settings into provider-specific options";
+        }
+    }
+    if (branch === "review") {
+        if (normalized.includes("codex_approval")) {
+            return "maps SDK approval requests to permission API payloads and timeouts";
+        }
+        if (normalized.includes("permission_manager") || normalized.includes("permissions")) {
+            return "stores, fetches, and resolves approval requests across Redis and HTTP";
+        }
+        if (normalized.includes("runtime_session")) {
+            return "decides whether Codex runtime sessions resume or start fresh";
+        }
+        if (normalized.includes("codex_stream_processor")) {
+            return "accounts for Codex stream lifecycle and usage snapshots";
+        }
+        if (normalized.includes("/runtime/codex.py")) {
+            return "owns Codex runtime process lifecycle, approval callbacks, and stream reads";
+        }
+        if (normalized.includes("/runtime/resolver.py")) {
+            return "decides Codex-vs-Claude runtime routing from model/provider metadata";
+        }
+        if (normalized.includes("/runtime/base.py") || normalized.includes("/runtime/claude.py")) {
+            return "anchors shared runtime contracts used to compare Codex behavior";
+        }
+        if (normalized.includes("model_provider_auth") || normalized.includes("ai_models.py")) {
+            return "checks provider metadata and Codex availability gates";
+        }
+        if (normalized.includes("test_ai_models_codex_gate") || normalized.includes("test_model_provider_auth")) {
+            return "guards provider gating and metadata fail-closed behavior";
+        }
+        if (normalized.includes("modelprovider.ts")) {
+            return "maps frontend model/provider capability checks";
+        }
+        if (normalized.includes("input.tsx")) {
+            return "owns primary send-site attachment/runtime handoff behavior";
+        }
+        if (normalized.includes("fileupload") || normalized.includes("usemessageactions")) {
+            return "guards frontend attachment behavior for Codex provider constraints";
+        }
+        if (normalized.includes("chatservice") || normalized.endsWith("/api/endpoints/chat.py") || normalized.endsWith("/services/chat.py")) {
+            return "checks chat ingress and persistence paths touched by runtime/provider decisions";
+        }
+    }
+    if (branch === "debug") {
+        if (normalized.includes("rightpaneldevtools")) {
+            return "tracks filtered rows, virtualizer keys, and clicked trace-entry identity";
+        }
+        if (normalized.includes("devtools-helpers")) {
+            return "classifies trace entries into message and tool navigation targets";
+        }
+        if (normalized.includes("devtoolsnavstore")) {
+            return "queues and delivers right-panel navigation requests";
+        }
+        if (normalized.includes("chat-window/chat")) {
+            return "resolves pending navigation against cached messages and scroll state";
+        }
+        if (normalized.includes("message-bubble/message.tsx")) {
+            return "wraps message highlight lifecycle after navigation resolves";
+        }
+        if (normalized.includes("messagecacheorder")) {
+            return "keeps cached messages in stable chronological order for lookup";
+        }
+        if (normalized.includes("messagerenderer")) {
+            return "turns message and tool identifiers into highlightable anchors";
+        }
+        if (normalized.includes("toolcard")) {
+            return "expands nested tool cards and exposes anchor ids";
+        }
+        if (normalized.includes("usedevtoolsqueries") || normalized.includes("querykeys")) {
+            return "defines trace query cache keys and freshness boundaries";
+        }
+        if (normalized.includes("right-panel-devtools.test")) {
+            return "guards filtered row click-through and trace navigation behavior";
+        }
+        if (normalized.includes("devtoolsnavstore.test")) {
+            return "guards navigation request delivery and highlight clearing behavior";
+        }
+        if (normalized.includes("devtools.py") || normalized.includes("session_trace")) {
+            return "defines backend trace/archive response shape and expiry fallback";
+        }
+    }
+    return undefined;
+}
+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 renderTaskGuidance(input) {
+    const normalizedTask = input.task.toLowerCase();
+    const branch = classifyTaskBranch(normalizedTask);
+    const selected = selectedPathSet(input.selected);
+    if (branch === "runtime") {
+        return [
+            `- Top targets: ${guidanceCoverage(selected, input.showRootLabels, [
+                "frontend/src/hooks/useChatRuntimeSettings.ts",
+                "frontend/src/hooks/useMessageActions.ts",
+                "frontend/src/store/messageQueueStore.ts",
+                "backend/app/api/endpoints/chat.py",
+                "backend/app/services/chat.py",
+                "backend/app/services/queue.py",
+                "backend/app/services/streaming/orchestrator.py",
+                "backend/app/services/runtime/codex.py",
+                "backend/app/services/runtime/claude.py",
+            ])}.`,
+            "- Flow to verify: composer controls and chat-scoped settings produce permission/effort values; create-chat sends runtime_permission_mode/runtime_effort_level, normal send and queue paths send permission_mode/effort_level compatibility fields, and backend code normalizes/persists one runtime snapshot before dispatch.",
+            "- Provider semantics to pin down: Codex effort values collapse to its advertised levels, Claude permission modes can map to bypass-style options, legacy/internal sentinel values must normalize before persistence, and unsupported settings must fail loudly rather than vanish.",
+            "- Validation checklist: create-chat stores runtime_permission_mode/runtime_effort_level; queued local append and backend upsert preserve permission_mode/effort_level until API/service normalization; pending initial prompt redispatch reads the stored snapshot; provider adapter tests cover translation drift.",
+        ].join("\n");
+    }
+    if (branch === "review") {
+        return [
+            `- Top review targets: ${guidanceCoverage(selected, input.showRootLabels, [
+                "backend/app/services/runtime/resolver.py",
+                "backend/app/services/runtime/codex.py",
+                "backend/app/services/runtime/codex_approval.py",
+                "backend/app/services/runtime/codex_stream_processor.py",
+                "backend/app/services/runtime_session_service.py",
+                "backend/app/api/endpoints/permissions.py",
+                "frontend/src/hooks/usePermissionRequest.ts",
+                "frontend/src/hooks/useMessageActions.ts",
+            ])}.`,
+            "- Review scope: this packet contains selected current-source context, not a git diff; separate confirmed source facts, likely risks, and needs-verification items before labeling anything a finding.",
+            "- Likely risks to test first: fail-open runtime routing when Codex support metadata is absent; wrong-chat or stale RuntimeSessionService resume decisions; approval timeout/Redis TTL mismatches; denied or expired permission responses mutating the wrong pending request; frontend file-upload filtering drifting from provider capabilities.",
+            "- Evidence map: pair runtime/session files with codex_approval.py and permission endpoints, then check frontend hooks/tests for the user-visible approval and attachment behavior.",
+            "- Missing-test checklist: live SDK approval payload shape, timeout cleanup of reader tasks, cross-chat permission denial, expired permission UI behavior, and provider-specific attachment filtering.",
+        ].join("\n");
+    }
+    if (branch === "debug") {
+        return [
+            `- Top debug targets: ${guidanceCoverage(selected, input.showRootLabels, [
+                "frontend/src/components/right-panel/RightPanelDevtools.tsx",
+                "frontend/src/components/right-panel/devtools-helpers.ts",
+                "frontend/src/store/devtoolsNavStore.ts",
+                "frontend/src/components/chat/chat-window/Chat.tsx",
+                "frontend/src/utils/messageCacheOrder.ts",
+                "frontend/src/components/chat/message-bubble/MessageRenderer.tsx",
+                "frontend/src/components/chat/tools/common/ToolCard.tsx",
+                "backend/app/api/endpoints/devtools.py",
+            ])}.`,
+            "- Confirmed source fact to preserve: selected RightPanelDevtools source may already carry originalIndex from the filtered row into TraceEntry and handleEntryClick, so originalIndex/filter-index alone is not proven as the main root cause.",
+            "- Likely checks: deferred search/navigation staleness, virtualizer key reuse, layout-effect timing after filter/search changes, cached-message dedupe before target resolution, and MessageRenderer/ToolCard anchor expansion.",
+            "- Validation checklist: filtered views click the intended message/tool, virtualized rows keep stable keys after filter changes, layout effects remeasure at the right time, cached message flattening preserves the target, and regression tests cover both message and nested tool anchors.",
+        ].join("\n");
+    }
+    return "- Use focus files first, then closure contracts and tests; material omissions or open questions should be resolved before editing.";
+}
+function guidanceCoverage(selected, showRootLabels, expectedPaths) {
+    const present = expectedPaths
+        .filter((path) => selected.has(path))
+        .slice(0, 10)
+        .map((path) => renderRootPrefix(0, showRootLabels) + path);
+    return present.length === 0
+        ? "no expected top target selected; inspect selected files and omissions"
+        : present.join(", ");
+}
+function renderContextSynthesis(input) {
+    const lines = [];
+    const selectedPaths = new Set(input.selected.map((file) => `${file.root_index}\u0000${file.path}`));
+    const selectedSearch = input.search.filter((record) => selectedPaths.has(`${record.root_index}\u0000${record.path}`));
+    const selectedTerms = [
+        ...new Set(selectedSearch.map((record) => record.search_term).filter(Boolean)),
+    ].slice(0, 8);
+    const materialOmissions = input.omissions.filter(isMaterialOmission);
+    const taskShape = renderTaskShapeSummary({
+        task: input.task,
+        selected: input.selected,
+        selectedSearch,
+        materialOmissions,
+        showRootLabels: input.showRootLabels,
+    });
+    lines.push(`- Coverage: ${input.metrics.files_selected} selected files, ${input.omissions.length} recorded omissions, ${input.metrics.estimated_tokens} estimated tokens.`);
+    lines.push(...taskShape);
+    if (selectedTerms.length > 0) {
+        lines.push(`- Search evidence: selected-file hits cover ${selectedTerms.length} task anchors; exact hit lines are in search.jsonl.`);
+    }
+    const groups = renderSelectedPathGroups(input.selected);
+    if (groups.length > 0) {
+        lines.push(`- Selected areas: ${groups.join("; ")}.`);
+    }
+    const closure = closureFiles(input.selected, input.showRootLabels);
+    if (closure.length > 0) {
+        lines.push(`- Contract and closure files: ${closure.join(", ")}.`);
+    }
+    if (materialOmissions.length > 0) {
+        const rendered = materialOmissions
+            .slice(0, 5)
+            .map((omission) => {
+            return `${humanOmissionReason(omission.reason)}${renderOmissionPathSuffix(omission.paths, 3)}`;
+        })
+            .join("; ");
+        lines.push(`- Material follow-ups: ${rendered}.`);
+    }
+    else {
+        lines.push("- Material follow-ups: none recorded.");
+    }
+    return lines.join("\n");
+}
+function renderTaskShapeSummary(input) {
+    const normalizedTask = input.task.toLowerCase();
+    const selected = selectedPathSet(input.selected);
+    const branch = classifyTaskBranch(normalizedTask);
+    const taskBullets = branch === "runtime"
+        ? runtimeSettingsSynthesisBullets(normalizedTask, selected)
+        : branch === "review"
+            ? codexApprovalsSynthesisBullets(normalizedTask, selected)
+            : branch === "debug"
+                ? devtoolsTraceSynthesisBullets(normalizedTask, selected)
+                : [
+                    ...runtimeSettingsSynthesisBullets(normalizedTask, selected),
+                    ...codexApprovalsSynthesisBullets(normalizedTask, selected),
+                    ...devtoolsTraceSynthesisBullets(normalizedTask, selected),
+                ];
+    if (taskBullets.length > 0) {
+        return taskBullets;
+    }
+    const action = taskActionCue(input.task) ?? "not inferred";
+    const relationshipCues = relationshipCuesFromSelected(input.selected);
+    const riskCues = riskCuesFromContext({
+        selected: input.selected,
+        selectedSearch: input.selectedSearch,
+        materialOmissions: input.materialOmissions,
+        showRootLabels: input.showRootLabels,
+    });
+    return [
+        `- Task shape: action=${action}; relationships=${relationshipCues}; risks=${riskCues}.`,
+    ];
+}
+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 branch = classifyTaskBranch(input.task.toLowerCase());
+    const branchLabel = `${branch === "generic" ? "general" : branch} task`;
+    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 semantic = taskSpecificRangeRole(input.task, file.path)
+                ?? taskSpecificFileRole(input.task, file.path);
+            const summary = semantic
+                ?? rangeEvidenceSummary({
+                    task: input.task,
+                    path: file.path,
+                    source: file.source,
+                    symbols,
+                    searchTerms,
+                });
+            const score = (file.source === "focus" ? 40 : 20)
+                + (semantic == null ? 0 : 30)
+                + Math.min(searchHitCount, 6) * 3
+                + (pathLooksLikeTest(file.path) ? 8 : 0)
+                + (branch === "generic" ? 0 : 4)
+                - rangeIndex;
+            const hitText = searchHitCount === 0
+                ? ""
+                : `; ${searchHitCount} selected-file search hit${searchHitCount === 1 ? "" : "s"}`;
+            candidates.push({
+                file,
+                range,
+                score,
+                order,
+                reason: `${branchLabel}; ${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 (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);
+}
+function runtimeSettingsSynthesisBullets(normalizedTask, selected) {
+    if (!mentionsAny(normalizedTask, ["runtime settings", "runtime_permission_mode", "runtime_effort_level", "queue dispatch"])) {
+        return [];
+    }
+    return [
+        `- Discovery/runtime settings: follow user-facing runtime controls through send/queue state into backend chat schemas, persistence, and runtime adapter dispatch. Selected coverage: ${selectedCoverage(selected, [
+            "frontend/src/components/chat/message-input/ComposerRuntimeControls.tsx",
+            "frontend/src/components/chat/thinking-mode-selector/ThinkingModeSelector.tsx",
+            "frontend/src/hooks/useChatRuntimeSettings.ts",
+            "frontend/src/hooks/useMessageActions.ts",
+            "frontend/src/services/chatService.ts",
+            "frontend/src/services/queueService.ts",
+            "backend/app/api/endpoints/chat.py",
+            "backend/app/models/schemas/chat.py",
+            "backend/app/services/runtime/codex.py",
+            "backend/app/services/runtime/resolver.py",
+            "backend/app/services/model_provider_auth.py",
+            "backend/app/services/claude_agent.py",
+            "frontend/src/components/chat/model-selector/ModelSelector.tsx",
+            "frontend/src/hooks/queries/useModelQueries.ts",
+            "frontend/src/utils/modelProvider.ts",
+        ])}.`,
+        "- Architecture: Composer controls and chat-scoped hooks produce permission/effort values; create-chat serializes runtime_permission_mode/runtime_effort_level; normal send and queued-send paths serialize permission_mode/effort_level compatibility fields; backend chat endpoints normalize them; ChatService and queue storage persist snapshots; workers/orchestrators hand normalized values to provider runtimes.",
+        "- Key invariants: create-chat must persist runtime_permission_mode/runtime_effort_level, queued sends must preserve permission_mode/effort_level through local append and backend upsert until normalization, pending initial prompts must redispatch with the stored runtime snapshot, and provider adapters must translate permission/effort semantics without silently dropping unsupported values.",
+        "- Likely risks to verify: payload names can drift between chatService/useMessageActions and chat.py schemas, ChatService can rehydrate defaults instead of the stored snapshot, queued work can replay stale effort names, and Claude/Codex adapters can diverge on permission semantics.",
+        "- Focused tests to add or inspect first: create-chat persistence, update_chat runtime snapshot persistence, queued send replay, pending initial prompt redispatch, and provider permission/effort translation.",
+    ];
+}
+function codexApprovalsSynthesisBullets(normalizedTask, selected) {
+    if (!mentionsAny(normalizedTask, ["code review", "approval", "codex approval", "runtime/session", "permission modes", "file upload"])) {
+        return [];
+    }
+    return [
+        `- Review/Codex approvals: map provider selection and Codex runtime session state to approval-bridge requests, permission APIs, and frontend approval consumers. Selected coverage: ${selectedCoverage(selected, [
+            "backend/app/services/runtime/codex.py",
+            "backend/app/services/runtime/codex_approval.py",
+            "backend/app/services/runtime_session_service.py",
+            "backend/app/api/endpoints/permissions.py",
+            "backend/app/models/schemas/permissions.py",
+            "frontend/src/hooks/usePermissionRequest.ts",
+            "frontend/src/utils/modelProvider.ts",
+        ])}.`,
+        "- Architecture: model/provider resolution chooses Codex runtime; RuntimeSessionService decides resume versus new session; CodexRuntime streams SDK events; approval callbacks normalize SDK requests into Redis-backed permission records; HTTP permission endpoints return decisions to frontend hooks.",
+        "- Review risk model: check fail-closed routing when Codex capability metadata is absent, wrong-session resume/upsert decisions, SDK approval normalization drift, Redis TTL and timeout coupling, denied/expired approval propagation, stuck reader tasks after permission timeout, and frontend provider/file-upload gating.",
+        "- Review plan: start with confirmed source facts, then likely Codex routing/session risks, then approval TTL/wait-window coupling, permission response ownership, and provider-specific attachment gating; call an item a finding only after checking the paired test coverage.",
+        "- Regression tests to expect: absent Codex support metadata fails closed, cross-chat denial cannot mutate another request, expired approvals clean up pending state, and live SDK approval payload shape remains normalized by the bridge.",
+    ];
+}
+function devtoolsTraceSynthesisBullets(normalizedTask, selected) {
+    if (!mentionsAny(normalizedTask, ["devtools", "trace row", "row-to-message", "click-through", "highlight"])) {
+        return [];
+    }
+    return [
+        `- Debugging/devtools trace mapping: connect backend trace/archive entries to right-panel row identity, devtools navigation state, chat cache lookup, and message/tool anchor expansion. Selected coverage: ${selectedCoverage(selected, [
+            "backend/app/api/endpoints/devtools.py",
+            "backend/app/services/session_trace_archive.py",
+            "frontend/src/components/right-panel/RightPanelDevtools.tsx",
+            "frontend/src/components/right-panel/devtools-helpers.ts",
+            "frontend/src/store/devtoolsNavStore.ts",
+            "frontend/src/components/chat/chat-window/Chat.tsx",
+            "frontend/src/hooks/queries/queryKeys.ts",
+            "frontend/src/components/chat/tools/common/ToolCard.tsx",
+        ])}.`,
+        "- Architecture: backend trace entries carry durable ids/indexes; RightPanelDevtools filters and virtualizes those entries; click handlers publish a devtools navigation request; Chat resolves it against cached messages; MessageRenderer and ToolCard expose the final message/tool anchors.",
+        "- Confirmed source fact: if selected RightPanelDevtools code already carries originalIndex alongside filtered rows, do not blame originalIndex/filter-index as the main root cause without a failing repro.",
+        "- Likely checks: deferred search/navigation staleness, virtualizer getItemKey/key reuse, layout-effect remeasure timing after filter/search changes, cached message lookup with duplicate timestamps, and nested tool-card expansion from a devtools navigation request.",
+        "- Focused tests to add or inspect first: filtered trace row click-through, row key stability after filter changes, layout-effect remeasure/reset behavior, cached message dedupe, and nested tool-card expansion from a devtools navigation request.",
+    ];
+}
+function renderGeneratedAnswer(input) {
+    const normalizedTask = input.task.toLowerCase();
+    const branch = classifyTaskBranch(normalizedTask);
+    const completenessGate = renderCompletenessGate(input.omissions);
+    const lineGroundedActionMap = renderLineGroundedActionMap({
+        task: input.task,
+        selected: input.selected,
+        showRootLabels: input.showRootLabels,
+    });
+    if (branch === "runtime") {
+        return [
+            ...completenessGate,
+            "### Architecture",
+            "- Runtime settings cross four ownership boundaries: composer controls, send/queue serialization, backend normalization/persistence, and provider adapter dispatch.",
+            "### Ownership Boundaries",
+            `- UI state: ${briefRef(input.selected, input.showRootLabels, "frontend/src/hooks/useChatRuntimeSettings.ts")} owns permissionMode/effortLevel; ${briefRef(input.selected, input.showRootLabels, "frontend/src/components/chat/message-input/Input.tsx")} and ${briefRef(input.selected, input.showRootLabels, "frontend/src/hooks/useMessageActions.ts")} are the primary send consumers.`,
+            `- API/persistence: ${briefRef(input.selected, input.showRootLabels, "frontend/src/services/chatService.ts")} emits create-chat runtime fields; ${briefRef(input.selected, input.showRootLabels, "backend/app/api/endpoints/chat.py")} normalizes compatibility aliases; ${briefRef(input.selected, input.showRootLabels, "backend/app/services/chat.py")} persists and redispatches the normalized snapshot.`,
+            `- Runtime dispatch: ${briefRef(input.selected, input.showRootLabels, "backend/app/services/streaming/orchestrator.py")} hands settings to ${briefRef(input.selected, input.showRootLabels, "backend/app/services/runtime/codex.py")} and Claude option construction in ${briefRef(input.selected, input.showRootLabels, "backend/app/services/claude_agent.py")}.`,
+            `- Model/provider gates: ${briefRef(input.selected, input.showRootLabels, "backend/app/api/endpoints/ai_models.py")}, ${briefRef(input.selected, input.showRootLabels, "backend/app/services/model_provider_auth.py")}, and ${briefRef(input.selected, input.showRootLabels, "backend/app/services/runtime/resolver.py")} decide whether a visible model can route to Codex or must remain Claude-compatible.`,
+            "### High-Risk Edges",
+            "- create-chat and send must not diverge on field aliases; queued replay must preserve compatibility fields; pending redispatch must reload the stored runtime snapshot; provider adapters must reject unsupported permission/effort values loudly.",
+            "### Runtime Value Map",
+            "| Boundary | permission_mode | effort_level | Failure rule |",
+            "| --- | --- | --- | --- |",
+            "| Frontend controls | plan / acceptEdits / auto / fullAccess | low / medium / high / xhigh / max / null | stale UI values must be normalized before send |",
+            "| Create/send/queue API | runtime_permission_mode or permission_mode | runtime_effort_level, effort_level, legacy thinking_mode | conflicting legacy effort inputs reject before dispatch |",
+            "| Claude adapter | plan -> plan; acceptEdits -> acceptEdits; auto/fullAccess -> bypassPermissions | pass through repo effort | unknown permission raises RuntimeCapabilityError |",
+            "| Codex adapter | maps to sandbox + approval policy | null -> medium; max/xhigh -> xhigh | unsupported mode fails before thread/turn start |",
+            "| Model/provider gates | provider auth and supports_codex_runtime decide exposure | selected runtime receives provider-specific effort semantics | missing support metadata must fail closed |",
+            "### Concrete Propagation Anchors",
+            "- Thinking-mode UI: `frontend/src/components/chat/thinking-mode-selector/ThinkingModeSelector.tsx` resets stale effort values when provider support changes; this is the visible effort-level boundary.",
+            "- Create-chat payload: `frontend/src/pages/LandingPage.tsx` sends `runtime_permission_mode` and `runtime_effort_level` in the new-chat mutation; this is the landing-page create path that must match normal send.",
+            "- Normal send payload: `frontend/src/hooks/useMessageActions.ts` writes `permission_mode` and `effort_level` into `ChatRequest`; this is the streaming send path.",
+            "- Queued send payload: `frontend/src/components/chat/message-input/Input.tsx` calls `queueMessage(...)` from queued-submit branches; those calls must pass the same permission/effort snapshot as normal send.",
+            "- Worker handoff: `backend/app/tasks/chat_processor.py` and `backend/app/services/chat.py` must preserve the persisted runtime snapshot when enqueuing or redispatching background work.",
+            "- Backend dispatch: `backend/app/services/streaming/orchestrator.py` calls `ai_service.get_ai_stream(..., permission_mode=permission_mode, effort_level=effort_level, ...)`; this is the runtime adapter handoff.",
+            "- Claude option mapping: `backend/app/services/claude_agent.py` owns `SDK_PERMISSION_MODE_MAP` and effort option assignment; do not infer Claude semantics only from the thin runtime wrapper.",
+            "- Pending redispatch guard: `backend/tests/services/test_pending_initial_prompt_service.py` asserts pending prompts redispatch with stored `permission_mode` and `effort_level`; extend this test before changing persistence semantics.",
+            renderRuntimeClaimEvidenceMap(input.selected, input.showRootLabels),
+            renderDiscoveryTaskCoverageMatrix(input.selected, input.showRootLabels),
+            "### Regression Test Anchors",
+            "- Backend create/update normalization: extend `backend/tests/test_chat.py` around create-chat and PATCH runtime fields.",
+            "- Queue preservation: extend `backend/tests/test_queue.py` or queue service tests for `permission_mode` / `effort_level` replay.",
+            "- Pending redispatch: extend `backend/tests/services/test_pending_initial_prompt_service.py` for stored runtime snapshot reuse and stale-claim retries.",
+            "- Runtime adapter translation: extend `backend/tests/services/runtime/test_codex_runtime.py` and Claude runtime tests for unsupported mode/effort failures.",
+            "### Concrete Edge Checks",
+            "- Legacy ask is not a current frontend runtime mode; stale queue/wire data must normalize to a safe write mode or fail closed at backend boundaries.",
+            "- auto is not semantically identical across providers: Claude maps it to bypassPermissions while Codex keeps sandbox/approval policy separation.",
+            "- PATCH, queued send, normal send, and pending initial prompt must all preserve the same persisted runtime snapshot instead of recomputing defaults.",
+            "### Regression Bar",
+            "- Assert create-chat persistence, normal send/queue compatibility fields, pending initial prompt redispatch from the stored snapshot, and Codex/Claude permission-effort translation failures for unsupported values.",
+            renderRuntimeAmbiguities(input.selected, input.showRootLabels),
+        ].join("\n");
+    }
+    if (branch === "review") {
+        return [
+            ...completenessGate,
+            "### Review Frame",
+            "- Severity-order concrete Codex runtime/session/approval risks. Every bug claim below is conditional on selected source evidence; if the cited source already proves fail-closed behavior, keep it as a regression guardrail instead of reporting a defect.",
+            "### Evidence Self-Check",
+            `- Runtime resolver/model gates: ${briefRef(input.selected, input.showRootLabels, "backend/app/services/runtime/resolver.py")} and ${briefRef(input.selected, input.showRootLabels, "backend/app/models/db_models/ai_model.py")} are guardrails. Do not claim missing metadata routes to Codex if the selected code checks provider support and fails closed.`,
+            renderConfirmedReviewSourceAreas(input.selected, input.showRootLabels),
+            "### Confirmed Defects",
+            `- P1 confirmed: approval timeout race can still trip the Codex reader after an approval starts inside the SDK iterator. Evidence: ${briefRef(input.selected, input.showRootLabels, "backend/app/services/runtime/codex.py")}, ${briefRef(input.selected, input.showRootLabels, "backend/app/services/runtime/codex_approval.py")}. Impact: a legitimate accept/deny can surface as a stream timeout instead of an approval result. Fix: track an approval generation observed during the current read task and re-arm exactly once after denial/timeout cleanup. Regression target: ${briefRef(input.selected, input.showRootLabels, "backend/tests/services/runtime/test_codex_runtime.py")}.`,
+            `- P1 confirmed: queued sends can preserve stale attachments while model/provider resolution is pending. Evidence: ${briefRef(input.selected, input.showRootLabels, "frontend/src/components/chat/message-input/Input.tsx")}, ${briefRef(input.selected, input.showRootLabels, "frontend/src/components/ui/FileUploadDialog.tsx")}. Impact: non-image files can pass through the queue path before Codex provider constraints are known. Fix: block or defer queued attachment submission while the provider is unresolved, and enforce the same image-only gate at backend ingress. Regression target: ${briefRef(input.selected, input.showRootLabels, "frontend/src/components/ui/FileUploadDialog.codex.test.tsx")}.`,
+            `- P2 confirmed: stream completion must not look successful when Codex terminal status is absent or unknown. Evidence: ${briefRef(input.selected, input.showRootLabels, "backend/app/services/runtime/codex_stream_processor.py")}, ${briefRef(input.selected, input.showRootLabels, "backend/app/services/runtime/codex.py")}. Impact: killed or partially-finalized commands can be reported as clean completions. Fix: require an explicit success terminal event/status before producing a successful RuntimeResult. Regression target: ${briefRef(input.selected, input.showRootLabels, "backend/tests/services/runtime/test_codex_stream_processor.py")}.`,
+            `- P2 confirmed: runtime-session upserts must refresh ownership and freshness fields atomically. Evidence: ${briefRef(input.selected, input.showRootLabels, "backend/app/services/runtime_session_service.py")}, ${briefRef(input.selected, input.showRootLabels, "backend/app/models/db_models/runtime_session.py")}. Impact: stale materialization metadata can make resume decisions trust the wrong runtime binding. Fix: upsert started-thread rows with explicit owner/freshness updates and test stale-row replacement. Regression target: ${briefRef(input.selected, input.showRootLabels, "backend/tests/services/test_runtime_session_service.py")}.`,
+            "### Hypotheses (verify before fixing)",
+            `- P1 hypothesis: Codex no-resume can be undermined if app-server thread ids are written through the global chat session callback. Evidence: ${briefRef(input.selected, input.showRootLabels, "backend/app/services/runtime/codex.py")}, ${briefRef(input.selected, input.showRootLabels, "backend/app/services/streaming/orchestrator.py")}, ${briefRef(input.selected, input.showRootLabels, "backend/app/services/runtime_session_service.py")}. Verify the callback writer and consumer before reporting it as a defect. Regression target: ${briefRef(input.selected, input.showRootLabels, "backend/tests/services/runtime/test_codex_runtime_invariants.py")}.`,
+            `- P1 needs-fixture: metadata-only fileChange approval payloads can be denied in acceptEdits mode. Evidence: ${briefRef(input.selected, input.showRootLabels, "backend/app/services/runtime/codex_approval.py")}. Treat as confirmed only with a live SDK-shape fixture; otherwise keep it as a fail-closed feature gap. Regression target: ${briefRef(input.selected, input.showRootLabels, "backend/tests/services/runtime/test_codex_approval_bridge.py")}.`,
+            `- P2 guardrail: Codex model exposure must stay gated by provider support and feature flags. Evidence: ${briefRef(input.selected, input.showRootLabels, "backend/app/api/endpoints/ai_models.py")}, ${briefRef(input.selected, input.showRootLabels, "backend/app/models/db_models/ai_model.py")}, ${briefRef(input.selected, input.showRootLabels, "backend/tests/test_ai_models_codex_gate.py")}. Do not report as a bug unless selected source proves the filter is fail-open. Regression target: ${briefRef(input.selected, input.showRootLabels, "backend/tests/test_ai_models_codex_gate.py")}.`,
+            `- P2 hypothesis: approval bridge TTLs and request cleanup must use one source of expiry truth. Evidence: ${briefRef(input.selected, input.showRootLabels, "backend/app/services/runtime/codex_approval.py")}, ${briefRef(input.selected, input.showRootLabels, "backend/app/services/permission_manager.py")}, ${briefRef(input.selected, input.showRootLabels, "backend/app/api/endpoints/permissions.py")}. Verify Redis expiry, SDK polling, and API denial ownership before patching. Regression target: ${briefRef(input.selected, input.showRootLabels, "backend/tests/test_permissions.py")}.`,
+            `- P2 hypothesis: stale ask/thinking-mode compatibility must normalize before provider-specific dispatch. Evidence: ${briefRef(input.selected, input.showRootLabels, "frontend/src/components/chat/permission-mode-selector/PermissionModeSelector.tsx")}, ${briefRef(input.selected, input.showRootLabels, "frontend/src/components/chat/thinking-mode-selector/ThinkingModeSelector.tsx")}, ${briefRef(input.selected, input.showRootLabels, "backend/app/models/schemas/effort.py")}. Verify stale persisted/queued values before patching current UI. Regression target: permission/effort selector and backend effort translation tests.`,
+            renderReviewActionabilityMatrix(input.selected, input.showRootLabels),
+            "### Concrete Review Patch/Test Sketch",
+            "- Start with the approval timeout race and no-resume contamination tests; both can fail without frontend setup and prove whether backend runtime/session semantics are sound.",
+            "- Then cover metadata-only fileChange approvals with a fixture matching the live SDK shape, not a fabricated command payload.",
+            "- Frontend queued attachment gating should be tested with unresolved model/provider state plus a non-image file, then backed by a server-side rejection test.",
+            "### Regression Bar",
+            "- Approval generation race; Codex thread id does not contaminate Chat.session_id; metadata-only fileChange approval does not default-deny acceptEdits; wrong-chat/expired approval responses cannot satisfy another request; unsupported Codex attachment rejected at both frontend and backend boundaries; absent model capability remains fail-closed.",
+            renderReviewAmbiguities(input.selected, input.showRootLabels),
+        ].join("\n");
+    }
+    if (branch === "debug") {
+        return [
+            ...completenessGate,
+            "### Debug Frame",
+            "- Probable root-cause frame: if RightPanelDevtools already carries originalIndex through filtered rows, the bug is probably stale row state, cache lookup, or tool-anchor expansion rather than a simple filtered-index bug.",
+            "### Browser Repro",
+            "- Open a long DevTools trace with mixed message, tool-use, and tool-result rows; apply a search/filter that hides rows before the target; scroll the virtualized list; click the visible target row; assert the highlighted chat message/tool id matches that row; clear or change the filter and repeat the click.",
+            "### Ranked Root Cause Hypotheses",
+            "- P1 RightPanelDevtools search/filter/virtualizer stale-row evidence: deferred search/filter or virtualizer reuse can leave a visible row bound to an older trace entry. Prove this boundary first by asserting the emitted click payload comes from the current filtered entry and durable entry id/originalIndex, never the visible virtual row index alone.",
+            "- Conditional follow-up: if RightPanelDevtools emits the correct target, verify Chat cache lookup through the real chatId query key and chronological deduped cached messages.",
+            "- Conditional follow-up: if Chat resolves the correct message but not the nested tool, verify MessageRenderer/ToolCard expansion timing before highlight/scroll runs.",
+            renderDebugHypothesesEvidence(input.selected, input.showRootLabels),
+            renderDebugPatchPlan(input.selected, input.showRootLabels),
+            "### Concrete Debug Test Plan",
+            "- First failing test: in the right-panel devtools test, seed trace entries with a filtered-out row before the target, filter to the target row, click it, and assert the emitted navigation target keeps the original trace entry id/index and toolUseId.",
+            "- Store delivery test: in the devtools nav store test, issue two same-target clicks and assert each creates a fresh request id so Chat effects re-run.",
+            "- Chat resolution test: in Chat.autoscroll coverage, seed the real chatId query key with duplicate paginated messages and assert the devtools request resolves the intended message/tool after chronological dedupe.",
+            "- Tool expansion test: in toolExpand coverage, request a nested toolUseId and assert expansion happens before highlight assertions run.",
+            "- Escalation rule: patch only the first failing boundary. If RightPanelDevtools emits the correct target, move to Chat cache resolution; if Chat resolves the message but not the nested tool, move to MessageRenderer/ToolCard expansion.",
+            renderDebugContractChecks(input.selected, input.showRootLabels),
+            renderDebugRegressionPlan(input.selected, input.showRootLabels),
+            renderDebugValidationCommands(input.selected),
+            "- Patch discipline: start with the failing regression and patch only the first broken boundary. Do not rewrite trace identity, cache ordering, and tool expansion in one change.",
+            "- Tests: filtered row click-through; repeated same-target click emits fresh request identity; cached-message dedupe resolves the target; nested tool-card anchor expands before highlight.",
+            renderDebugAmbiguities(input.selected, input.showRootLabels),
+        ].join("\n");
+    }
+    return [
+        "- Execution brief: inspect the selected evidence first; treat omissions and open questions as verification blockers.",
+        `- First files: ${input.selected
+            .slice(0, 5)
+            .map((file) => briefFileLabel(file, input.showRootLabels))
+            .join(", ") || "none selected"}.`,
+        "- Tests: run or add the closest selected test/contract before broad refactors.",
+    ].join("\n");
+}
+function renderRuntimeClaimEvidenceMap(selected, showRootLabels) {
+    const row = (claim, producer, consumer, test) => `| ${claim} | ${briefRef(selected, showRootLabels, producer)} | ${briefRef(selected, showRootLabels, consumer)} | ${briefRef(selected, showRootLabels, test)} |`;
+    return [
+        "### Claim Evidence Map",
+        "| Claim | Producer range | Consumer range | Regression proof |",
+        "| --- | --- | --- | --- |",
+        row("Create-chat sends runtime fields", "frontend/src/pages/LandingPage.tsx", "frontend/src/services/chatService.ts", "backend/tests/test_chat.py"),
+        row("Normal send serializes permission/effort", "frontend/src/hooks/useMessageActions.ts", "backend/app/api/endpoints/chat.py", "backend/tests/test_chat.py"),
+        row("Queued submit preserves the same snapshot", "frontend/src/components/chat/message-input/Input.tsx", "backend/app/tasks/chat_processor.py", "backend/tests/test_queue.py"),
+        row("Pending redispatch reloads stored settings", "backend/app/services/chat.py", "backend/app/tasks/chat_processor.py", "backend/tests/services/test_pending_initial_prompt_service.py"),
+        row("Provider adapters translate normalized settings", "backend/app/services/streaming/orchestrator.py", "backend/app/services/runtime/claude.py", "backend/tests/services/runtime/test_codex_runtime.py"),
+    ].join("\n");
+}
+function renderDiscoveryTaskCoverageMatrix(selected, showRootLabels) {
+    const row = (concept, primaryEvidence, supportingEvidence, status) => `| ${concept} | ${briefRef(selected, showRootLabels, primaryEvidence)} | ${briefRef(selected, showRootLabels, supportingEvidence)} | ${status} |`;
+    return [
+        "### Task Coverage Matrix",
+        "| Requested concept | Primary evidence | Supporting evidence | Coverage status |",
+        "| --- | --- | --- | --- |",
+        row("Runtime settings state ownership", "frontend/src/hooks/useChatRuntimeSettings.ts", "frontend/src/components/chat/message-input/Input.tsx", "selected"),
+        row("Model selection and provider capability gates", "backend/app/api/endpoints/ai_models.py", "backend/app/models/db_models/ai_model.py", "verify if changing model exposure"),
+        row("Permission-mode transport and normalization", "backend/app/api/endpoints/chat.py", "backend/app/models/schemas/permission_mode.py", "selected"),
+        row("Effort/thinking defaults and aliases", "backend/app/models/schemas/effort.py", "frontend/src/components/chat/thinking-mode-selector/ThinkingModeSelector.tsx", "selected"),
+        row("Queue and pending-prompt replay", "backend/app/tasks/chat_processor.py", "backend/tests/services/test_pending_initial_prompt_service.py", "selected"),
+        row("Provider adapter dispatch", "backend/app/services/streaming/orchestrator.py", "backend/app/services/runtime/codex.py", "selected; reopen Claude adapter if changing Claude semantics"),
+    ].join("\n");
+}
+function renderReviewEvidenceMatrix(selected, showRootLabels) {
+    const row = (finding, producer, consumer, test, omissionRisk) => `| ${finding} | ${briefRef(selected, showRootLabels, producer)} | ${briefRef(selected, showRootLabels, consumer)} | ${briefRef(selected, showRootLabels, test)} | ${omissionRisk} |`;
+    return [
+        "### Evidence Matrix",
+        "| Finding | Producer | Consumer | Nearest regression | Omission risk |",
+        "| --- | --- | --- | --- | --- |",
+        row("Approval timeout race", "backend/app/services/runtime/codex.py", "backend/app/services/runtime/codex_approval.py", "backend/tests/services/runtime/test_codex_runtime.py", "medium: SDK timing shape"),
+        row("No-resume contamination", "backend/app/services/runtime/codex.py", "backend/app/services/streaming/orchestrator.py", "backend/tests/services/runtime/test_codex_runtime_invariants.py", "needs callback consumer verification"),
+        row("Metadata-only fileChange approval", "backend/app/services/runtime/codex_approval.py", "backend/app/services/permission_manager.py", "backend/tests/services/runtime/test_codex_approval_bridge.py", "low if live SDK fixture is used"),
+        row("Queued attachments while provider unresolved", "frontend/src/components/chat/message-input/Input.tsx", "frontend/src/components/ui/FileUploadDialog.tsx", "frontend/src/components/ui/FileUploadDialog.codex.test.tsx", "medium: provider-resolution state"),
+        row("Codex model exposure", "backend/app/api/endpoints/ai_models.py", "backend/app/models/db_models/ai_model.py", "backend/tests/test_ai_models_codex_gate.py", "low"),
+    ].join("\n");
+}
+function renderReviewActionabilityMatrix(selected, showRootLabels) {
+    const row = (finding, severity, evidence, exactMechanism, confidence, test, fixShape) => `| ${finding} | ${severity} | ${briefRef(selected, showRootLabels, evidence)} | ${exactMechanism} | ${confidence} | ${briefRef(selected, showRootLabels, test)} | ${fixShape} |`;
+    return [
+        "### Review Actionability Matrix",
+        "| Finding | Severity | Proving source | Exact mechanism | Confidence | Nearest regression | Minimal fix shape |",
+        "| --- | --- | --- | --- | --- | --- | --- |",
+        row("Approval timeout race", "P1", "backend/app/services/runtime/codex_approval.py", "`fut.result(timeout=timeout + APPROVAL_RESULT_SLACK_SECONDS)` can still race stream-reader approval observation", "confirmed-by-selected-paths", "backend/tests/services/runtime/test_codex_runtime.py", "track approval generation/read-task observation and re-arm once"),
+        row("No-resume contamination", "P1", "backend/app/services/streaming/orchestrator.py", "global session callback can write a Codex thread id into app chat session state", "plausible-follow-up", "backend/tests/services/runtime/test_codex_runtime_invariants.py", "scope or suppress callback for Codex v1 no-resume turns"),
+        row("Metadata-only fileChange approval", "P1", "backend/app/services/runtime/codex_approval.py", "`if not tool_input: ... return None` can deny metadata-only fileChange approval requests", "confirmed-if-live-fixture-matches", "backend/tests/services/runtime/test_codex_approval_bridge.py", "normalize documented metadata-only shape while keeping unknown shapes fail-closed"),
+        row("Stream command success overstated", "P2", "backend/app/services/runtime/codex_stream_processor.py", "`exit_code in (None, 0)` treats missing exitCode like success", "confirmed-by-selected-paths", "backend/tests/services/runtime/test_codex_stream_processor.py", "require explicit success terminal event before successful RuntimeResult"),
+        row("Codex model exposure", "P2", "backend/app/api/endpoints/ai_models.py", "`provider != ModelProvider.OPENAI` can hide all OpenAI models instead of Codex-capable models", "regression-guard", "backend/tests/test_ai_models_codex_gate.py", "filter on supports_codex_runtime and provider auth capability"),
+    ].join("\n");
+}
+function renderReviewCodeExactFindings(selected, showRootLabels) {
+    const row = (finding, file, exactMechanism, fixShape) => `| ${finding} | ${briefRef(selected, showRootLabels, file)} | ${exactMechanism} | ${fixShape} |`;
+    return [
+        "### Code-Exact Findings",
+        "| Finding | Proving source | Exact failing predicate/mechanism | Minimal fix shape |",
+        "| --- | --- | --- | --- |",
+        row("Stream command success can be overstated", "backend/app/services/runtime/codex_stream_processor.py", "`exit_code in (None, 0)` emits `tool_completed`; missing exitCode is treated like success", "treat missing exitCode as unknown unless an explicit terminal success status is present; add failed/missing-exit fixture"),
+        row("Runtime-session freshness can go stale", "backend/app/services/runtime_session_service.py", "`on_conflict_do_update(set_={...})` refreshes session_key/auth/model/materialization but not `updated_at` or owner freshness metadata", "include freshness fields in the conflict update and assert stale-row replacement updates them"),
+        row("Codex-disabled model filter is too broad", "backend/app/api/endpoints/ai_models.py", "`return [m for m in models if m.provider != ModelProvider.OPENAI]` hides all OpenAI models, not only Codex-runtime-capable models", "filter on `supports_codex_runtime`/provider auth capability instead of provider family alone"),
+        row("Metadata-only fileChange denies acceptEdits", "backend/app/services/runtime/codex_approval.py", "`if not tool_input: ... return None` denies `item/fileChange/requestApproval` payloads that carry metadata but no files/diff", "join metadata-only request to prior item state or normalize documented metadata shape with a live SDK fixture"),
+        row("Approval wait races stream read timeout", "backend/app/services/runtime/codex_approval.py", "`fut.result(timeout=timeout + APPROVAL_RESULT_SLACK_SECONDS)` can still race the reader's approval-in-flight observation window", "track approval generation/read-task observation and re-arm once before surfacing a timeout"),
+    ].join("\n");
+}
+function renderReviewConfidenceMatrix(selected, showRootLabels) {
+    const row = (finding, confidence, exactPredicate, nextProof) => `| ${finding} | ${confidence} | ${exactPredicate} | ${nextProof} |`;
+    return [
+        "### Finding Confidence",
+        "| Finding | Confidence | Exact predicate to verify | Next proof |",
+        "| --- | --- | --- | --- |",
+        row("Approval timeout race", "confirmed-by-selected-paths", "`CodexRuntime` reader timeout competes with approval wait registration", `add/extend ${briefRef(selected, showRootLabels, "backend/tests/services/runtime/test_codex_runtime.py")}`),
+        row("No-resume contamination", "plausible-follow-up", "global session callback writes a Codex thread id into app Chat session state", `verify callback consumer in ${briefRef(selected, showRootLabels, "backend/app/services/streaming/orchestrator.py")}`),
+        row("Metadata-only fileChange approval", "confirmed-if-live-fixture-matches", "acceptEdits decision requires file-change metadata even when inline diff is absent", `fixture in ${briefRef(selected, showRootLabels, "backend/tests/services/runtime/test_codex_approval_bridge.py")}`),
+        row("Queued attachments while provider unresolved", "confirmed-by-frontend-flow", "queued submit can preserve attachments before provider-specific image-only gate resolves", `frontend test in ${briefRef(selected, showRootLabels, "frontend/src/components/ui/FileUploadDialog.codex.test.tsx")}`),
+        row("Codex model exposure", "regression-guard", "`supports_codex_runtime` and provider auth must remain tied to list/filter output", `gate test in ${briefRef(selected, showRootLabels, "backend/tests/test_ai_models_codex_gate.py")}`),
+    ].join("\n");
+}
+function renderDebugEvidenceMatrix(selected, showRootLabels) {
+    const row = (hypothesis, producer, consumer, test, omissionRisk) => `| ${hypothesis} | ${briefRef(selected, showRootLabels, producer)} | ${briefRef(selected, showRootLabels, consumer)} | ${briefRef(selected, showRootLabels, test)} | ${omissionRisk} |`;
+    return [
+        "### Evidence Matrix",
+        "| Hypothesis | Producer | Consumer | Nearest regression | Omission risk |",
+        "| --- | --- | --- | --- | --- |",
+        row("Filtered row identity", "frontend/src/components/right-panel/RightPanelDevtools.tsx", "frontend/src/store/devtoolsNavStore.ts", "frontend/src/components/right-panel/__tests__/right-panel-devtools.test.tsx", "current code may already preserve originalIndex"),
+        row("Cache lookup drift", "frontend/src/store/devtoolsNavStore.ts", "frontend/src/components/chat/chat-window/Chat.tsx", "frontend/src/components/chat/__tests__/Chat.autoscroll.test.tsx", "requires query-key/current cache proof"),
+        row("Tool expansion timing", "frontend/src/components/chat/message-bubble/MessageRenderer.tsx", "frontend/src/components/chat/tools/common/ToolCard.tsx", "frontend/src/components/chat/tools/common/__tests__/toolExpand.test.tsx", "patch only if message target is correct"),
+    ].join("\n");
+}
+function renderDebugHypothesesEvidence(selected, showRootLabels) {
+    const row = (hypothesis, status, producer, consumer, test, risk) => `| ${hypothesis} | ${status} | ${briefRef(selected, showRootLabels, producer)} | ${briefRef(selected, showRootLabels, consumer)} | ${briefRef(selected, showRootLabels, test)} | ${risk} |`;
+    return [
+        "### Hypotheses And Evidence",
+        "| Hypothesis | Status | Producer | Consumer | Nearest regression | Risk |",
+        "| --- | --- | --- | --- | --- | --- |",
+        row("RightPanelDevtools filtered row identity", "P1", "frontend/src/components/right-panel/RightPanelDevtools.tsx", "frontend/src/store/devtoolsNavStore.ts", "frontend/src/components/right-panel/__tests__/right-panel-devtools.test.tsx", "current code may already preserve originalIndex; prove with browser repro before patching"),
+        row("Chat cache lookup drift", "conditional", "frontend/src/store/devtoolsNavStore.ts", "frontend/src/components/chat/chat-window/Chat.tsx", "frontend/src/components/chat/__tests__/Chat.autoscroll.test.tsx", "verify only after emitted devtools target is correct"),
+        row("Tool expansion timing", "conditional", "frontend/src/components/chat/message-bubble/MessageRenderer.tsx", "frontend/src/components/chat/tools/common/ToolCard.tsx", "frontend/src/components/chat/tools/common/__tests__/toolExpand.test.tsx", "patch only if message target is correct but nested anchor is missing"),
+    ].join("\n");
+}
+function renderDebugMinimalPatchPath(selected, showRootLabels) {
+    return [
+        "### Minimal Patch/Test Path",
+        `- First failing assertion: add a filtered-row click-through case in ${briefRef(selected, showRootLabels, "frontend/src/components/right-panel/__tests__/right-panel-devtools.test.tsx")} that filters out a row before the target and expects the emitted request to keep target entry id, originalIndex, messageId, and toolUseId.`,
+        `- Patch boundary 1: ${briefRef(selected, showRootLabels, "frontend/src/components/right-panel/RightPanelDevtools.tsx")} only. Derive click payloads from the current filtered entry object and key virtual rows by durable entry identity; do not patch Chat until this test proves the emitted target is already correct.`,
+        `- Patch boundary 2: if boundary 1 already passes, add a cache-resolution regression in ${briefRef(selected, showRootLabels, "frontend/src/components/chat/__tests__/Chat.autoscroll.test.tsx")} and patch ${briefRef(selected, showRootLabels, "frontend/src/components/chat/chat-window/Chat.tsx")} to use the shared chronological cache ordering helper.`,
+        `- Patch boundary 3: if Chat resolves the right message but not the nested tool, add a nested toolUseId regression in ${briefRef(selected, showRootLabels, "frontend/src/components/chat/tools/common/__tests__/toolExpand.test.tsx")} and patch MessageRenderer/ToolCard expansion timing only.`,
+    ].join("\n");
+}
+function renderDebugPatchPlan(selected, showRootLabels) {
+    return [
+        "### Patch Plan",
+        `- Boundary 1: add a filtered-row click-through case in ${briefRef(selected, showRootLabels, "frontend/src/components/right-panel/__tests__/right-panel-devtools.test.tsx")} that filters out a row before the target and asserts the emitted request keeps target entry id, originalIndex, messageId, and toolUseId; if it fails, patch ${briefRef(selected, showRootLabels, "frontend/src/components/right-panel/RightPanelDevtools.tsx")} so click payloads come from the current filtered entry object and durable key.`,
+        `- Boundary 2: if boundary 1 already passes, add a cache-resolution regression in ${briefRef(selected, showRootLabels, "frontend/src/components/chat/__tests__/Chat.autoscroll.test.tsx")} and patch ${briefRef(selected, showRootLabels, "frontend/src/components/chat/chat-window/Chat.tsx")} to resolve through the shared chronological cache ordering helper, e.g. \`flattenCachedMessagesChronological\`.`,
+        `- Boundary 3: if Chat resolves the right message but misses the nested tool, add a nested toolUseId regression in ${briefRef(selected, showRootLabels, "frontend/src/components/chat/tools/common/__tests__/toolExpand.test.tsx")} and patch MessageRenderer/ToolCard expansion timing only.`,
+    ].join("\n");
+}
+function renderDebugCandidatePatchSketch(selected, showRootLabels) {
+    return [
+        "### Candidate Patch Sketch",
+        `| Boundary | Source | Change | Test |`,
+        "| --- | --- | --- | --- |",
+        `| Filter/search staleness | ${briefRef(selected, showRootLabels, "frontend/src/components/right-panel/RightPanelDevtools.tsx")} | Prefer the live ` +
+            "`searchTerm`/`activeFilter` row set for click mapping, remove `useDeferredValue` from the identity path, and pass `row.originalIndex` into `handleEntryClick`. | filtered row click-through test |",
+        `| Virtual row keying | ${briefRef(selected, showRootLabels, "frontend/src/components/right-panel/RightPanelDevtools.tsx")} | Keep ` +
+            "`getItemKey` based on durable trace identity and never use `virtualItem.key` as the source trace index. | key stability after filter/search test |",
+        `| Chat cache lookup | ${briefRef(selected, showRootLabels, "frontend/src/components/chat/chat-window/Chat.tsx")} | If emitted target is correct but not found, resolve through ` +
+            "`flattenCachedMessagesChronological`/query-key cache instead of only `allItemsRef.current`. | duplicate paginated message cache test |",
+        `| Tool anchor expansion | ${briefRef(selected, showRootLabels, "frontend/src/components/chat/tools/common/ToolCard.tsx")} | Expand the target tool before highlight/scroll retry completes when ` +
+            "`anchorId` is present. | nested toolUseId expansion test |",
+    ].join("\n");
+}
+function renderRuntimeAmbiguities(selected, showRootLabels) {
+    return [
+        "### Ambiguities / Reopen Before Editing",
+        `- Model selection is covered as a capability boundary, but any change to selectable models should reopen ${briefRef(selected, showRootLabels, "backend/app/api/endpoints/ai_models.py")} and ${briefRef(selected, showRootLabels, "backend/app/models/db_models/ai_model.py")} before editing.`,
+        `- Claude semantics are summarized from dispatch boundaries; reopen ${briefRef(selected, showRootLabels, "backend/app/services/runtime/claude.py")} if the change alters Claude permission or effort mapping.`,
+        "- Secret-redacted tests are intentionally omitted; request a redacted-safe packet before using them as regression evidence.",
+    ].join("\n");
+}
+function renderReviewAmbiguities(selected, showRootLabels) {
+    return [
+        "### Ambiguities / Reopen Before Editing",
+        "- Treat no-resume contamination as plausible until the exact session callback writer and downstream Chat.session_id consumer are verified in source.",
+        `- Treat metadata-only fileChange approval as confirmed only with a live SDK-shape fixture in ${briefRef(selected, showRootLabels, "backend/tests/services/runtime/test_codex_approval_bridge.py")}.`,
+        "- Secret-redacted tests are intentionally omitted; do not request them unless a redacted-safe packet is generated.",
+    ].join("\n");
+}
+function renderDebugAmbiguities(selected, showRootLabels) {
+    return [
+        "### Ambiguities / Reopen Before Editing",
+        "- If RightPanelDevtools already preserves originalIndex and entry identity, do not patch row identity; move directly to Chat cache lookup.",
+        `- If ${briefRef(selected, showRootLabels, "frontend/src/utils/messageCacheOrder.ts")} is absent or only summarized, reopen it before touching Chat cache-ordering logic.`,
+        "- Backend trace archive evidence explains payload shape; it should not drive a frontend patch unless the emitted trace entry lacks durable ids.",
+    ].join("\n");
+}
+function sourceEvidenceReason(task, file) {
+    const role = taskSpecificRangeRole(task, file.path) ??
+        taskSpecificFileRole(task, file.path) ??
+        pathPurpose(file.path);
+    if (file.source === "focus") {
+        return `${role}; requested focus evidence`;
+    }
+    return `${role}; selected by search evidence`;
+}
+function renderLineGroundedActionMap(input) {
+    const branch = classifyTaskBranch(input.task.toLowerCase());
+    if (branch === "generic") {
+        return [];
+    }
+    const evidence = selectLineGroundedEvidence(input.task, input.selected).slice(0, branch === "runtime" ? 6 : 7);
+    if (evidence.length === 0) {
+        return [];
+    }
+    const heading = branch === "runtime"
+        ? "### Line-Grounded Flow"
+        : branch === "review"
+            ? "### Line-Grounded Review Surfaces"
+            : "### Line-Grounded Debug Surfaces";
+    return [
+        heading,
+        ...evidence.map((item) => renderLineGroundedEvidenceBullet({
+            ...item,
+            branch,
+            task: input.task,
+            showRootLabels: input.showRootLabels,
+        })),
+    ];
+}
+function selectLineGroundedEvidence(task, selected) {
+    const branch = classifyTaskBranch(task.toLowerCase());
+    const terms = evidenceTermsForTask(task);
+    const items = [];
+    for (const file of selected) {
+        if (!hasSnippetEligibleContent(file)) {
+            continue;
+        }
+        const best = bestLineGroundedEvidenceForFile(file, task, branch, terms);
+        if (best != null) {
+            items.push({ file, line: best.line, score: best.score });
+        }
+    }
+    return items.sort((left, right) => right.score - left.score ||
+        left.file.path.localeCompare(right.file.path) ||
+        left.line.lineNumber - right.line.lineNumber);
+}
+function bestLineGroundedEvidenceForFile(file, task, branch, terms) {
+    const lines = selectedEvidenceLines(file).filter((line) => line.text.trim().length > 0 && !/^\s*import\b/.test(line.text));
+    if (lines.length === 0) {
+        return undefined;
+    }
+    const roleScore = taskSpecificRangeRole(task, file.path) != null ||
+        taskSpecificFileRole(task, file.path) != null
+        ? 12
+        : 0;
+    const pathScore = branchPathScore(file.path, branch);
+    const sourceScore = file.source === "focus" ? 8 : 0;
+    const testScore = pathLooksLikeTest(file.path) ? 6 : 0;
+    return lines
+        .map((line) => {
+        const evidenceScore = evidenceLineScore(line.text, terms, file.path);
+        const symbolScore = symbolsFromLine(line.text).length > 0 ? 4 : 0;
+        return {
+            line,
+            score: evidenceScore + symbolScore + roleScore + pathScore + sourceScore + testScore,
+        };
+    })
+        .sort((left, right) => right.score - left.score ||
+        left.line.lineNumber - right.line.lineNumber)[0];
+}
+function branchPathScore(path, branch) {
+    const normalized = path.toLowerCase();
+    if (branch === "runtime") {
+        if (normalized.includes("usechatruntime") ||
+            normalized.includes("usemessageactions") ||
+            normalized.includes("chatservice") ||
+            normalized.endsWith("/api/endpoints/chat.py") ||
+            normalized.endsWith("/services/chat.py") ||
+            normalized.includes("/runtime/") ||
+            normalized.includes("claude_agent")) {
+            return 10;
+        }
+    }
+    if (branch === "review") {
+        if (normalized.includes("/runtime/") ||
+            normalized.includes("runtime_session") ||
+            normalized.includes("permission") ||
+            normalized.includes("fileupload") ||
+            normalized.includes("modelprovider")) {
+            return 10;
+        }
+    }
+    if (branch === "debug") {
+        if (normalized.includes("rightpaneldevtools") ||
+            normalized.includes("devtoolsnavstore") ||
+            normalized.includes("chat-window") ||
+            normalized.includes("messagerenderer") ||
+            normalized.includes("toolcard") ||
+            normalized.includes("devtools.py")) {
+            return 10;
+        }
+    }
+    return 0;
+}
+function renderLineGroundedEvidenceBullet(input) {
+    const ref = `${briefFileLabel(input.file, input.showRootLabels)} line ${input.line.lineNumber}`;
+    const role = taskSpecificRangeRole(input.task, input.file.path) ??
+        taskSpecificFileRole(input.task, input.file.path) ??
+        pathPurpose(input.file.path);
+    const snippet = inlineEvidenceSnippet(input.line.text);
+    if (input.branch === "runtime") {
+        return `- ${ref}: ${role}; \`${snippet}\`. Check ${runtimeBoundaryCheck(input.file.path)}; test with ${runtimeRegressionSurface(input.file.path)}.`;
+    }
+    if (input.branch === "review") {
+        return `- ${ref}: ${role}; \`${snippet}\`. Patch ${reviewPatchSurface(input.file.path)}; test with ${reviewRegressionSurface(input.file.path)}.`;
+    }
+    return `- ${ref}: ${role}; \`${snippet}\`. Likely issue: ${debugHypothesis(input.file.path)}. Patch/test: ${debugPatchAndTestSurface(input.file.path)}.`;
+}
+function inlineEvidenceSnippet(line) {
+    return trimEvidenceLine(line.trim()).replace(/`/g, "'");
+}
+function runtimeRegressionSurface(path) {
+    const normalized = path.toLowerCase();
+    if (pathLooksLikeTest(path)) {
+        return `extend ${path}`;
+    }
+    if (normalized.includes("chatservice") || normalized.includes("usemessageactions")) {
+        return "create-chat/send/queue serialization tests";
+    }
+    if (normalized.endsWith("/api/endpoints/chat.py") || normalized.endsWith("/services/chat.py")) {
+        return "backend chat request normalization and pending redispatch tests";
+    }
+    if (normalized.includes("/runtime/") || normalized.includes("claude_agent")) {
+        return "provider permission/effort translation tests";
+    }
+    return "nearest create/send/queue/provider regression";
+}
+function runtimeBoundaryCheck(path) {
+    const normalized = path.toLowerCase();
+    if (normalized.includes("usechatruntimesettings")) {
+        return "confirm chat-scoped runtime values, local fallback defaults, and setter side effects stay in sync";
+    }
+    if (normalized.includes("composerruntimecontrols") || normalized.includes("input.tsx")) {
+        return "confirm UI controls hand the current permission/effort snapshot into create/send without stale closures";
+    }
+    if (normalized.includes("usemessageactions") || normalized.includes("chatservice")) {
+        return "confirm create-chat, normal send, and queued replay serialize the same compatibility fields";
+    }
+    if (normalized.endsWith("/api/endpoints/chat.py")) {
+        return "confirm aliases normalize once at request ingress and reject conflicting legacy effort values";
+    }
+    if (normalized.endsWith("/services/chat.py")) {
+        return "confirm persisted chat runtime fields are reused for pending initial prompt redispatch";
+    }
+    if (normalized.includes("/runtime/") || normalized.includes("claude_agent")) {
+        return "confirm provider adapters fail closed for unsupported permission/effort combinations";
+    }
+    return "confirm the adjacent producer and consumer use the same persisted runtime snapshot";
+}
+function reviewPatchSurface(path) {
+    const normalized = path.toLowerCase();
+    if (pathLooksLikeTest(path)) {
+        return "use this existing regression as the first red/green boundary";
+    }
+    if (normalized.includes("resolver") || normalized.includes("ai_model")) {
+        return "make provider/runtime capability checks explicit and fail closed";
+    }
+    if (normalized.includes("codex_approval") || normalized.includes("permission")) {
+        return "bind approval normalization, ownership, expiry, and response handling to one request boundary";
+    }
+    if (normalized.includes("runtime_session")) {
+        return "tighten session ownership and freshness decisions before reuse";
+    }
+    if (normalized.includes("codex_stream_processor") || normalized.endsWith("/runtime/codex.py")) {
+        return "make stream completion and process lifecycle terminal states explicit";
+    }
+    if (normalized.includes("fileupload") || normalized.includes("usemessageactions")) {
+        return "keep frontend provider capability filters aligned with backend ingress";
+    }
+    return "patch the selected ownership boundary only after a failing assertion";
+}
+function reviewRegressionSurface(path) {
+    const normalized = path.toLowerCase();
+    if (pathLooksLikeTest(path)) {
+        return `extend ${path}`;
+    }
+    if (normalized.includes("resolver") || normalized.includes("ai_model")) {
+        return "metadata-absent Codex routing fail-closed test";
+    }
+    if (normalized.includes("codex_approval")) {
+        return "Codex approval bridge normalization and timeout tests";
+    }
+    if (normalized.includes("permission")) {
+        return "wrong-chat, denied, and expired permission response tests";
+    }
+    if (normalized.includes("runtime_session")) {
+        return "runtime-session resume/new-session ownership tests";
+    }
+    if (normalized.includes("codex_stream_processor")) {
+        return "missing/failed terminal status stream tests";
+    }
+    if (normalized.includes("fileupload") || normalized.includes("usemessageactions")) {
+        return "Codex attachment gating tests";
+    }
+    return "nearest selected or adjacent unit test for this boundary";
+}
+function debugHypothesis(path) {
+    const normalized = path.toLowerCase();
+    if (normalized.includes("rightpaneldevtools")) {
+        return "row rendering should carry stable trace identity, not only visible virtual index";
+    }
+    if (normalized.includes("devtoolsnavstore")) {
+        return "repeated or delayed clicks need fresh request identity and deterministic delivery";
+    }
+    if (normalized.includes("chat-window")) {
+        return "cached-message lookup must find the requested message/tool before highlight state is committed";
+    }
+    if (normalized.includes("messagerenderer") || normalized.includes("toolcard")) {
+        return "message/tool anchors must exist or expand before scroll/highlight runs";
+    }
+    if (normalized.includes("devtools.py") || normalized.includes("trace_archive")) {
+        return "backend trace ids/indexes must be stable enough for frontend navigation";
+    }
+    return "treat this as an inferred debug boundary until a failing repro pins it down";
+}
+function debugPatchAndTestSurface(path) {
+    const normalized = path.toLowerCase();
+    if (pathLooksLikeTest(path)) {
+        return `extend ${path}`;
+    }
+    if (normalized.includes("rightpaneldevtools")) {
+        return "patch click payload/key derivation; test filtered row click-through";
+    }
+    if (normalized.includes("devtoolsnavstore")) {
+        return "patch request freshness/delivery; test repeated same-target clicks";
+    }
+    if (normalized.includes("chat-window")) {
+        return "patch cache lookup/fallback; test duplicate cached messages and unloaded targets";
+    }
+    if (normalized.includes("messagerenderer") || normalized.includes("toolcard")) {
+        return "patch anchor expansion/highlight ordering; test nested tool-card navigation";
+    }
+    if (normalized.includes("devtools.py") || normalized.includes("trace_archive")) {
+        return "patch trace response identity only if frontend evidence shows unstable ids";
+    }
+    return "add the narrow failing repro before editing";
+}
+function renderCompletenessGate(omissions) {
+    const material = omissions.filter(isMaterialOmission);
+    if (material.length === 0) {
+        return [];
+    }
+    const rendered = material
+        .slice(0, 3)
+        .map((omission) => `${humanOmissionReason(omission.reason)}${renderOmissionPathSuffix(omission.paths, 2)}`)
+        .join("; ");
+    return [
+        "### Completeness Gate",
+        `- Treat this packet as partial until these material gaps are checked: ${rendered}. Do not convert hypotheses into final fixes without resolving the affected boundary or test.`,
+    ];
+}
+function renderReviewFindingLine(input) {
+    const selectedPaths = selectedPathSet(input.selected);
+    const selectedEvidenceCount = input.evidence.filter((path) => selectedPaths.has(path)).length;
+    const confidence = input.title.includes("must remain fail-closed")
+        ? "Guardrail check"
+        : selectedEvidenceCount === input.evidence.length
+            ? "P1 finding"
+            : "Needs verification";
+    const evidence = input.evidence.map((path) => briefRef(input.selected, input.showRootLabels, path));
+    const tests = input.tests.map((path) => briefRef(input.selected, input.showRootLabels, path));
+    return `- ${confidence}: ${input.title}. Evidence: ${evidence.join(", ")}. Impact: ${input.impact}. Suggested fix: ${input.fix}. Regression target: ${tests.join(", ")}.`;
+}
+function renderDebugSelectedInvariants(selected, showRootLabels) {
+    const selectedPaths = selectedPathSet(selected);
+    const facts = [];
+    const add = (path, fact) => {
+        if (selectedPaths.has(path)) {
+            facts.push(`${briefRef(selected, showRootLabels, path)} ${fact}`);
+        }
+    };
+    add("frontend/src/components/right-panel/RightPanelDevtools.tsx", "already carries originalIndex through filtered rows and uses it for keys/clicks; do not blame filtered index without a failing assertion");
+    add("frontend/src/store/devtoolsNavStore.ts", "already models requestId-scoped highlight clearing; verify whether repeated same-target requests get fresh ids at the producer boundary");
+    add("frontend/src/components/chat/chat-window/Chat.tsx", "resolves navigation against cached messages before committing scroll/highlight state; verify cache ordering and target presence");
+    add("frontend/src/components/chat/message-bubble/MessageRenderer.tsx", "maps message/tool ids into anchors consumed by highlight and expansion paths");
+    add("frontend/src/components/chat/tools/common/ToolCard.tsx", "expands nested tool cards from requestId/anchorId signals and ignores duplicate request ids");
+    if (facts.length === 0) {
+        return "- Selected-code invariants: no primary devtools navigation files are selected; collect them before proposing a concrete fix.";
+    }
+    return `- Selected-code invariants: ${facts.join("; ")}.`;
+}
+function renderDebugPatchCandidates(selected, showRootLabels) {
+    const selectedPaths = selectedPathSet(selected);
+    const clauses = [];
+    const missing = [];
+    const add = (path, action) => {
+        if (selectedPaths.has(path)) {
+            clauses.push(`in ${briefRef(selected, showRootLabels, path)}, ${action}`);
+            return;
+        }
+        missing.push(path);
+    };
+    add("frontend/src/components/right-panel/RightPanelDevtools.tsx", "keep the click payload derived from the filtered row's original entry identity and use a durable key (entry id/originalIndex), never the visible virtual row index alone");
+    add("frontend/src/store/devtoolsNavStore.ts", "ensure every trace click produces a fresh request identity so repeated same-target clicks retrigger scroll/highlight effects");
+    add("frontend/src/components/chat/chat-window/Chat.tsx", "resolve the requested message/tool target from chronological cached messages before committing highlight state; if absent, fail visibly or fetch rather than falling back to a rendered index");
+    add("frontend/src/components/chat/message-bubble/MessageRenderer.tsx", "map the devtools target to the concrete message/tool anchor consumed by highlight state");
+    add("frontend/src/components/chat/tools/common/ToolCard.tsx", "expand the requested nested tool card before applying the highlight so the anchor exists");
+    if (clauses.length === 0) {
+        return [
+            "- Patch candidates: no primary debug implementation file is selected, so do not propose exact edits yet.",
+            `Select before patching: ${missing.slice(0, 5).join(", ")}.`,
+        ].join(" ");
+    }
+    const gap = missing.length === 0
+        ? ""
+        : ` Missing from this bundle: ${missing.slice(0, 5).join(", ")}; select before writing exact edits there.`;
+    return `- Patch candidates: ${clauses.join("; ")}.${gap}`;
+}
+function renderDebugContractChecks(selected, showRootLabels) {
+    const selectedPaths = selectedPathSet(selected);
+    const contractPaths = [
+        "backend/app/api/endpoints/devtools.py",
+        "backend/app/services/session_trace_archive.py",
+        "backend/app/models/schemas/devtools.py",
+    ].filter((path) => selectedPaths.has(path));
+    if (contractPaths.length === 0) {
+        return "- Backend contract check: no backend trace schema/archive file is selected; verify stable id/index fields before relying on frontend row-position semantics.";
+    }
+    return `- Backend contract check: ${contractPaths
+        .map((path) => briefRef(selected, showRootLabels, path))
+        .join(", ")} define the trace id/index fields the frontend can rely on.`;
+}
+function renderDebugRegressionPlan(selected, showRootLabels) {
+    const selectedPaths = selectedPathSet(selected);
+    const clauses = [];
+    const add = (path, action) => {
+        if (selectedPaths.has(path)) {
+            clauses.push(`${action} in ${briefRef(selected, showRootLabels, path)}`);
+        }
+    };
+    add("frontend/src/components/right-panel/__tests__/right-panel-devtools.test.tsx", "filter to a visible tool row, click it, and assert navigation uses the original/stable trace target");
+    add("frontend/src/store/__tests__/devtoolsNavStore.test.ts", "cover request freshness and stable target delivery through the store");
+    add("frontend/src/components/chat/chat-window/__tests__/Chat.devtools.test.tsx", "seed overlapping cached pages and assert the devtools target resolves after dedupe");
+    add("frontend/src/components/chat/tools/common/__tests__/toolExpand.test.tsx", "assert a devtools request expands and scrolls to a nested tool id");
+    if (clauses.length === 0) {
+        return "- Focused regression tests: add or inspect right-panel filtered click-through, devtools store request delivery, chat cache dedupe, and nested tool expansion tests; select the relevant test files before writing exact assertions.";
+    }
+    return `- Focused regression tests: ${clauses.join("; ")}.`;
+}
+function renderDebugValidationCommands(selected) {
+    const commands = selected
+        .map((file) => likelyValidationCommand(file.path))
+        .filter((command) => command != null);
+    const unique = [...new Set(commands)].slice(0, 6);
+    if (unique.length === 0) {
+        return "- Likely validation commands: select the relevant frontend/backend test files before running exact target-repo validation.";
+    }
+    return `- Likely validation commands: ${unique.map((command) => `\`${command}\``).join(", ")}.`;
+}
+function likelyValidationCommand(path) {
+    const normalized = path.toLowerCase();
+    if (normalized.startsWith("frontend/")) {
+        const frontendPath = path.replace(/^frontend\//, "");
+        if ((normalized.includes("__tests__") ||
+            normalized.includes(".test.") ||
+            normalized.includes(".spec.")) &&
+            (normalized.endsWith(".ts") || normalized.endsWith(".tsx"))) {
+            return `cd frontend && npx vitest run ${frontendPath}`;
+        }
+        return undefined;
+    }
+    if (normalized.startsWith("backend/")) {
+        const backendPath = path.replace(/^backend\//, "");
+        if ((normalized.includes("/tests/") || normalized.split("/").at(-1)?.startsWith("test_")) &&
+            normalized.endsWith(".py")) {
+            return `cd backend && pytest ${backendPath}`;
+        }
+        return undefined;
+    }
+    if (normalized.includes("__tests__") ||
+        normalized.includes(".test.") ||
+        normalized.includes(".spec.")) {
+        if (normalized.endsWith(".ts") || normalized.endsWith(".tsx")) {
+            return `npx vitest run ${path}`;
+        }
+        if (normalized.endsWith(".py")) {
+            return `pytest ${path}`;
+        }
+    }
+    if (normalized.includes("/tests/") || normalized.split("/").at(-1)?.startsWith("test_")) {
+        if (normalized.endsWith(".py")) {
+            return `pytest ${path}`;
+        }
+    }
+    return undefined;
+}
+function renderGeneratedAnswerSourceEvidence(input) {
+    const snippets = selectGeneratedAnswerEvidenceFiles(input.task, input.selected, input.slices)
+        .map((file) => ({
+        file,
+        snippet: sourceEvidenceSnippet(file, input.task, evidenceTermsForTask(input.task)),
+    }))
+        .filter((item) => item.snippet.length > 0);
+    if (snippets.length === 0) {
+        return "- No compact source evidence available from selected files.";
+    }
+    return snippets
+        .map(({ file, snippet }) => {
+        const fence = markdownFenceFor(snippet);
+        const why = sourceEvidenceReason(input.task, file);
+        return [
+            `- ${briefFileLabel(file, input.showRootLabels)} - ${why}`,
+            "",
+            fence,
+            snippet,
+            fence,
+        ].join("\n");
+    })
+        .join("\n\n");
+}
+function selectGeneratedAnswerEvidenceFiles(task, selected, slices) {
+    const normalizedTask = task.toLowerCase();
+    const preferredPaths = generatedAnswerPreferredEvidencePaths(normalizedTask);
+    const selectedByPath = new Map(selected.map((file) => [file.path, file]));
+    const sliceByPath = bestEvidenceSliceByPath(slices, evidenceTermsForTask(task));
+    const chosen = [];
+    const chosenKeys = new Set();
+    const addFile = (file) => {
+        if (file == null || chosenKeys.has(generatedAnswerEvidenceFileKey(file))) {
+            return;
+        }
+        if (!hasSnippetEligibleContent(file)) {
+            return;
+        }
+        chosen.push(file);
+        chosenKeys.add(generatedAnswerEvidenceFileKey(file));
+    };
+    for (const path of preferredPaths) {
+        const preferred = shouldPreferSliceEvidence(normalizedTask, path)
+            ? sliceByPath.get(path) ?? selectedByPath.get(path)
+            : selectedByPath.get(path) ?? sliceByPath.get(path);
+        addFile(preferred);
+        if (chosen.length >= SOURCE_EVIDENCE_MAX_FILES) {
+            return chosen;
+        }
+    }
+    for (const file of selected) {
+        if (taskMentionsPathToken(normalizedTask, file.path) ||
+            taskSpecificFileRole(task, file.path) != null) {
+            addFile(file);
+            if (chosen.length >= SOURCE_EVIDENCE_MAX_FILES) {
+                return chosen;
+            }
+        }
+    }
+    if (chosen.length > 0 && preferredPaths.length > 0) {
+        return chosen;
+    }
+    for (const file of selected) {
+        addFile(file);
+        if (chosen.length >= SOURCE_EVIDENCE_MAX_FILES) {
+            break;
+        }
+    }
+    return chosen;
+}
+function shouldPreferSliceEvidence(normalizedTask, path) {
+    const branch = classifyTaskBranch(normalizedTask);
+    if (branch === "runtime") {
+        return new Set([
+            "frontend/src/pages/LandingPage.tsx",
+            "frontend/src/hooks/useMessageActions.ts",
+            "frontend/src/components/chat/message-input/Input.tsx",
+            "frontend/src/services/chatService.ts",
+            "backend/app/api/endpoints/chat.py",
+            "backend/app/services/chat.py",
+            "backend/app/tasks/chat_processor.py",
+            "backend/app/services/streaming/orchestrator.py",
+            "backend/app/services/runtime/resolver.py",
+            "backend/app/services/model_provider_auth.py",
+            "backend/app/services/claude_agent.py",
+            "backend/app/services/runtime/claude.py",
+            "backend/app/services/runtime/codex.py",
+            "backend/app/api/endpoints/ai_models.py",
+            "backend/app/models/db_models/ai_model.py",
+            "frontend/src/components/chat/model-selector/ModelSelector.tsx",
+            "frontend/src/hooks/queries/useModelQueries.ts",
+            "frontend/src/utils/modelProvider.ts",
+            "frontend/src/components/chat/thinking-mode-selector/ThinkingModeSelector.tsx",
+            "frontend/src/components/chat/permission-mode-selector/PermissionModeSelector.tsx",
+            "backend/app/models/schemas/effort.py",
+            "backend/app/models/schemas/permission_mode.py",
+            "backend/app/services/queue.py",
+        ]).has(path);
+    }
+    if (branch === "review") {
+        return path === "frontend/src/components/chat/message-input/Input.tsx";
+    }
+    if (branch === "debug") {
+        return new Set([
+            "frontend/src/components/right-panel/RightPanelDevtools.tsx",
+            "frontend/src/components/chat/chat-window/Chat.tsx",
+            "frontend/src/components/chat/message-bubble/MessageRenderer.tsx",
+            "frontend/src/components/chat/tools/common/ToolCard.tsx",
+        ]).has(path);
+    }
+    return false;
+}
+function generatedAnswerPreferredEvidencePaths(normalizedTask) {
+    const branch = classifyTaskBranch(normalizedTask);
+    if (branch === "runtime") {
+        return [
+            "frontend/src/pages/LandingPage.tsx",
+            "frontend/src/hooks/useMessageActions.ts",
+            "frontend/src/components/chat/message-input/Input.tsx",
+            "frontend/src/services/chatService.ts",
+            "backend/app/api/endpoints/chat.py",
+            "backend/app/services/chat.py",
+            "backend/app/tasks/chat_processor.py",
+            "backend/app/services/streaming/orchestrator.py",
+            "backend/app/services/runtime/resolver.py",
+            "backend/app/services/model_provider_auth.py",
+            "backend/app/services/claude_agent.py",
+            "backend/app/services/runtime/claude.py",
+            "backend/app/services/runtime/codex.py",
+            "backend/app/api/endpoints/ai_models.py",
+            "backend/app/models/db_models/ai_model.py",
+            "frontend/src/components/chat/model-selector/ModelSelector.tsx",
+            "frontend/src/hooks/queries/useModelQueries.ts",
+            "frontend/src/utils/modelProvider.ts",
+            "frontend/src/components/chat/thinking-mode-selector/ThinkingModeSelector.tsx",
+            "frontend/src/components/chat/permission-mode-selector/PermissionModeSelector.tsx",
+            "frontend/src/hooks/useChatRuntimeSettings.ts",
+            "frontend/src/components/chat/message-input/ComposerRuntimeControls.tsx",
+            "frontend/src/services/queueService.ts",
+            "frontend/src/services/streamService.ts",
+            "frontend/src/store/messageQueueStore.ts",
+            "backend/app/services/queue.py",
+            "backend/app/models/schemas/effort.py",
+            "backend/app/models/schemas/permission_mode.py",
+            "backend/app/models/schemas/chat.py",
+            "backend/app/models/db_models/chat.py",
+            "backend/app/services/runtime/effort.py",
+            "backend/tests/services/test_pending_initial_prompt_service.py",
+        ];
+    }
+    if (branch === "review") {
+        return [
+            "backend/app/services/runtime/resolver.py",
+            "backend/app/services/runtime/codex.py",
+            "backend/app/services/runtime/codex_approval.py",
+            "frontend/src/components/chat/message-input/Input.tsx",
+            "frontend/src/components/ui/FileUploadDialog.tsx",
+            "frontend/src/components/ui/FileUploadDialog.codex.test.tsx",
+            "backend/app/services/runtime/codex_stream_processor.py",
+            "backend/app/services/model_provider_auth.py",
+            "backend/app/services/permission_manager.py",
+            "backend/app/services/runtime_session_service.py",
+            "backend/app/models/db_models/runtime_session.py",
+            "backend/app/models/db_models/ai_model.py",
+            "backend/app/api/endpoints/ai_models.py",
+            "backend/tests/test_ai_models_codex_gate.py",
+            "frontend/src/hooks/useMessageActions.ts",
+            "frontend/src/components/chat/permission-mode-selector/PermissionModeSelector.tsx",
+            "frontend/src/components/chat/thinking-mode-selector/ThinkingModeSelector.tsx",
+        ];
+    }
+    if (branch === "debug") {
+        return [
+            "frontend/src/components/right-panel/RightPanelDevtools.tsx",
+            "frontend/src/store/devtoolsNavStore.ts",
+            "frontend/src/hooks/queries/queryKeys.ts",
+            "frontend/src/hooks/queries/useDevtoolsQueries.ts",
+            "frontend/src/hooks/useMessageCache.ts",
+            "frontend/src/utils/messageCacheOrder.ts",
+            "frontend/src/components/chat/chat-window/Chat.tsx",
+            "frontend/src/components/chat/message-bubble/MessageRenderer.tsx",
+            "frontend/src/components/chat/tools/common/ToolCard.tsx",
+            "frontend/src/components/right-panel/__tests__/right-panel-devtools.test.tsx",
+        ];
+    }
+    return [];
+}
+function bestEvidenceSliceByPath(slices, terms) {
+    const best = new Map();
+    for (const slice of slices) {
+        if (slice.content.trim().length === 0) {
+            continue;
+        }
+        const file = selectedFileFromSlice(slice);
+        const score = evidenceSliceScore(slice, terms);
+        const existing = best.get(slice.path);
+        if (existing == null || score > existing.score) {
+            best.set(slice.path, { file, score });
+        }
+    }
+    return new Map([...best.entries()].map(([path, value]) => [path, value.file]));
+}
+function selectedFileFromSlice(slice) {
+    const bytes = Buffer.byteLength(slice.content, "utf8");
+    return {
+        root_index: slice.root_index,
+        path: slice.path,
+        ranges: [{ start_line: slice.start_line, end_line: slice.end_line }],
+        content: slice.content,
+        bytes,
+        estimated_tokens: estimateContextBuilderTokens(slice.content),
+        source: slice.source,
+    };
+}
+function evidenceSliceScore(slice, terms) {
+    const normalized = slice.content.toLowerCase();
+    const termScore = terms.reduce((total, term) => total + (normalized.includes(term.toLowerCase()) ? 10 : 0), 0);
+    const sourceScore = slice.source === "focus" ? 100 : 0;
+    return sourceScore + termScore + Math.min(50, slice.end_line - slice.start_line + 1);
+}
+function generatedAnswerEvidenceFileKey(file) {
+    return `${file.root_index}\u0000${file.path}`;
+}
+function compactSelectedSnippet(file, terms) {
+    const lines = selectedEvidenceLines(file);
+    if (lines.length === 0) {
+        return "";
+    }
+    return compactSelectedSnippetFromLines(file, lines, terms);
+}
+function sourceEvidenceSnippet(file, task, terms) {
+    const lines = selectedEvidenceLines(file);
+    if (lines.length === 0) {
+        return "";
+    }
+    const taskWindows = taskCriticalSourceEvidenceWindows(task, file, lines);
+    if (taskWindows.length > 0) {
+        return renderEvidenceLineWindows(taskWindows, lines);
+    }
+    if (shouldInlineExpandedEvidenceFile(task, file, lines)) {
+        return renderEvidenceLineWindows([
+            { startIndex: 0, endIndex: lines.length - 1 },
+        ], lines);
+    }
+    return compactSelectedSnippetFromLines(file, lines, terms);
+}
+function taskCriticalSourceEvidenceWindows(task, file, lines) {
+    const branch = classifyTaskBranch(task.toLowerCase());
+    const path = file.path;
+    const ranges = [];
+    if (branch === "runtime") {
+        if (path === "frontend/src/pages/LandingPage.tsx") {
+            ranges.push({ start_line: 150, end_line: 170 });
+        }
+        else if (path === "frontend/src/hooks/useMessageActions.ts") {
+            ranges.push({ start_line: 80, end_line: 122 });
+        }
+        else if (path === "frontend/src/components/chat/message-input/Input.tsx") {
+            ranges.push({ start_line: 480, end_line: 540 }, { start_line: 560, end_line: 610 }, { start_line: 629, end_line: 655 });
+        }
+        else if (path === "frontend/src/services/chatService.ts") {
+            ranges.push({ start_line: 45, end_line: 60 }, { start_line: 186, end_line: 232 });
+        }
+        else if (path === "backend/app/api/endpoints/chat.py") {
+            ranges.push({ start_line: 396, end_line: 460 }, { start_line: 529, end_line: 560 }, { start_line: 1299, end_line: 1383 });
+        }
+        else if (path === "backend/app/tasks/chat_processor.py") {
+            ranges.push({ start_line: 85, end_line: 140 });
+        }
+        else if (path === "backend/app/services/streaming/orchestrator.py") {
+            ranges.push({ start_line: 930, end_line: 960 }, { start_line: 979, end_line: 1120 });
+        }
+        else if (path === "backend/app/services/runtime/resolver.py") {
+            ranges.push({ start_line: 16, end_line: 45 });
+        }
+        else if (path === "backend/app/services/model_provider_auth.py") {
+            ranges.push({ start_line: 42, end_line: 95 });
+        }
+        else if (path === "backend/app/services/claude_agent.py") {
+            ranges.push({ start_line: 56, end_line: 75 }, { start_line: 829, end_line: 872 });
+        }
+        else if (path === "frontend/src/components/chat/thinking-mode-selector/ThinkingModeSelector.tsx") {
+            ranges.push({ start_line: 16, end_line: 83 });
+        }
+        else if (path === "frontend/src/components/chat/permission-mode-selector/PermissionModeSelector.tsx") {
+            ranges.push({ start_line: 1, end_line: 120 });
+        }
+        else if (path === "frontend/src/components/chat/model-selector/ModelSelector.tsx") {
+            ranges.push({ start_line: 1, end_line: 160 });
+        }
+        else if (path === "frontend/src/hooks/queries/useModelQueries.ts") {
+            ranges.push({ start_line: 1, end_line: 160 });
+        }
+        else if (path === "frontend/src/utils/modelProvider.ts") {
+            ranges.push({ start_line: 1, end_line: 160 });
+        }
+        else if (path === "backend/app/services/queue.py") {
+            ranges.push({ start_line: 1, end_line: 220 });
+        }
+        else if (path === "backend/app/models/schemas/effort.py" ||
+            path === "backend/app/models/schemas/permission_mode.py") {
+            ranges.push({ start_line: 1, end_line: 160 });
+        }
+        else if (path === "backend/app/services/runtime/claude.py") {
+            ranges.push({ start_line: 1, end_line: 92 });
+        }
+        else if (path === "backend/app/services/runtime/codex.py") {
+            ranges.push({ start_line: 111, end_line: 180 }, { start_line: 212, end_line: 264 });
+        }
+        else if (path === "backend/app/api/endpoints/ai_models.py") {
+            ranges.push({ start_line: 24, end_line: 38 });
+        }
+        else if (path === "backend/app/models/db_models/ai_model.py") {
+            ranges.push({ start_line: 22, end_line: 38 });
+        }
+    }
+    else if (branch === "review" &&
+        path === "frontend/src/components/chat/message-input/Input.tsx") {
+        ranges.push({ start_line: 430, end_line: 650 }, { start_line: 880, end_line: 1060 });
+    }
+    else if (branch === "debug" &&
+        path === "frontend/src/components/right-panel/RightPanelDevtools.tsx") {
+        ranges.push({ start_line: 560, end_line: 725 }, { start_line: 900, end_line: 930 });
+    }
+    else if (branch === "debug" &&
+        path === "frontend/src/components/chat/chat-window/Chat.tsx") {
+        ranges.push({ start_line: 450, end_line: 615 }, { start_line: 670, end_line: 750 });
+    }
+    if (ranges.length === 0) {
+        return [];
+    }
+    return evidenceWindowsForLineRanges(lines, ranges);
+}
+function evidenceWindowsForLineRanges(lines, ranges) {
+    const windows = [];
+    for (const range of ranges) {
+        const indexes = lines
+            .map((line, index) => ({ line, index }))
+            .filter(({ line }) => line.lineNumber >= range.start_line && line.lineNumber <= range.end_line)
+            .map(({ index }) => index);
+        if (indexes.length === 0) {
+            continue;
+        }
+        windows.push({
+            startIndex: Math.min(...indexes),
+            endIndex: Math.max(...indexes),
+        });
+    }
+    return windows;
+}
+function compactSelectedSnippetFromLines(file, lines, terms) {
+    if (shouldInlineSmallEvidenceFile(file, lines)) {
+        return renderEvidenceLineWindows([
+            { startIndex: 0, endIndex: lines.length - 1 },
+        ], lines);
+    }
+    const candidates = [];
+    for (const [index, line] of lines.entries()) {
+        if (line.text.trim().length === 0) {
+            continue;
+        }
+        const score = evidenceLineScore(line.text, terms, file.path);
+        if (terms.length > 0 && score <= 0) {
+            continue;
+        }
+        candidates.push({ index, score });
+    }
+    if (candidates.length > 0) {
+        const anchors = candidates
+            .sort((left, right) => right.score - left.score ||
+            lines[left.index].lineNumber - lines[right.index].lineNumber ||
+            left.index - right.index)
+            .slice(0, SOURCE_EVIDENCE_MAX_WINDOWS)
+            .map((candidate) => candidate.index);
+        return renderEvidenceLineWindows(mergedEvidenceWindows(lines, anchors), lines);
+    }
+    return renderEvidenceLineWindows([{ startIndex: 0, endIndex: Math.min(lines.length - 1, SOURCE_EVIDENCE_FALLBACK_LINES - 1) }], lines);
+}
+function shouldInlineExpandedEvidenceFile(task, file, lines) {
+    if (classifyTaskBranch(task.toLowerCase()) === "generic") {
+        return false;
+    }
+    if (lines.length > SOURCE_EVIDENCE_EXPANDED_FILE_MAX_LINES) {
+        return false;
+    }
+    if (file.bytes > SOURCE_EVIDENCE_EXPANDED_FILE_MAX_BYTES) {
+        return false;
+    }
+    const preferredPaths = new Set(generatedAnswerPreferredEvidencePaths(task.toLowerCase()));
+    return preferredPaths.has(file.path) || taskSpecificFileRole(task, file.path) != null;
+}
+const SOURCE_EVIDENCE_WINDOW_RADIUS = 4;
+const SOURCE_EVIDENCE_MAX_FILES = 10;
+const SOURCE_EVIDENCE_MAX_WINDOWS = 6;
+const SOURCE_EVIDENCE_SMALL_FILE_MAX_BYTES = 2_000;
+const SOURCE_EVIDENCE_SMALL_FILE_MAX_LINES = 20;
+const SOURCE_EVIDENCE_FALLBACK_LINES = 32;
+const SOURCE_EVIDENCE_EXPANDED_FILE_MAX_BYTES = 60_000;
+const SOURCE_EVIDENCE_EXPANDED_FILE_MAX_LINES = 650;
+function selectedEvidenceLines(file) {
+    const linesByRange = splitSelectedFileContentByRange(file);
+    const lines = [];
+    for (const [rangeIndex, rangeLines] of linesByRange.entries()) {
+        const range = file.ranges[rangeIndex];
+        if (range == null) {
+            continue;
+        }
+        for (const [lineOffset, rawLine] of rangeLines.entries()) {
+            lines.push({
+                lineNumber: range.start_line + lineOffset,
+                rangeIndex,
+                text: rawLine.trimEnd(),
+            });
+        }
+    }
+    return trimBlankEvidenceEdges(lines);
+}
+function trimBlankEvidenceEdges(lines) {
+    let start = 0;
+    let end = lines.length;
+    while (start < end && lines[start].text.trim().length === 0) {
+        start += 1;
+    }
+    while (end > start && lines[end - 1].text.trim().length === 0) {
+        end -= 1;
+    }
+    return lines.slice(start, end);
+}
+function shouldInlineSmallEvidenceFile(file, lines) {
+    return (file.bytes <= SOURCE_EVIDENCE_SMALL_FILE_MAX_BYTES &&
+        lines.length <= SOURCE_EVIDENCE_SMALL_FILE_MAX_LINES);
+}
+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) {
+    const normalizedTask = task.toLowerCase();
+    const branch = classifyTaskBranch(normalizedTask);
+    if (branch === "runtime") {
+        return [
+            "runtime_permission_mode",
+            "runtime_effort_level",
+            "permission_mode",
+            "effort_level",
+            "permissionMode",
+            "effortLevel",
+            "ComposerRuntimeControls",
+            "SDK_PERMISSION_MODE_MAP",
+            "_build_claude_options",
+            "ModelSelector",
+            "useModelQueries",
+            "modelProvider",
+            "PermissionModeSelector",
+            "ThinkingModeSelector",
+            "pending_initial_prompt",
+            "createChat",
+            "sendMessage",
+            "messageQueue",
+            "normalize_permission_mode",
+            "normalize_effort_level",
+        ];
+    }
+    if (branch === "review") {
+        return [
+            "codex",
+            "approval",
+            "permission",
+            "session_id",
+            "RuntimeSession",
+            "runtime_session",
+            "CodexRuntime",
+            "process_event",
+            "FileUploadDialog",
+            "SDK_PERMISSION_MODE_MAP",
+            "_build_claude_options",
+            "ModelSelector",
+            "useModelQueries",
+            "modelProvider",
+            "supports",
+            "file",
+        ];
+    }
+    if (branch === "debug") {
+        return [
+            "filteredEntries",
+            "originalIndex",
+            "entry_id",
+            "getItemKey",
+            "handleEntryClick",
+            "pendingScroll",
+            "toolUseId",
+            "queryKeys",
+            "useDevtoolsQueries",
+            "useMessageCache",
+            "messageCacheOrder",
+            "virtualizer",
+        ];
+    }
+    return task
+        .toLowerCase()
+        .split(/[^a-z0-9_]+/)
+        .filter((term) => term.length >= 4)
+        .slice(0, 8);
+}
+function hasSnippetEligibleContent(file) {
+    const trimmed = file.content.trim();
+    return (trimmed.length > 0 &&
+        trimmed !== "[redacted-sensitive-content]" &&
+        !hasHighConfidenceSecret(trimmed));
+}
+function taskMentionsPathToken(task, path) {
+    const basename = path.toLowerCase().split("/").at(-1) ?? path.toLowerCase();
+    const stem = basename.replace(/\.[^.]+$/, "");
+    return stem.length >= 4 && task.includes(stem);
+}
+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;
+    }
+    if (/\b(runtime_|permission|effort|approval|session|entry_id|originalIndex|getItemKey|handleEntryClick|filteredEntries|toolUseId)\b/i.test(line)) {
+        score += 4;
+    }
+    score += pathAwareEvidenceBoost(path, line);
+    return score;
+}
+function pathAwareEvidenceBoost(path, line) {
+    if (path == null) {
+        return 0;
+    }
+    const normalizedPath = path.toLowerCase();
+    const normalizedLine = line.toLowerCase();
+    let score = 0;
+    if (normalizedPath.endsWith("/components/chat/message-input/input.tsx")) {
+        if (normalizedLine.includes("await queuemessage("))
+            score += 80;
+        if (normalizedLine.includes("handlesubmit"))
+            score += 55;
+        if (normalizedLine.includes("permissionmode") && !normalizedLine.includes("import"))
+            score += 35;
+        if (normalizedLine.includes("effortlevel") && !normalizedLine.includes("import"))
+            score += 35;
+        if (normalizedLine.includes("onmessagesend("))
+            score += 30;
+    }
+    if (normalizedPath.endsWith("/pages/chatpage.tsx")) {
+        if (normalizedLine.includes("usechatstreaming"))
+            score += 65;
+        if (normalizedLine.includes("onmessagesend") || normalizedLine.includes("handlemessagesend")) {
+            score += 45;
+        }
+        if (normalizedLine.includes("pendinginitialprompt"))
+            score += 40;
+    }
+    if (normalizedPath.endsWith("/services/streaming/orchestrator.py")) {
+        if (normalizedLine.includes("ai_service.get_ai_stream"))
+            score += 90;
+        if (normalizedLine.includes("permission_mode=permission_mode"))
+            score += 70;
+        if (normalizedLine.includes("effort_level=effort_level"))
+            score += 70;
+        if (normalizedLine.includes("resolve_runtime_for_model"))
+            score += 55;
+        if (normalizedLine.includes("run_chat_stream"))
+            score += 40;
+    }
+    if (normalizedPath.endsWith("/tests/services/test_pending_initial_prompt_service.py")) {
+        if (normalizedLine.includes("assert request.permission_mode"))
+            score += 80;
+        if (normalizedLine.includes("assert request.effort_level"))
+            score += 80;
+        if (normalizedLine.includes("dispatch_kwargs"))
+            score += 65;
+        if (normalizedLine.includes("runtime_permission_mode="))
+            score += 55;
+        if (normalizedLine.includes("runtime_effort_level="))
+            score += 55;
+    }
+    return score;
+}
+function trimEvidenceLine(line) {
+    const maxLength = 180;
+    if (line.length <= maxLength) {
+        return line;
+    }
+    return `${line.slice(0, maxLength - 3)}...`;
+}
+function briefRef(selected, showRootLabels, path) {
+    const file = selected.find((item) => item.path === path);
+    if (file == null) {
+        return path;
+    }
+    return briefFileLabel(file, showRootLabels);
+}
+function briefFileLabel(file, showRootLabels) {
+    return `${renderRootPrefix(file.root_index, showRootLabels)}${file.path}:${briefRangeLabel(file.ranges)}`;
+}
+function briefRangeLabel(ranges) {
+    if (ranges.length === 0) {
+        return "full";
+    }
+    return ranges
+        .slice(0, 3)
+        .map((range) => range.start_line === range.end_line
+        ? `${range.start_line}`
+        : `${range.start_line}-${range.end_line}`)
+        .join(",");
+}
+function selectedCoverage(selected, expectedPaths) {
+    const present = expectedPaths.filter((path) => selected.has(path)).slice(0, 5);
+    if (present.length > 0) {
+        return present.join(", ");
+    }
+    return "no expected path selected; use selected areas and omissions below to find the gap";
+}
+function renderRelationshipsAndRisks(input) {
+    const normalizedTask = input.task.toLowerCase();
+    const branch = classifyTaskBranch(normalizedTask);
+    const selected = selectedPathSet(input.selected);
+    const lines = [];
+    if (branch === "runtime") {
+        lines.push("- Architecture: ComposerRuntimeControls/useChatRuntimeSettings define the user intent, Input/useMessageActions/chatService serialize it, queueService/messageQueueStore preserve it offline, chat.py/ChatService persist it, and chat_processor/orchestrator/runtime adapters execute it.");
+        lines.push(relationshipLine("Frontend settings and send path", selected, input.showRootLabels, [
+            "frontend/src/components/chat/message-input/ComposerRuntimeControls.tsx",
+            "frontend/src/hooks/useChatRuntimeSettings.ts",
+            "frontend/src/components/chat/message-input/Input.tsx",
+            "frontend/src/hooks/useMessageActions.ts",
+            "frontend/src/hooks/useChatStreaming.ts",
+            "frontend/src/services/chatService.ts",
+            "frontend/src/services/queueService.ts",
+            "frontend/src/store/messageQueueStore.ts",
+        ]));
+        lines.push(relationshipLine("Backend validation, persistence, and runtime dispatch", selected, input.showRootLabels, [
+            "backend/app/api/endpoints/chat.py",
+            "backend/app/services/chat.py",
+            "backend/app/services/queue.py",
+            "backend/app/tasks/chat_processor.py",
+            "backend/app/services/streaming/orchestrator.py",
+            "backend/app/services/runtime/codex.py",
+        ]));
+        lines.push(relationshipLine("Contracts and provider semantics", selected, input.showRootLabels, [
+            "backend/app/models/schemas/chat.py",
+            "backend/app/models/db_models/chat.py",
+            "backend/app/models/schemas/effort.py",
+            "backend/app/models/schemas/permission_mode.py",
+            "backend/app/services/runtime/base.py",
+            "backend/app/services/runtime/claude.py",
+        ]));
+        lines.push("- Risks: create-chat can persist defaults while send/queue carries updated settings; queued work can replay stale effort names; Codex and Claude permission modes diverge; pending initial prompts can redispatch without the stored snapshot.");
+    }
+    else if (branch === "review") {
+        lines.push("- Architecture: resolver selects Codex, CodexRuntime streams SDK events, codex_approval bridges approval callbacks into PermissionManager records, permissions endpoints resolve them, and frontend hooks surface the decision. Treat RuntimeSessionService as a review target, not as proven-live wiring: selected source may show Codex v1 no-resume/deferred runtime_sessions integration.");
+        lines.push(relationshipLine("Runtime/session core", selected, input.showRootLabels, [
+            "backend/app/services/runtime/codex.py",
+            "backend/app/services/runtime/resolver.py",
+            "backend/app/services/runtime_session_service.py",
+            "backend/app/services/runtime/codex_stream_processor.py",
+            "backend/app/services/streaming/orchestrator.py",
+        ]));
+        lines.push(relationshipLine("Approval and permission contracts", selected, input.showRootLabels, [
+            "backend/app/services/runtime/codex_approval.py",
+            "backend/app/services/permission_manager.py",
+            "backend/app/api/endpoints/permissions.py",
+            "backend/app/models/schemas/permissions.py",
+            "backend/app/core/config.py",
+            "backend/app/constants.py",
+            "frontend/src/hooks/usePermissionRequest.ts",
+        ]));
+        lines.push(relationshipLine("Frontend provider/upload consumers and tests", selected, input.showRootLabels, [
+            "frontend/src/utils/modelProvider.ts",
+            "frontend/src/components/ui/FileUploadDialog.tsx",
+            "frontend/src/hooks/useMessageActions.ts",
+            "frontend/src/hooks/__tests__/useMessageActions.codex.test.tsx",
+            "backend/tests/services/runtime/test_codex_approval_bridge.py",
+            "backend/tests/test_permissions.py",
+        ]));
+        lines.push("- Risks: Codex capability metadata must remain fail-closed, approval timeouts can leave reader tasks waiting, Redis TTLs can disagree with SDK wait windows, denied/cross-chat responses can mutate the wrong request, and unit tests may miss live SDK payload drift.");
+    }
+    else if (branch === "debug") {
+        lines.push("- Architecture: devtools.py/session_trace_archive produce trace entries, RightPanelDevtools filters and virtualizes them, devtoolsNavStore carries the selected entry target, Chat resolves cached messages, and MessageRenderer/ToolCard expose scroll and expansion anchors.");
+        lines.push(relationshipLine("Trace fetch and archive shape", selected, input.showRootLabels, [
+            "backend/app/api/endpoints/devtools.py",
+            "backend/app/services/session_trace_archive.py",
+            "backend/app/models/db_models/session_trace_archive.py",
+            "backend/app/services/codex_trace.py",
+            "frontend/src/types/devtools.types.ts",
+        ]));
+        lines.push(relationshipLine("Right-panel row identity and navigation", selected, input.showRootLabels, [
+            "frontend/src/components/right-panel/RightPanelDevtools.tsx",
+            "frontend/src/components/right-panel/devtools-helpers.ts",
+            "frontend/src/components/right-panel/RightPanel.tsx",
+            "frontend/src/store/devtoolsNavStore.ts",
+            "frontend/src/components/right-panel/__tests__/right-panel-devtools.test.tsx",
+            "frontend/src/components/right-panel/__tests__/devtools-helpers.test.ts",
+        ]));
+        lines.push(relationshipLine("Chat cache, message lookup, and tool expansion", selected, input.showRootLabels, [
+            "frontend/src/components/chat/chat-window/Chat.tsx",
+            "frontend/src/hooks/queries/queryKeys.ts",
+            "frontend/src/utils/messageCacheOrder.ts",
+            "frontend/src/types/chat.types.ts",
+            "frontend/src/components/chat/message-bubble/MessageRenderer.tsx",
+            "frontend/src/components/chat/tools/common/ToolExpandContext.ts",
+            "frontend/src/components/chat/tools/common/ToolCard.tsx",
+        ]));
+        lines.push("- Risks: filtered row position can be confused with original trace index, virtualizer keys can recycle stale rows, cached-message deduping can hide the target message, and tool expansion can resolve the message while missing the nested tool anchor.");
+    }
+    else {
+        lines.push("- Architecture: selected files are grouped by source area; inspect focus files first, then contract/type/test closure.");
+        lines.push("- Risks: any material omissions listed below may require follow-up discovery before editing.");
+    }
+    const omissionRisk = omissionRiskLine(branch, selected, input.omissions);
+    if (omissionRisk != null) {
+        lines.push(omissionRisk);
+    }
+    const material = input.omissions.filter(isMaterialOmission).slice(0, 3);
+    if (material.length > 0) {
+        lines.push(`- Known gaps: ${material
+            .map((omission) => {
+            const paths = omission.paths?.slice(0, 2).join(", ");
+            const reason = humanOmissionReason(omission.reason);
+            return paths == null || paths.length === 0 ? reason : `${reason} (${paths})`;
+        })
+            .join("; ")}.`);
+    }
+    return lines.filter((line) => line.trim().length > 0).join("\n");
+}
+function omissionRiskLine(branch, selected, omissions) {
+    const omitted = new Set(omissions.flatMap((omission) => omission.paths ?? []));
+    const missing = (paths) => paths.filter((path) => !selected.has(path) || omitted.has(path));
+    if (branch === "runtime") {
+        return formatOmissionRiskEntries([
+            ["normal/queued send parity", missing([
+                    "frontend/src/components/chat/message-input/Input.tsx",
+                    "frontend/src/hooks/useChatStreaming.ts",
+                    "frontend/src/hooks/useMessageActions.ts",
+                    "frontend/src/services/queueService.ts",
+                ])],
+            ["pending redispatch and worker persistence", missing([
+                    "backend/app/services/chat.py",
+                    "backend/app/tasks/chat_processor.py",
+                    "backend/tests/services/test_pending_initial_prompt_service.py",
+                ])],
+            ["runtime adapter translation", missing([
+                    "backend/app/services/runtime/codex.py",
+                    "backend/app/services/runtime/claude.py",
+                    "backend/tests/services/runtime/test_codex_runtime.py",
+                ])],
+        ]);
+    }
+    if (branch === "review") {
+        return formatOmissionRiskEntries([
+            ["security/approval TTLs", missing([
+                    "backend/app/services/runtime/codex_approval.py",
+                    "backend/app/api/endpoints/permissions.py",
+                    "backend/tests/services/runtime/test_codex_approval_bridge.py",
+                ])],
+            ["runtime-session contamination", missing([
+                    "backend/app/services/runtime/codex.py",
+                    "backend/app/services/streaming/orchestrator.py",
+                    "backend/app/services/runtime_session_service.py",
+                    "backend/tests/services/runtime/test_codex_runtime_invariants.py",
+                ])],
+            ["frontend attachment gating", missing([
+                    "frontend/src/components/chat/message-input/Input.tsx",
+                    "frontend/src/components/ui/FileUploadDialog.tsx",
+                    "frontend/src/components/ui/FileUploadDialog.codex.test.tsx",
+                ])],
+        ]);
+    }
+    if (branch === "debug") {
+        return formatOmissionRiskEntries([
+            ["row identity and virtualizer tests", missing([
+                    "frontend/src/components/right-panel/RightPanelDevtools.tsx",
+                    "frontend/src/components/right-panel/__tests__/right-panel-devtools.test.tsx",
+                ])],
+            ["chat cache lookup", missing([
+                    "frontend/src/components/chat/chat-window/Chat.tsx",
+                    "frontend/src/hooks/queries/queryKeys.ts",
+                    "frontend/src/utils/messageCacheOrder.ts",
+                ])],
+            ["message/tool anchor expansion", missing([
+                    "frontend/src/components/chat/message-bubble/MessageRenderer.tsx",
+                    "frontend/src/components/chat/tools/common/ToolCard.tsx",
+                    "frontend/src/components/chat/tools/common/__tests__/toolExpand.test.tsx",
+                ])],
+        ]);
+    }
+    return undefined;
+}
+function formatOmissionRiskEntries(entries) {
+    const risks = entries.filter((entry) => entry[1].length > 0);
+    if (risks.length === 0) {
+        return undefined;
+    }
+    return `- Omission risk: ${risks
+        .slice(0, 3)
+        .map(([label, paths]) => `${label} needs ${paths.slice(0, 2).join(", ")}`)
+        .join("; ")}.`;
+}
+function mentionsAny(input, needles) {
+    return needles.some((needle) => input.includes(needle));
+}
+function renderConfirmedReviewSourceAreas(selected, showRootLabels) {
+    const expected = [
+        "backend/app/services/runtime/resolver.py",
+        "backend/app/services/runtime/codex_approval.py",
+        "backend/app/models/schemas/permissions.py",
+        "backend/tests/services/runtime/test_codex_approval_bridge.py",
+    ];
+    const selectedPaths = selectedPathSet(selected);
+    const present = expected
+        .filter((path) => selectedPaths.has(path))
+        .map((path) => briefRef(selected, showRootLabels, path));
+    const missing = expected.filter((path) => !selectedPaths.has(path));
+    if (present.length === 0) {
+        return `- Confirmed source areas: none of the preferred review guardrails are selected. Verify before quoting: ${missing.join(", ")}.`;
+    }
+    const suffix = missing.length === 0
+        ? ""
+        : ` Additional verification targets: ${missing.join(", ")}.`;
+    return `- Confirmed source areas: selected ranges around ${present.join(", ")} are the guardrails to quote as facts.${suffix}`;
+}
+const REVIEW_TASK_KEYWORDS = [
+    "code review",
+    "review",
+    "codex approval",
+];
+const DEBUG_TASK_KEYWORDS = [
+    "devtools",
+    "trace row",
+    "row-to-message",
+    "click-through",
+    "highlight",
+];
+const RUNTIME_TASK_KEYWORDS = [
+    "runtime settings",
+    "runtime_permission_mode",
+    "runtime_effort_level",
+    "queue dispatch",
+];
+function classifyTaskBranch(normalizedTask) {
+    if (mentionsAny(normalizedTask, DEBUG_TASK_KEYWORDS)) {
+        return "debug";
+    }
+    if (mentionsAny(normalizedTask, REVIEW_TASK_KEYWORDS)) {
+        return "review";
+    }
+    if (mentionsAny(normalizedTask, RUNTIME_TASK_KEYWORDS)) {
+        return "runtime";
+    }
+    return "generic";
+}
+function selectedPathSet(selected) {
+    return new Set(selected.map((file) => file.path));
+}
+function relationshipLine(label, selected, showRootLabels, paths) {
+    const present = paths.filter((path) => selected.has(path));
+    const missing = paths.filter((path) => !selected.has(path));
+    const chain = present.length === 0
+        ? "unavailable; no expected anchors selected"
+        : present
+            .slice(0, 8)
+            .map((path) => `${renderRootPrefix(0, showRootLabels)}${path}`)
+            .join(" -> ");
+    return `- ${label} chain: ${chain}.`;
+}
+function taskActionCue(task) {
+    const verbs = [
+        "add",
+        "audit",
+        "build",
+        "debug",
+        "diagnose",
+        "explain",
+        "fix",
+        "harden",
+        "implement",
+        "inspect",
+        "investigate",
+        "plan",
+        "refactor",
+        "remove",
+        "review",
+        "summarize",
+        "test",
+        "update",
+        "verify",
+    ];
+    const words = new Set(task.toLowerCase().match(/[a-z][a-z0-9_-]*/g) ?? []);
+    return verbs.find((verb) => words.has(verb));
+}
+function relationshipCuesFromSelected(selected) {
+    if (selected.length === 0) {
+        return "no selected files";
+    }
+    const sourceCounts = new Map();
+    for (const file of selected) {
+        sourceCounts.set(file.source, (sourceCounts.get(file.source) ?? 0) + 1);
+    }
+    const sources = [...sourceCounts.entries()]
+        .sort(([left], [right]) => left.localeCompare(right))
+        .map(([source, count]) => `${source}:${count}`)
+        .join(", ");
+    const areas = renderSelectedPathGroups(selected).slice(0, 3).join("; ");
+    return `${sources}${areas.length === 0 ? "" : ` across ${areas}`}`;
+}
+function riskCuesFromContext(input) {
+    if (input.materialOmissions.length > 0) {
+        return input.materialOmissions
+            .slice(0, 3)
+            .map((omission) => humanOmissionReason(omission.reason))
+            .join(", ");
+    }
+    const closure = closureFiles(input.selected, input.showRootLabels).slice(0, 3);
+    if (closure.length > 0) {
+        return `contract files selected (${closure.join(", ")})`;
+    }
+    if (input.selectedSearch.length === 0) {
+        return "no selected-file search hits";
+    }
+    return "none recorded";
+}
+function renderSelectedPathGroups(selected) {
+    const counts = new Map();
+    for (const file of selected) {
+        const group = pathGroup(file.path);
+        counts.set(group, (counts.get(group) ?? 0) + 1);
+    }
+    return [...counts.entries()]
+        .sort((left, right) => right[1] - left[1] || left[0].localeCompare(right[0]))
+        .slice(0, 5)
+        .map(([group, count]) => `${group} (${count})`);
+}
+function pathGroup(path) {
+    const parts = path.split("/");
+    if (path.startsWith("backend/app/") && parts.length >= 4) {
+        return parts.slice(0, 4).join("/");
+    }
+    if (path.startsWith("frontend/src/") && parts.length >= 4) {
+        return parts.slice(0, 4).join("/");
+    }
+    return parts.slice(0, Math.min(parts.length, 2)).join("/");
+}
+function closureFiles(selected, showRootLabels) {
+    return selected
+        .filter((file) => isClosurePath(file.path))
+        .slice(0, 8)
+        .map((file) => `${renderRootPrefix(file.root_index, showRootLabels)}${file.path}`);
+}
+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" ||
+        basename === "permission_mode.py" ||
+        basename === "effort.py");
+}
+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 slices.jsonl.`]
+        : [];
+    const selectedHitPreviews = renderSelectedHitPreviews({
+        selected,
+        search,
+        showRootLabels,
+    });
+    const selectedRangeLandmarks = selected.length > 12
+        ? []
+        : renderSelectedRangeLandmarks({
+            selected,
+            showRootLabels,
+        });
+    return [
+        "- Full selected source is also stored in `slices.jsonl`; the task-critical evidence is inlined above for bundle-first review.",
+        `- Selected source payload: ${selected.length} files, ${totalRanges} ranges, ${totalBytes} bytes before artifact serialization.`,
+        "- Range index:",
+        ...previewFiles,
+        ...hidden,
+        ...(selectedRangeLandmarks.length === 0
+            ? []
+            : ["", "- Range landmarks:", ...selectedRangeLandmarks]),
+        ...(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) {
+        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) {
+    if (symbolsFromLine(line).length > 0) {
+        return true;
+    }
+    return /\b(?:boundary|needle|requestId|originalIndex|write_active_asset)\b/.test(line);
+}
+function renderSelectedHitPreviews(input) {
+    const selectedPaths = new Set(input.selected.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) {
+    const branch = classifyTaskBranch(task.toLowerCase());
+    return omissions
+        .map((omission) => {
+        if (omission.paths == null) {
+            return omission;
+        }
+        const paths = omission.paths.filter((path) => !isTangentialPresentationOmissionPath(path, branch));
+        return { ...omission, paths };
+    })
+        .filter((omission) => {
+        if ((omission.paths?.length ?? 0) > 0) {
+            return true;
+        }
+        return !isMaterialOmission(omission);
+    });
+}
+function filterTaskPresentationSelected(selected, task) {
+    const branch = classifyTaskBranch(task.toLowerCase());
+    return selected.filter((file) => !isTangentialPresentationSelectedPath(file.path, branch));
+}
+function promoteTaskPresentationEvidence(selected, task, slices) {
+    const branch = classifyTaskBranch(task.toLowerCase());
+    const required = branch === "review"
+        ? [
+            "frontend/src/components/chat/message-input/Input.tsx",
+            "frontend/src/components/ui/FileUploadDialog.codex.test.tsx",
+        ]
+        : [];
+    if (required.length === 0) {
+        return [...selected];
+    }
+    const selectedPaths = selectedPathSet(selected);
+    const evidenceByPath = bestEvidenceSliceByPath(slices, evidenceTermsForTask(task));
+    const promoted = [];
+    for (const path of required) {
+        if (selectedPaths.has(path)) {
+            continue;
+        }
+        const evidence = evidenceByPath.get(path);
+        if (evidence != null && hasSnippetEligibleContent(evidence)) {
+            promoted.push(evidence);
+        }
+    }
+    if (promoted.length === 0) {
+        return [...selected];
+    }
+    return [...selected, ...promoted];
+}
+function isTangentialPresentationSelectedPath(path, branch) {
+    const normalized = path.toLowerCase();
+    if (branch === "runtime") {
+        return normalized.endsWith("/components/chat/chat-window/chat.tsx");
+    }
+    if (branch === "review") {
+        return (normalized.endsWith("/services/sandbox/provider.py") ||
+            normalized.includes("providerauth") ||
+            normalized.includes("provider_auth"));
+    }
+    return false;
+}
+function isTangentialPresentationOmissionPath(path, branch) {
+    const normalized = path.toLowerCase();
+    if (branch === "runtime") {
+        return (normalized.includes("/components/settings/") ||
+            normalized.endsWith("/api/endpoints/settings.py") ||
+            normalized.endsWith("/models/schemas/settings.py") ||
+            normalized.includes("/services/nightshift/") ||
+            normalized.includes("/tests/services/nightshift/"));
+    }
+    if (branch === "review") {
+        return (normalized.includes("/services/checks/") ||
+            normalized.endsWith("/api/endpoints/checks.py") ||
+            normalized.endsWith("/models/schemas/checks.py") ||
+            normalized.includes("/tests/checks/") ||
+            normalized.includes("/components/right-panel/checks/"));
+    }
+    return false;
+}
+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) {
+    const normalized = question.toLowerCase();
+    const paths = selectedPathSet(selected);
+    if (mentionsAny(normalized, [
+        "filtered trace",
+        "filtered index",
+        "filtered indices",
+        "original index",
+        "original trace indices",
+        "entry id",
+        "virtualizer key",
+        "click target",
+    ]) &&
+        paths.has("frontend/src/components/right-panel/RightPanelDevtools.tsx") &&
+        paths.has("frontend/src/store/devtoolsNavStore.ts") &&
+        paths.has("frontend/src/components/chat/chat-window/Chat.tsx")) {
+        return true;
+    }
+    if (mentionsAny(normalized, [
+        "cached message lookup",
+        "cached messages",
+        "older paginated messages",
+        "wrong rendered index",
+        "virtualized scrolling",
+        "disambiguate by chatid",
+        "messages not currently loaded",
+        "infinite-query cache",
+    ]) &&
+        paths.has("frontend/src/components/chat/chat-window/Chat.tsx") &&
+        (paths.has("frontend/src/utils/messageCacheOrder.ts") ||
+            paths.has("frontend/src/hooks/queries/queryKeys.ts"))) {
+        return true;
+    }
+    if (mentionsAny(normalized, ["tool-result", "tool result", "tool-use", "tool use"]) &&
+        paths.has("frontend/src/components/chat/message-bubble/MessageRenderer.tsx") &&
+        paths.has("frontend/src/components/chat/tools/common/ToolCard.tsx")) {
+        return true;
+    }
+    if (mentionsAny(normalized, ["highlight", "scroll effects", "repeated clicks"]) &&
+        paths.has("frontend/src/store/devtoolsNavStore.ts") &&
+        paths.has("frontend/src/components/chat/chat-window/Chat.tsx")) {
+        return true;
+    }
+    if (mentionsAny(normalized, [
+        "queued messages",
+        "frontend field names",
+        "runtime_permission_mode",
+        "runtime_effort_level",
+    ]) &&
+        paths.has("frontend/src/services/chatService.ts") &&
+        paths.has("backend/app/services/chat.py")) {
+        return true;
+    }
+    if (mentionsAny(normalized, [
+        "effort settings",
+        "effort_level",
+        "codex/openai",
+        "claude/openrouter",
+        "non-codex providers",
+    ]) &&
+        paths.has("backend/app/services/runtime/codex.py") &&
+        paths.has("backend/app/services/runtime/claude.py")) {
+        return true;
+    }
+    if (mentionsAny(normalized, [
+        "codex trace",
+        "archived claude",
+        "message_id/tool_use_id",
+        "failed clicks",
+        "assistant messages",
+        "tool_use",
+        "tool_result",
+        "virtualizer keys",
+        "visible indices",
+        "original trace entry ids",
+    ]) &&
+        paths.has("frontend/src/components/right-panel/RightPanelDevtools.tsx") &&
+        paths.has("backend/app/api/endpoints/devtools.py") &&
+        paths.has("backend/app/services/session_trace_archive.py")) {
+        return true;
+    }
+    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.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(sanitizeDiagnosticText),
+            }),
+        ...(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) {
+    assertNoHighConfidenceSecretsInTask(task);
+    return task;
+}
+function safePath(path) {
+    return boundContextBuilderPathList([path], 1)[0] ?? "[redacted-sensitive-path]";
+}
+function safeContent(content) {
+    return hasHighConfidenceSecret(content) ? "[redacted-sensitive-content]" : content;
+}
+function sanitizeJsonValue(value) {
+    if (typeof value === "string") {
+        const pathSafe = safePath(value);
+        return pathSafe === "[redacted-sensitive-path]"
+            ? pathSafe
+            : sanitizeDiagnosticText(value);
+    }
+    if (typeof value === "number" || typeof value === "boolean" || value == null) {
+        return value;
+    }
+    if (Array.isArray(value)) {
+        return value.slice(0, 200).map(sanitizeJsonValue);
+    }
+    if (typeof value === "object") {
+        return Object.fromEntries(Object.entries(value)
+            .slice(0, 200)
+            .map(([key, entryValue]) => [
+            sanitizeDiagnosticText(key),
+            sanitizeJsonValue(entryValue),
+        ]));
+    }
+    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