scai 0.1.178 → 1.0.0

package/dist/pipeline/modules/finalAnswerModule.js

@@ -1,10 +1,67 @@
-// File: src/pipeline/modules/finalAnswerModule.ts
+/**
+ * Phase Boundary: Final Answer Module
+ *
+ * This module is responsible for producing the final grounded answer to the user's query.
+ * It focuses on synthesizing evidence from analyzed files, execution artifacts, and research
+ * to generate a concise, well-grounded response.
+ *
+ * Key responsibilities:
+ * - Collects and structures evidence from file analyses, execution outcomes, and research
+ * - Builds a compact answer packet for grounding the final AI response
+ * - Generates the final answer using a structured prompt that includes all relevant context
+ * - Ensures the final answer is focused, grounded, and prioritizes intent and rationale
+ *
+ * Boundary conditions:
+ * - Keeps final answer synthesis focused on grounded file and research evidence
+ * - Does not depend on removed legacy continuity-answer shortcuts
+ * - Focuses only on grounded answers derived from analyzed files and execution artifacts
+ *
+ * Final grounding rule:
+ * - Constructs one compact answer packet from the strongest available evidence
+ * - Prefers research synthesis for repo-wide answers over dumping planning/code sections
+ * - Only includes exact identifiers or short excerpts when they materially help keep the answer grounded
+ */
 import { logInputOutput } from "../../utils/promptLogHelper.js";
 import { generate } from "../../lib/generate.js";
 import { cleanupModule } from "./cleanupModule.js";
 import chalk from "chalk";
+import path from "path";
+import { isExecutionGroundedStep } from "../../utils/executionEvidence.js";
+import { getVerifyFocusFilePreference, isVerifyFocusQueryText } from "../../utils/verifyFocusPreference.js";
+import { buildResumePacket, renderResumePacket } from "../../utils/resumeState.js";
 const MAX_CODE_CHARS = 3000;
 const MAX_FILES = 4;
+const MIN_EXACT_VERIFY_CONFIDENCE = 0.85;
+const MAX_EXCERPTS_PER_FILE = 1;
+const MAX_RATIONALE_LINES = 3;
+const MAX_PROMPT_EXCERPT_CHARS = 600;
+const GENERIC_VERIFY_IDENTIFIERS = new Set([
+    "module",
+    "repo",
+    "pattern",
+    "src",
+    "cli",
+    "points",
+    "explain",
+    "summarize",
+    "weak",
+]);
+function extractMentionedFilePaths(text) {
+    if (!text.trim())
+        return [];
+    const matches = text.match(/(?:\/[^\s`'"]+\.(?:ts|js|tsx|jsx|py|java|go|rs|cpp|c|cs|md|json)|\b[\w./-]+\.(?:ts|js|tsx|jsx|py|java|go|rs|cpp|c|cs|md|json)\b)/g) ?? [];
+    return Array.from(new Set(matches.map(item => item.trim())));
+}
+/**
+ * Builds the persisted final answer text from the rendered response and analyzed files.
+ *
+ * Why this exists:
+ * - the module needs one stable place to shape the final output header
+ * - explanation queries often need the module-level concept name to stay visible
+ */
+function buildFinalAnswer(renderedResponse, analyzedFiles) {
+    return `Analyzed files:\n${analyzedFiles.join("\n")}\n\n${renderedResponse}`;
+}
 export const finalAnswerModule = {
     name: "finalAnswer",
     description: "Produces the final grounded answer, prioritizing intent, targets, and rationale over file listings.",
@@ -16,11 +73,33 @@ export const finalAnswerModule = {
             throw new Error("[finalAnswerModule] No context provided");
         }
         const analysis = context.analysis ?? {};
+        const directoryListingAnswer = analysis.directoryListingAnswer;
+        if (directoryListingAnswer) {
+            const finalText = directoryListingAnswer.summary;
+            analysis.finalAnswer = finalText;
+            logInputOutput("finalAnswerModule", "output", {
+                directoryListing: true,
+                folderPath: directoryListingAnswer.folderPath ?? null,
+                entryCount: directoryListingAnswer.entries.length,
+            });
+            console.log(chalk.yellow(`\n\n[FINAL ANSWER]\n${finalText}\n`));
+            return {
+                query,
+                content: finalText,
+                data: {
+                    response: finalText,
+                    analyzedFiles: [],
+                },
+                context,
+            };
+        }
         const fileAnalysis = analysis.fileAnalysis ?? {};
-        const combinedAnalysis = await ensureCombinedAnalysis(context, query);
         const focus = analysis.focus;
         const rationale = focus?.rationale ?? "No explicit rationale provided.";
-        const transformedFiles = context.execution?.codeTransformArtifacts?.files ?? [];
+        const resumedContextCapsule = renderResumePacket(buildResumePacket(context.analysis?.resumeState)) ||
+            context.initContext?.resumedContextCapsule?.trim();
+        const combinedAnalysis = await ensureCombinedAnalysis(context, query);
+        const answerMode = resolveAnswerMode(context, query);
         // --------------------------------------------------
         // 1️⃣ Collect semantic files and excerpts
         // --------------------------------------------------
@@ -29,120 +108,58 @@ export const finalAnswerModule = {
             (!focus?.relevantFiles || focus.relevantFiles.includes(path)))
             .map(([path, fa]) => ({ path, analysis: fa }))
             .slice(0, MAX_FILES);
+        const verifyMeaningfulFiles = resolveVerifyMeaningfulFiles(context, meaningfulFiles.map(file => file.path));
+        const answerFiles = resolveMeaningfulAnswerFiles(context, meaningfulFiles, verifyMeaningfulFiles);
         // Collect analyzed files for output (prefer executed task steps from this run).
-        const analyzedFiles = resolveAnalyzedFilesForOutput(context, meaningfulFiles.map(f => f.path));
-        // --------------------------------------------------
-        // 2️⃣ Collect supporting code snippets from working files
-        // --------------------------------------------------
-        const workingFiles = context.workingFiles ?? [];
-        const codeSnippets = meaningfulFiles
-            .map(({ path }) => {
-            const wf = workingFiles.find(f => f.path === path);
-            if (!wf?.code)
-                return null;
-            return {
-                path,
-                code: sliceCode(wf.code),
-            };
-        })
-            .filter(Boolean);
-        // --------------------------------------------------
-        // 3️⃣ Build structured evidence sections
-        // --------------------------------------------------
-        const semanticSection = meaningfulFiles.length > 0
-            ? meaningfulFiles.map(({ path, analysis }) => {
-                const excerptsSection = analysis.excerpts?.map(ex => `
-Excerpt:
-Description: ${ex.description}
-${ex.startLine !== undefined ? `StartLine: ${ex.startLine}` : ""}
-${ex.endLine !== undefined ? `EndLine: ${ex.endLine}` : ""}
-Symbols: ${ex.symbols?.join(", ") ?? "[none]"}
-Code:
-${sliceCode(ex.code)}
-`.trim()).join("\n\n") ?? "[No excerpts available]";
-                return `
-${formatProposedChanges(path, analysis)}
-
-Supporting Excerpts:
-${excerptsSection}
-`.trim();
-            }).join("\n\n")
-            : "[No meaningful semantic changes identified]";
-        const combinedSection = combinedAnalysis
-            ? `
-Shared patterns:
-${combinedAnalysis.sharedPatterns?.map(p => `- ${p}`).join("\n") || "[none]"}
-
-Architecture summary:
-${combinedAnalysis.architectureSummary ?? "[none]"}
-
-Hotspots:
-${combinedAnalysis.hotspots?.map(h => `- ${h}`).join("\n") || "[none]"}
-`.trim()
-            : "[No combined analysis available]";
-        const codeSection = transformedFiles.length > 0
-            ? transformedFiles.map(f => `
-FILE: ${f.filePath}
-----------------------------------------
-${sliceCode(f.content)}
-`).join("\n\n")
-            : codeSnippets.length > 0
-                ? codeSnippets.map(f => `
-FILE: ${f.path}
-----------------------------------------
-${f.code}
-`).join("\n\n")
-                : "[No source code required for explanation]";
-        // --------------------------------------------------
-        // 4️⃣ Prompt
-        // --------------------------------------------------
-        const prompt = `
-You are an AI assistant providing the final answer to the user.
-
-This is the final stage of a structured analysis pipeline.
-
-User query:
-${query}
-
-Rationale for focus:
-${rationale}
-
-Analyzed files:
-${analyzedFiles.join("\n")}
-
-==================== PROPOSED CHANGES ====================
-
-${semanticSection}
-
-==================== COMBINED ANALYSIS ====================
-
-${combinedSection}
-
-==================== SOURCE CODE (LIMITED) ====================
-
-${codeSection}
-
-==================== INSTRUCTIONS ====================
-
-- Answer the user's question directly.
-- Prioritize intent, targets, and rationale over file listings.
-- Refer to files only when they materially support the explanation.
-- If no changes or conclusions can be drawn, say so explicitly.
-- Do NOT speculate.
-- Do NOT suggest further changes.
-- Be concise, grounded, and outcome-focused.
-`.trim();
+        const preliminaryAnalyzedFiles = resolveAnalyzedFilesForOutput(context, answerFiles.map(f => f.path));
+        const answerEvidence = collectAnswerEvidence({
+            context,
+            rationale,
+            mode: answerMode,
+            answerFiles,
+            analyzedFiles: preliminaryAnalyzedFiles,
+            combinedAnalysis,
+            resumedContextCapsule,
+        });
+        const analyzedFiles = resolveAnalyzedFilesForOutput(context, answerEvidence.answerFiles);
+        const answerPacket = buildAnswerPacket({
+            mode: answerMode,
+            rationale,
+            orderedQuestions: context.analysis?.intent?.questions ?? [],
+            evidence: answerEvidence,
+        });
+        const prompt = renderFinalAnswerPrompt(query, answerPacket);
         // --------------------------------------------------
         // 5️⃣ Generate final answer
         // --------------------------------------------------
-        const aiResponse = await generate({ query, content: prompt });
-        // ✅ Prepend analyzed files to finalText so user sees them
-        const finalText = typeof aiResponse.data === "string"
-            ? `Analyzed files:\n${analyzedFiles.join("\n")}\n\n${aiResponse.data}`
-            : `Analyzed files:\n${analyzedFiles.join("\n")}\n\n${JSON.stringify(aiResponse.data, null, 2)}`;
+        const aiResponse = await generate({ query, content: prompt }, {
+            caller: "finalAnswerModule",
+            inputContext: {
+                query,
+                mode: answerPacket.mode,
+                rationale: answerPacket.rationale,
+                analyzedFiles,
+                executedAnswerFiles: answerPacket.executedAnswerFiles,
+                candidateAnswerFiles: answerPacket.candidateAnswerFiles,
+                answerEvidenceLevel: answerPacket.answerEvidenceLevel,
+                answerFiles: answerPacket.answerFiles,
+                answerSummaryByFile: answerPacket.answerSummaryByFile,
+                crossFileSummary: answerPacket.crossFileSummary ?? "",
+                researchSummary: answerPacket.researchSummary ?? "",
+                exactIdentifiers: answerPacket.exactIdentifiers,
+                supportingExcerpts: answerPacket.supportingExcerpts,
+                resumedContextCapsule: answerPacket.resumedContextCapsule ?? "",
+            },
+        });
+        const renderedResponse = renderAnswerResponse({
+            rawResponse: aiResponse.data,
+            packet: answerPacket,
+        });
+        const finalText = buildFinalAnswer(renderedResponse, analyzedFiles);
         context.analysis || (context.analysis = {});
         context.analysis.finalAnswer = finalText;
         logInputOutput("finalAnswerModule", "output", {
+            callId: aiResponse.trace?.callId,
             data: aiResponse.data,
             analyzedFiles,
         });
@@ -151,7 +168,7 @@ ${codeSection}
             query,
             content: finalText,
             data: {
-                response: aiResponse.data,
+                response: renderedResponse,
                 analyzedFiles,
             },
             context,
@@ -161,21 +178,13 @@ ${codeSection}
 /* -------------------------
    Helpers
 ---------------------------- */
-function formatProposedChanges(path, analysis) {
-    const proposed = analysis.proposedChanges;
-    return `
-FILE: ${path}
-
-Summary:
-${proposed?.summary ?? "[no summary]"}
-
-Targets:
-${proposed?.targets?.map(t => `- ${t}`).join("\n") || "[none]"}
-
-Rationale:
-${proposed?.rationale ?? "[no rationale]"}
-`.trim();
-}
+/**
+ * Trims large code blocks without losing both the setup and the ending.
+ *
+ * Examples:
+ * - short file under the limit -> return unchanged
+ * - long file -> keep the first 60%, insert the truncation marker line, then keep the last 40%
+ */
 function sliceCode(code) {
     if (code.length <= MAX_CODE_CHARS)
         return code;
@@ -183,6 +192,14 @@ function sliceCode(code) {
         "\n/* … truncated … */\n" +
         code.slice(-Math.floor(MAX_CODE_CHARS * 0.4)));
 }
+/**
+ * Reuses cached cross-file analysis when available and only computes it when at least two
+ * semantically analyzed files exist.
+ *
+ * Examples:
+ * - 0 or 1 semantically analyzed files -> return `undefined` because there is nothing to compare
+ * - 3 analyzed files -> run combined analysis once, then cache it on `context.analysis.combinedAnalysis`
+ */
 async function ensureCombinedAnalysis(context, query) {
     context.analysis || (context.analysis = {});
     if (context.analysis.combinedAnalysis) {
@@ -202,6 +219,13 @@ async function ensureCombinedAnalysis(context, query) {
     context.analysis.combinedAnalysis = combined;
     return combined;
 }
+/**
+ * Builds the cross-file prompt and parses the model result into a stable shape.
+ *
+ * Examples:
+ * - shared auth logic across two files -> `sharedPatterns` may include `"both files validate session state first"`
+ * - parse failure or malformed JSON -> fall back to empty arrays and `"[unparsed]"`
+ */
 async function analyzeCombined(fileAnalysis, query) {
     const prompt = `
 You are given semantic analysis for multiple files that are all relevant
@@ -226,7 +250,13 @@ Return STRICT JSON:
 }
 `.trim();
     try {
-        const ai = await generate({ query: "cross-file analysis", content: prompt });
+        const ai = await generate({ query: "cross-file analysis", content: prompt }, {
+            caller: "finalAnswerModule.analyzeCombined",
+            inputContext: {
+                query,
+                fileAnalysis,
+            },
+        });
         const cleaned = await cleanupModule.run({ query, content: ai.data });
         const data = typeof cleaned.data === "object" && cleaned.data
             ? cleaned.data
@@ -246,36 +276,1031 @@ Return STRICT JSON:
         };
     }
 }
+/**
+ * Resolves the grounding mode so prompt inputs match the answer shape.
+ *
+ * Examples:
+ * - explicit target explanation -> `single-file`
+ * - repo-wide architecture question with synthesis research -> `repo-wide`
+ * - "what should we do next?" on a resumed task -> `continuity`
+ */
+function resolveAnswerMode(context, query) {
+    const normalized = query.trim().toLowerCase();
+    const isContinuityQuery = normalized === "where were we?" ||
+        normalized === "what should we do next?" ||
+        context.analysis?.resumeIntent?.kind === "continuity-summary" ||
+        context.analysis?.resumeIntent?.kind === "continuity-next-step";
+    if (isContinuityQuery) {
+        return "continuity";
+    }
+    const hasArchitectureSynthesis = Boolean(context.analysis?.researchArtifacts?.latestByAction?.["research-architecture-synthesis"]);
+    if (context.analysis?.scopeType === "repo-wide" || hasArchitectureSynthesis) {
+        return "repo-wide";
+    }
+    const selectedCount = context.analysis?.focus?.selectedFiles?.length ?? 0;
+    return selectedCount <= 1 ? "single-file" : "multi-file";
+}
+/**
+ * Builds the compact answer packet used to ground the final answer model call.
+ *
+ * Examples:
+ * - repo-wide answer -> prefer research synthesis plus a few representative files
+ * - single-file explanation -> keep one file summary, exact identifiers, and one short excerpt
+ */
+function buildAnswerPacket(args) {
+    return {
+        mode: args.mode,
+        rationale: reduceAnswerRationale(args.rationale),
+        orderedQuestions: args.orderedQuestions,
+        answerFiles: args.evidence.answerFiles,
+        executedAnswerFiles: args.evidence.executedAnswerFiles,
+        candidateAnswerFiles: args.evidence.candidateAnswerFiles,
+        answerEvidenceLevel: args.evidence.answerEvidenceLevel,
+        answerSummaryByFile: args.evidence.answerSummaryByFile,
+        crossFileSummary: args.evidence.crossFileSummary,
+        researchSummary: args.evidence.researchSummary,
+        exactIdentifiers: args.evidence.exactIdentifiers,
+        supportingExcerpts: args.evidence.supportingExcerpts,
+        resumedContextCapsule: args.evidence.resumedContextCapsule,
+    };
+}
+function parseStructuredQuestionAnswers(value) {
+    const raw = typeof value === "string" ? value : JSON.stringify(value ?? "");
+    try {
+        const parsed = JSON.parse(raw);
+        if (!Array.isArray(parsed.answers)) {
+            return undefined;
+        }
+        const normalized = parsed.answers
+            .filter((item) => !!item && typeof item.questionId === "string" && typeof item.answer === "string")
+            .map((item) => ({
+            questionId: item.questionId,
+            answer: item.answer.trim(),
+            evidenceStatus: item.evidenceStatus,
+        }))
+            .filter((item) => item.answer.length > 0);
+        return normalized.length > 0 ? normalized : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function renderStructuredQuestionAnswers(questions, answers) {
+    return questions
+        .sort((left, right) => left.order - right.order)
+        .map((question, index) => {
+        const matched = answers.find((answer) => answer.questionId === question.id);
+        const body = matched?.answer?.trim() || "Not enough grounded evidence to answer this question separately yet.";
+        return `${index + 1}. ${question.text}\n${body}`;
+    })
+        .join("\n\n");
+}
+function renderAnswerResponse(args) {
+    if (args.packet.orderedQuestions.length <= 1) {
+        return typeof args.rawResponse === "string"
+            ? args.rawResponse
+            : JSON.stringify(args.rawResponse, null, 2);
+    }
+    const structuredAnswers = parseStructuredQuestionAnswers(args.rawResponse);
+    if (structuredAnswers) {
+        return renderStructuredQuestionAnswers(args.packet.orderedQuestions, structuredAnswers);
+    }
+    const rawText = typeof args.rawResponse === "string"
+        ? args.rawResponse.trim()
+        : JSON.stringify(args.rawResponse, null, 2);
+    return rawText || renderStructuredQuestionAnswers(args.packet.orderedQuestions, []);
+}
+/**
+ * Collects the grounded evidence that will be packed into the final answer prompt.
+ *
+ * This keeps file choice, grounded notes, and continuity reduction separate from packet assembly.
+ */
+function collectAnswerEvidence(args) {
+    const { context, rationale, mode, answerFiles, analyzedFiles, combinedAnalysis, resumedContextCapsule } = args;
+    const architectureInputFiles = resolveArchitectureInputFiles(context);
+    const preferredFiles = normalizeAnswerFilePaths([
+        ...extractMentionedFilePaths(rationale),
+        ...(context.analysis?.focus?.selectedFiles ?? []),
+        ...(context.analysis?.focus?.candidateFiles ?? []),
+    ]);
+    const preferredGroundedFiles = resolvePreferredGroundedFiles(context, preferredFiles);
+    const researchSummary = buildResearchSummary(context, mode);
+    const packetFiles = resolveAnswerPacketFiles({
+        mode,
+        answerFiles,
+        analyzedFiles,
+        researchSummary,
+        preferredFiles,
+        preferredGroundedFiles,
+        architectureInputFiles,
+    });
+    const executedAnswerFiles = resolveExecutedAnswerFiles(context, packetFiles);
+    const candidateAnswerFiles = packetFiles.filter(filePath => !executedAnswerFiles.includes(filePath));
+    const answerSummaryByFile = packetFiles.map(filePath => ({
+        filePath,
+        summary: buildAnswerSummaryForFile(context, filePath, mode, args.context.initContext?.userQuery ?? ""),
+    }));
+    const exactIdentifiers = packetFiles
+        .map(filePath => ({
+        filePath,
+        identifiers: collectAnswerExactIdentifiers(context, filePath, args.context.initContext?.userQuery ?? ""),
+    }))
+        .filter(entry => entry.identifiers.length > 0);
+    const supportingExcerpts = collectSupportingExcerpts(context, packetFiles, mode, args.context.initContext?.userQuery ?? "");
+    return {
+        answerFiles: packetFiles,
+        executedAnswerFiles,
+        candidateAnswerFiles,
+        answerEvidenceLevel: resolveAnswerEvidenceLevel(context, executedAnswerFiles, candidateAnswerFiles),
+        answerSummaryByFile,
+        crossFileSummary: buildCrossFileSummary(mode, combinedAnalysis),
+        researchSummary,
+        exactIdentifiers,
+        supportingExcerpts,
+        resumedContextCapsule: mode === "continuity"
+            ? reduceResumedContextCapsule(resumedContextCapsule)
+            : undefined,
+    };
+}
+function collectSupportingExcerpts(context, packetFiles, mode, query) {
+    if (mode === "repo-wide" || mode === "continuity") {
+        return [];
+    }
+    return packetFiles
+        .map(filePath => ({
+        filePath,
+        excerpts: buildSupportingExcerpts(context, filePath, query),
+    }))
+        .filter(entry => entry.excerpts.length > 0);
+}
+/**
+ * Chooses the smallest stable file list that still supports the answer.
+ *
+ * Examples:
+ * - repo-wide synthesis with architecture inputs -> use those first
+ * - single-file explanation -> keep only the first grounded file
+ */
+function resolveAnswerPacketFiles(args) {
+    const { mode, answerFiles, analyzedFiles, researchSummary, preferredFiles, preferredGroundedFiles, architectureInputFiles } = args;
+    const base = normalizeAnswerFilePaths(answerFiles.map(file => file.path));
+    const normalizedAnalyzed = normalizeAnswerFilePaths(analyzedFiles);
+    const groundedSupport = normalizeAnswerFilePaths([
+        ...preferredGroundedFiles,
+        ...architectureInputFiles,
+    ]);
+    const fallbackFiles = base.length > 0
+        ? base
+        : normalizedAnalyzed.length > 0
+            ? normalizedAnalyzed
+            : groundedSupport.length > 0
+                ? groundedSupport
+                : preferredFiles;
+    const preferredInScope = preferredFiles.filter(filePath => base.includes(filePath) || normalizedAnalyzed.includes(filePath) || groundedSupport.includes(filePath));
+    if (mode === "single-file") {
+        const primary = preferredInScope[0] ?? groundedSupport[0] ?? fallbackFiles[0];
+        return primary ? [primary] : [];
+    }
+    if (mode === "continuity") {
+        return (preferredInScope.length > 0 ? preferredInScope : groundedSupport.length > 0 ? groundedSupport : fallbackFiles).slice(0, 2);
+    }
+    if (mode === "repo-wide" && researchSummary) {
+        const merged = Array.from(new Set([...preferredInScope, ...groundedSupport, ...fallbackFiles]));
+        return merged.slice(0, MAX_FILES);
+    }
+    const merged = Array.from(new Set([
+        ...preferredInScope,
+        ...groundedSupport,
+        ...fallbackFiles,
+    ]));
+    return merged.slice(0, MAX_FILES);
+}
+/**
+ * Distills one file into a short answer note instead of dumping planning prose.
+ *
+ * Examples:
+ * - semantic summary exists -> keep that concise summary
+ * - exact identifiers exist -> surface them as the key grounded fact
+ */
+function buildAnswerSummaryForFile(context, filePath, mode, query) {
+    const readResult = context.analysis?.readResults?.byFile?.[filePath];
+    const analysis = context.analysis?.fileAnalysis?.[filePath];
+    const verify = context.analysis?.verify?.byFile?.[filePath];
+    const exact = collectAnswerExactIdentifiers(context, filePath, query);
+    const fileLabel = buildQueryAlignedFileLabel(filePath, query);
+    if (exact.length > 0) {
+        return fileLabel
+            ? `${fileLabel}. Key identifiers: ${exact.join(", ")}.`
+            : `Key identifiers: ${exact.join(", ")}.`;
+    }
+    const readFacts = readResult?.facts?.filter(fact => fact.found).map(fact => fact.key) ?? [];
+    if (readFacts.length > 0) {
+        return `Quick-read facts: ${readFacts.slice(0, 3).join(", ")}.`;
+    }
+    const summary = analysis?.proposedChanges?.summary?.trim();
+    if (summary) {
+        return summarizeSentence(summary);
+    }
+    const verifyRationale = verify?.rationale?.trim();
+    if (verifyRationale && !/generic token|insufficient verify evidence/i.test(verifyRationale)) {
+        return summarizeSentence(verifyRationale);
+    }
+    if (mode === "repo-wide") {
+        return "Representative source used for repo-wide architecture grounding.";
+    }
+    return "Grounded source selected for the final answer.";
+}
+/**
+ * Prefers cross-file synthesis only when the answer truly needs it.
+ *
+ * Examples:
+ * - single-file answer -> omit cross-file summary
+ * - repo-wide answer without synthesis -> fall back to combined analysis only if it exists
+ */
+function buildCrossFileSummary(mode, combinedAnalysis) {
+    if (mode === "single-file" || mode === "continuity" || !combinedAnalysis) {
+        return undefined;
+    }
+    const parts = [
+        combinedAnalysis.architectureSummary?.trim(),
+        combinedAnalysis.sharedPatterns?.length
+            ? `Shared patterns: ${combinedAnalysis.sharedPatterns.join("; ")}`
+            : "",
+        combinedAnalysis.hotspots?.length
+            ? `Hotspots: ${combinedAnalysis.hotspots.join("; ")}`
+            : "",
+    ].filter(Boolean);
+    return parts.length > 0 ? parts.join("\n") : undefined;
+}
+/**
+ * Pulls repo-wide synthesis from stored research artifacts when available.
+ *
+ * Examples:
+ * - completed architecture synthesis -> use its summary, prior research, and coupling points
+ * - no stored synthesis -> return `undefined`
+ */
+function buildResearchSummary(context, mode) {
+    if (mode !== "repo-wide")
+        return undefined;
+    const entry = context.analysis?.researchArtifacts?.latestByAction?.["research-architecture-synthesis"];
+    if (!entry)
+        return undefined;
+    const data = entry.collectedData ?? {};
+    const priorResearch = Array.isArray(data.priorResearchSummaries)
+        ? data.priorResearchSummaries
+            .map(item => `${String(item.action ?? "research")}: ${String(item.summary ?? "[none]")}`)
+        : [];
+    const sharedPatterns = Array.isArray(data.sharedPatterns)
+        ? data.sharedPatterns.map(item => String(item))
+        : [];
+    const hotspots = Array.isArray(data.hotspots)
+        ? data.hotspots.map(item => String(item))
+        : [];
+    const couplingPoints = Array.isArray(data.couplingPoints)
+        ? data.couplingPoints.map(item => String(item))
+        : [];
+    const architectureInputFiles = Array.isArray(data.architectureInputFiles)
+        ? data.architectureInputFiles.map(item => String(item))
+        : [];
+    const sections = [
+        `Synthesis summary: ${entry.summary}`,
+        typeof data.problemStatement === "string" && data.problemStatement.trim().length > 0
+            ? `Problem statement: ${data.problemStatement}`
+            : "",
+        priorResearch.length > 0 ? `Prior research: ${priorResearch.join(" | ")}` : "",
+        sharedPatterns.length > 0 ? `Shared patterns: ${sharedPatterns.join("; ")}` : "",
+        hotspots.length > 0 ? `Hotspots: ${hotspots.join("; ")}` : "",
+        couplingPoints.length > 0 ? `Coupling points: ${couplingPoints.join("; ")}` : "",
+        architectureInputFiles.length > 0 ? `Architecture input files: ${architectureInputFiles.join(", ")}` : "",
+    ].filter(Boolean);
+    return sections.join("\n");
+}
+function resolveArchitectureInputFiles(context) {
+    const synthesis = context.analysis?.researchArtifacts?.latestByAction?.["research-architecture-synthesis"];
+    const inputFiles = Array.isArray(synthesis?.collectedData?.architectureInputFiles)
+        ? (synthesis?.collectedData?.architectureInputFiles).map(item => String(item))
+        : [];
+    return normalizeAnswerFilePaths(inputFiles);
+}
+function resolvePreferredGroundedFiles(context, preferredFiles) {
+    const groundedCandidates = normalizeAnswerFilePaths([
+        ...(context.workingFiles ?? []).map(file => file.path),
+        ...Object.keys(context.analysis?.verify?.byFile ?? {}),
+        ...Object.keys(context.analysis?.fileAnalysis ?? {}),
+        ...resolveArchitectureInputFiles(context),
+    ]);
+    return preferredFiles.filter(filePath => groundedCandidates.includes(filePath));
+}
+/**
+ * Keeps continuity capsules short enough for final grounding.
+ *
+ * Examples:
+ * - long resume capsule -> retain task, status, selected files, and next hints only
+ * - empty capsule -> return `undefined`
+ */
+function reduceResumedContextCapsule(value) {
+    if (!value?.trim())
+        return undefined;
+    const lines = value.split("\n").map(line => line.trim()).filter(Boolean);
+    const keepPrefixes = [
+        "Original task:",
+        "Current task status:",
+        "Current intent state:",
+        "- Normalized intent:",
+        "Current routing/focus state:",
+        "- Selected files:",
+        "Next plan hints:",
+        "New user query:",
+    ];
+    const reduced = lines.filter(line => keepPrefixes.some(prefix => line.startsWith(prefix)));
+    const sanitized = (reduced.length > 0 ? reduced : lines.slice(0, 6))
+        .filter(line => line !== "Original task:" && line !== "Next plan hints:");
+    return sanitized.join("\n");
+}
+/**
+ * Uses semantic excerpts first and falls back to a short source slice only when needed.
+ *
+ * Examples:
+ * - semantic excerpt available -> keep one short excerpt
+ * - no semantic excerpt but code exists -> use one bounded code slice
+ */
+function buildSupportingExcerpts(context, filePath, query) {
+    const analysis = context.analysis?.fileAnalysis?.[filePath];
+    const exactIdentifiers = collectAnswerExactIdentifiers(context, filePath, query);
+    const excerpts = (analysis?.excerpts ?? [])
+        .map(excerpt => excerpt.code?.trim())
+        .filter((excerpt) => Boolean(excerpt))
+        .slice(0, MAX_EXCERPTS_PER_FILE)
+        .map(excerpt => compactSupportingExcerpt(excerpt, exactIdentifiers));
+    if (excerpts.length > 0) {
+        return excerpts;
+    }
+    const code = context.workingFiles?.find(file => file.path === filePath)?.code;
+    if (!code?.trim())
+        return [];
+    return [compactSupportingExcerpt(code, exactIdentifiers)];
+}
+/**
+ * Keeps rationale short so final grounding sees the decision, not the full planner history.
+ *
+ * Examples:
+ * - verbose pre/post-check rationale -> keep the first few specific lines only
+ * - empty rationale -> return a stable fallback
+ */
+function reduceAnswerRationale(value) {
+    const lines = value
+        .split("\n")
+        .map(line => line.trim())
+        .filter(Boolean)
+        .filter(line => !/^\[selectRelevantSources\]/i.test(line));
+    if (lines.length === 0) {
+        return "No explicit rationale provided.";
+    }
+    const ranked = lines.filter(line => /^Pre-check:/i.test(line) ||
+        /^\[Post-check\]/i.test(line) ||
+        /selected|candidate|relevant|aligned|confidence/i.test(line));
+    const compact = (ranked.length > 0 ? ranked : lines)
+        .slice(0, MAX_RATIONALE_LINES)
+        .map(line => summarizeSentence(line));
+    return compact.join("\n");
+}
+/**
+ * Keeps one answer summary sentence compact enough for prompt grounding.
+ * Example: a long semantic summary paragraph -> keep the first sentence under the cap.
+ */
+function summarizeSentence(value) {
+    const normalized = value.replace(/\s+/g, " ").trim();
+    if (!normalized) {
+        return "Grounded source selected for the final answer.";
+    }
+    const firstSentence = normalized.match(/^.*?[.!?](?:\s|$)/)?.[0]?.trim() ?? normalized;
+    const bounded = firstSentence.length <= 180 ? firstSentence : `${firstSentence.slice(0, 177).trimEnd()}...`;
+    return bounded;
+}
+/**
+ * Narrows a raw code block to the smallest useful excerpt for final grounding.
+ *
+ * Examples:
+ * - long file header plus one relevant function -> keep the function-sized slice
+ * - exact identifier present -> center the excerpt around the first identifier match
+ */
+function compactSupportingExcerpt(code, exactIdentifiers) {
+    const trimmed = code.trim();
+    if (!trimmed) {
+        return "";
+    }
+    const byIdentifier = exactIdentifiers
+        .map(identifier => extractExcerptAroundIdentifier(trimmed, identifier))
+        .find(Boolean);
+    if (byIdentifier) {
+        return byIdentifier;
+    }
+    const semanticBlock = extractLikelySemanticBlock(trimmed);
+    return limitExcerptLength(semanticBlock);
+}
+function extractExcerptAroundIdentifier(code, identifier) {
+    const escaped = identifier.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const match = code.match(new RegExp(`(^|\\n)([^\\n]{0,120}\\b${escaped}\\b[^\\n]{0,220})`, "i"));
+    const line = match?.[2]?.trim();
+    if (!line) {
+        return undefined;
+    }
+    return limitExcerptLength(line);
+}
+function extractLikelySemanticBlock(code) {
+    const lines = code.split("\n").map(line => line.trimEnd());
+    const filtered = lines.filter(line => {
+        const trimmed = line.trim();
+        if (!trimmed)
+            return false;
+        if (trimmed.startsWith("import "))
+            return false;
+        if (trimmed.startsWith("export type ") || trimmed.startsWith("type "))
+            return false;
+        if (trimmed === "/**" || trimmed === "*/" || trimmed.startsWith("* "))
+            return false;
+        return true;
+    });
+    const chosen = filtered.slice(0, 8).join("\n").trim();
+    return chosen || lines.slice(0, 6).join("\n").trim();
+}
+function limitExcerptLength(value) {
+    const normalized = sliceCode(value).replace(/\n{3,}/g, "\n\n").trim();
+    if (normalized.length <= MAX_PROMPT_EXCERPT_CHARS) {
+        return normalized;
+    }
+    return `${normalized.slice(0, MAX_PROMPT_EXCERPT_CHARS - 19).trimEnd()}\n/* … trimmed … */`;
+}
+/**
+ * Renders the compact answer packet into the final prompt.
+ *
+ * Examples:
+ * - repo-wide packet -> includes research synthesis and skips broad code dumps
+ * - single-file packet -> includes one file summary plus minimal excerpts
+ */
+function renderFinalAnswerPrompt(query, packet) {
+    const orderedQuestionSection = packet.orderedQuestions.length > 1
+        ? packet.orderedQuestions
+            .sort((left, right) => left.order - right.order)
+            .map((question, index) => `${index + 1}. ${question.text}`)
+            .join("\n")
+        : "";
+    const answerFilesSection = packet.answerSummaryByFile.length > 0
+        ? packet.answerSummaryByFile
+            .map(entry => `- ${entry.filePath}: ${entry.summary}`)
+            .join("\n")
+        : "[none]";
+    const executedAnswerFilesSection = packet.executedAnswerFiles.length > 0
+        ? packet.executedAnswerFiles.map(filePath => `- ${filePath}`).join("\n")
+        : "[none]";
+    const candidateAnswerFilesSection = packet.candidateAnswerFiles.length > 0
+        ? packet.candidateAnswerFiles.map(filePath => `- ${filePath}`).join("\n")
+        : "[none]";
+    const exactIdentifierSection = packet.exactIdentifiers.length > 0
+        ? packet.exactIdentifiers
+            .map(entry => `FILE: ${entry.filePath}\n- ${entry.identifiers.join("\n- ")}`)
+            .join("\n\n")
+        : "[No exact identifiers needed]";
+    const supportingExcerptSection = packet.supportingExcerpts.length > 0
+        ? packet.supportingExcerpts
+            .map(entry => `FILE: ${entry.filePath}\n${entry.excerpts.map(excerpt => `---\n${excerpt}`).join("\n")}`)
+            .join("\n\n")
+        : "[No supporting excerpts needed]";
+    return `
+You are an AI assistant providing the final answer to the user.
+
+This is the final stage of a structured analysis pipeline.
+
+User query:
+${query}
+
+Answer mode:
+${packet.mode}
+
+${packet.resumedContextCapsule ? `Reduced resumed context:\n${packet.resumedContextCapsule}\n` : ""}
+
+${orderedQuestionSection ? `Ordered question parts:\n${orderedQuestionSection}\n` : ""}
+
+Rationale for focus:
+${packet.rationale}
+
+Answer evidence level:
+${packet.answerEvidenceLevel}
+
+Executed answer files:
+${executedAnswerFilesSection}
+
+Candidate answer files:
+${candidateAnswerFilesSection}
+
+Grounded answer files:
+${answerFilesSection}
+
+${packet.crossFileSummary ? `Cross-file summary:\n${packet.crossFileSummary}\n` : ""}
+
+${packet.researchSummary ? `Research synthesis:\n${packet.researchSummary}\n` : ""}
+
+Exact identifiers:
+${exactIdentifierSection}
+
+Supporting excerpts:
+${supportingExcerptSection}
+
+${packet.orderedQuestions.length > 1 ? `
+Return STRICT JSON in this format:
+{
+  "answers": [
+    { "questionId": "q1", "answer": "grounded answer text", "evidenceStatus": "grounded" | "partial" | "missing" }
+  ]
+}
+The answers array must cover the ordered question parts in user order.
+` : ""}
+
+Instructions:
+- Answer the user's question directly.
+- If ordered question parts are present, answer in that exact order with numbered sections.
+- If one question lacks evidence, say so for that question only and continue with the rest.
+- Prefer the grounded answer files and research synthesis over broad code dumps.
+- Use exact identifiers only when they materially support the answer.
+- Refer to files only when they help explain the answer.
+- If the reduced resumed context already answers the question, prefer it over broader repo context.
+- Do NOT speculate.
+- Do NOT suggest further changes.
+- Be concise, grounded, and outcome-focused.
+`.trim();
+}
+/**
+ * Chooses which file list to expose in the final answer header.
+ *
+ * Priority examples:
+ * - transformed file exists -> prefer that over focus-selected files because it reflects actual work
+ * - no artifacts, but answer files exist -> use those fallback meaningful files
+ * - nothing qualified -> return `["[none]"]`
+ */
 function resolveAnalyzedFilesForOutput(context, fallbackMeaningfulFiles) {
+    const artifactPriority = resolveExecutedAnswerFiles(context, fallbackMeaningfulFiles);
+    if (artifactPriority.length > 0) {
+        return artifactPriority.slice(0, MAX_FILES);
+    }
+    const rationaleMentionedFiles = normalizeAnswerFilePaths(extractMentionedFilePaths(context.analysis?.focus?.rationale ?? ""));
+    const preferredGroundedFiles = resolvePreferredGroundedFiles(context, rationaleMentionedFiles);
+    const synthesisInputFiles = resolveArchitectureInputFiles(context);
+    const loadedGroundedFiles = normalizeAnswerFilePaths(fallbackMeaningfulFiles).filter(filePath => {
+        const isLoadedWorkingFile = (context.workingFiles ?? []).some(file => file.path === filePath && !!file.code?.trim());
+        const isPreferredGrounded = preferredGroundedFiles.includes(filePath);
+        const isSynthesisInput = synthesisInputFiles.includes(filePath);
+        return isSynthesisInput || (isLoadedWorkingFile && isPreferredGrounded);
+    });
+    if (loadedGroundedFiles.length > 0) {
+        return loadedGroundedFiles.slice(0, MAX_FILES);
+    }
+    return ["[none]"];
+}
+/**
+ * Keeps answer reporting tied to executed or verified evidence, not raw candidate metadata.
+ * Examples:
+ * - completed task step or valid verification on a selected file -> include
+ * - selected file with no execution or verify evidence -> exclude
+ */
+function resolveExecutedAnswerFiles(context, candidateAnswerFiles) {
     const transformedFiles = (context.execution?.codeTransformArtifacts?.files ?? [])
-        .map(file => file.filePath)
-        .filter((filePath, index, all) => !!filePath && all.indexOf(filePath) === index);
-    const researchTouchedFiles = (context.analysis?.researchArtifacts?.touchedFiles ?? [])
-        .filter((filePath, index, all) => !!filePath && all.indexOf(filePath) === index);
-    const semanticAnalyzedFiles = Object.entries(context.analysis?.fileAnalysis ?? {})
-        .filter(([_, analysis]) => analysis?.semanticAnalyzed)
+        .map(file => file.filePath);
+    const taskStepFiles = (context.task?.steps ?? [])
+        .filter(step => isExecutionGroundedStep(step))
+        .map(step => step.filePath);
+    const validatedFiles = (context.analysis?.executionOutcome?.validations ?? [])
+        .filter(validation => validation.status === "valid" && !!validation.filePath)
+        .map(validation => validation.filePath);
+    const verifyFiles = Object.entries(context.analysis?.verify?.byFile ?? {})
+        .filter(([filePath, verify]) => candidateAnswerFiles.includes(filePath) &&
+        (context.analysis?.focus?.selectedFiles ?? []).includes(filePath) &&
+        verify?.isRelevant === true &&
+        (verify.fileConfidence ?? 0) >= 0.45)
         .map(([filePath]) => filePath);
-    const taskStepFiles = (context.task?.taskSteps ?? [])
-        .filter(step => step.status === "completed" &&
-        !!step.filePath &&
-        !step.filePath.startsWith("__research__/"))
-        .map(step => step.filePath)
-        .filter((filePath, index, all) => all.indexOf(filePath) === index);
-    const artifactPriority = Array.from(new Set([
+    const synthesis = context.analysis?.researchArtifacts?.latestByAction?.["research-architecture-synthesis"];
+    const synthesisFiles = Array.isArray(synthesis?.collectedData?.architectureInputFiles)
+        ? (synthesis?.collectedData?.architectureInputFiles).map(item => String(item))
+        : [];
+    return normalizeAnswerFilePaths([
         ...transformedFiles,
-        ...researchTouchedFiles,
-        ...semanticAnalyzedFiles,
         ...taskStepFiles,
-    ])).filter(filePath => !!filePath && !filePath.startsWith("__research__/"));
-    if (artifactPriority.length > 0) {
-        return artifactPriority.slice(0, MAX_FILES);
+        ...validatedFiles,
+        ...verifyFiles,
+        ...synthesisFiles,
+    ]).filter(filePath => candidateAnswerFiles.includes(filePath));
+}
+function resolveAnswerEvidenceLevel(context, executedAnswerFiles, candidateAnswerFiles) {
+    if (context.analysis?.researchArtifacts?.latestByAction?.["research-architecture-synthesis"]) {
+        return "synthesized";
     }
-    if (fallbackMeaningfulFiles.length > 0) {
-        return fallbackMeaningfulFiles.slice(0, MAX_FILES);
+    if (executedAnswerFiles.some(filePath => hasExecutionGradeAnswerEvidence(context, filePath))) {
+        return "executed";
     }
-    const selected = context.analysis?.focus?.selectedFiles ?? [];
-    if (selected.length > 0) {
-        return selected.slice(0, MAX_FILES);
+    if (executedAnswerFiles.length > 0) {
+        return "verify";
     }
-    return ["[none]"];
+    if (candidateAnswerFiles.length > 0) {
+        return "candidate-only";
+    }
+    return "none";
+}
+/**
+ * Distinguishes true execution evidence from verify-only grounded files.
+ * Examples:
+ * - transformed file or valid execution validation -> true
+ * - verify-relevant selected file with no transform or validation -> false
+ */
+function hasExecutionGradeAnswerEvidence(context, filePath) {
+    return (context.task?.steps ?? []).some(step => isExecutionGroundedStep(step) && step.filePath === filePath) ||
+        (context.execution?.codeTransformArtifacts?.files ?? []).some(file => file.filePath === filePath) ||
+        (context.analysis?.executionOutcome?.validations ?? []).some(validation => validation.status === "valid" && validation.filePath === filePath);
+}
+/**
+ * Keeps final grounding on canonical repo file paths only.
+ * Examples:
+ * - "/repo/cli/src/db/fileIndex.ts" -> keep
+ * - "db/fileIndex.ts" -> drop
+ * - "__research__/impact-map" -> drop
+ */
+function normalizeAnswerFilePaths(paths) {
+    const out = new Set();
+    for (const filePath of paths) {
+        const trimmed = String(filePath ?? "").trim();
+        if (!trimmed || trimmed.startsWith("__research__/") || !path.isAbsolute(trimmed)) {
+            continue;
+        }
+        out.add(path.normalize(trimmed));
+    }
+    return Array.from(out);
+}
+/**
+ * Selects verify-backed files when semantic analysis did not produce enough grounded answer files.
+ *
+ * Why this exists:
+ * - verify can surface the files that best answer the user even when semantic excerpts are sparse
+ * - we still keep the list narrow so the final answer stays grounded and readable
+ *
+ * Examples:
+ * - existingPaths `["cli/src/index.ts"]`, verify marks `"cli/src/index.ts"` relevant -> skip duplicate
+ * - verify marks `"README.md"` relevant, but it was not selected/focused/touched this run -> skip as out of scope
+ * - `"cli/src/runner.ts"` confidence `0.22` -> skip as too weak
+ * - `"cli/src/runner.ts"` confidence `0.48` and query strongly prefers that path -> sort above a generic `0.48` match
+ */
+function resolveVerifyMeaningfulFiles(context, existingPaths) {
+    const seen = new Set(existingPaths);
+    const verifyByFile = context.analysis?.verify?.byFile ?? {};
+    const fileAnalysis = context.analysis?.fileAnalysis ?? {};
+    // Only consider files the run already had reason to care about.
+    // Example: focused files, transformed files, or files opened in the working set.
+    const eligibleVerifyFiles = new Set([
+        ...(context.analysis?.focus?.selectedFiles ?? []),
+        ...(context.execution?.codeTransformArtifacts?.files ?? []).map(file => file.filePath),
+        ...(context.workingFiles ?? []).map(file => file.path),
+    ]);
+    return Object.entries(verifyByFile)
+        .filter(([filePath, verify]) => {
+        // Avoid repeating files that semantic selection already chose.
+        if (seen.has(filePath))
+            return false;
+        // Keep verify from pulling in unrelated repo files just because they scored well.
+        if (!eligibleVerifyFiles.has(filePath))
+            return false;
+        // Require verify to explicitly say the file matters.
+        if (!verify?.isRelevant)
+            return false;
+        // Example: confidence 0.29 -> reject, confidence 0.30 -> keep.
+        return (verify.fileConfidence ?? 0) >= 0.3;
+    })
+        .sort(([filePathA, verifyA], [filePathB, verifyB]) => {
+        const prefA = getVerifyFocusFilePreference({
+            query: context.initContext?.userQuery ?? "",
+            filePath: filePathA,
+        });
+        const prefB = getVerifyFocusFilePreference({
+            query: context.initContext?.userQuery ?? "",
+            filePath: filePathB,
+        });
+        const scoreA = (verifyA.fileConfidence ?? 0) + (prefA.applies ? prefA.score : 0);
+        const scoreB = (verifyB.fileConfidence ?? 0) + (prefB.applies ? prefB.score : 0);
+        // Example: two files both score 0.50 from verify; the one matching an explicit query path wins.
+        return scoreB - scoreA;
+    })
+        .slice(0, MAX_FILES)
+        .map(([filePath]) => ({
+        path: filePath,
+        analysis: fileAnalysis[filePath] ?? {
+            semanticAnalyzed: false,
+            intent: "relevant",
+            proposedChanges: {
+                summary: "Verify evidence selected this file as relevant to the final answer.",
+                targets: ["verify evidence"],
+                rationale: "Used as a grounded answer source because verify evidence was stronger than semantic analysis coverage.",
+            },
+        },
+    }));
+}
+/**
+ * Keeps verify-backed execution files in the final packet when a verify-focus answer also has broad semantic docs.
+ * Example: a verify-wave trace can keep `mainAgentVerify.ts` and `fileCheckStep.ts`
+ * ahead of `README.md` instead of treating verify files as fallback-only.
+ */
+function resolveMeaningfulAnswerFiles(context, meaningfulFiles, verifyMeaningfulFiles) {
+    if (meaningfulFiles.length === 0) {
+        return verifyMeaningfulFiles;
+    }
+    const query = context.initContext?.userQuery ?? "";
+    if (!isVerifyFocusQueryText(query) || verifyMeaningfulFiles.length === 0) {
+        const focusedWorkingFiles = resolveFocusedWorkingAnswerFiles(context, meaningfulFiles.map(file => file.path));
+        if (focusedWorkingFiles.length === 0) {
+            return meaningfulFiles;
+        }
+        const merged = new Map();
+        for (const file of [...focusedWorkingFiles, ...meaningfulFiles]) {
+            if (!merged.has(file.path)) {
+                merged.set(file.path, file);
+            }
+        }
+        return Array.from(merged.values()).slice(0, MAX_FILES);
+    }
+    const merged = new Map();
+    const focusedWorkingFiles = resolveFocusedWorkingAnswerFiles(context, [...meaningfulFiles, ...verifyMeaningfulFiles].map(file => file.path));
+    for (const file of [...verifyMeaningfulFiles, ...focusedWorkingFiles, ...meaningfulFiles]) {
+        if (!merged.has(file.path)) {
+            merged.set(file.path, file);
+        }
+    }
+    return Array.from(merged.values()).slice(0, MAX_FILES);
+}
+function resolveFocusedWorkingAnswerFiles(context, existingPaths) {
+    const query = context.initContext?.userQuery ?? "";
+    if (!isVerifyFocusQueryText(query)) {
+        return [];
+    }
+    const seen = new Set(existingPaths);
+    const fileAnalysis = context.analysis?.fileAnalysis ?? {};
+    const selected = new Set(context.analysis?.focus?.selectedFiles ?? []);
+    return (context.workingFiles ?? [])
+        .filter(file => selected.has(file.path))
+        .filter(file => !seen.has(file.path))
+        .filter(file => file.code?.trim())
+        .filter(file => getVerifyFocusFilePreference({ query, filePath: file.path }).score > 0)
+        .map(file => ({
+        path: file.path,
+        analysis: fileAnalysis[file.path] ?? {
+            semanticAnalyzed: false,
+            intent: "relevant",
+            proposedChanges: {
+                summary: "Focused working file selected during verify and kept for final grounding.",
+                targets: ["verify focus"],
+                rationale: "Used as a grounded answer source because the verify-focused query selected and executed this file.",
+            },
+        },
+    }))
+        .slice(0, MAX_FILES);
+}
+/**
+ * Collects exact symbol/structural excerpts for one file from verify evidence.
+ *
+ * Example:
+ * - evidence excerpts ["getGroundingWaveBudget", "runVerifyWave"] -> preserve both in confidence order
+ * - import excerpt `import { upsertFileTemplate } from '../db/sqlTemplates.js';` -> preserve `upsertFileTemplate`
+ */
+function collectVerifyExactSymbols(context, filePath) {
+    const evidence = context.analysis?.verify?.byFile?.[filePath]?.evidence ?? [];
+    const ranked = evidence
+        .filter(item => (item.type === "symbol" || item.type === "structural") &&
+        typeof item.excerpt === "string" &&
+        item.excerpt.trim().length > 0 &&
+        (item.confidence ?? 0) >= MIN_EXACT_VERIFY_CONFIDENCE)
+        .sort((a, b) => (b.confidence ?? 0) - (a.confidence ?? 0));
+    const out = [];
+    const seen = new Set();
+    for (const item of ranked) {
+        const identifiers = extractUsefulExactIdentifiers(item.excerpt);
+        if (identifiers.length === 0)
+            continue;
+        for (const identifier of identifiers) {
+            const key = identifier.toLowerCase();
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            out.push(identifier);
+            if (out.length >= 4)
+                break;
+        }
+        if (out.length >= 4)
+            break;
+    }
+    return out;
+}
+function collectAnswerExactIdentifiers(context, filePath, query) {
+    const verifyIdentifiers = collectVerifyExactSymbols(context, filePath);
+    if (verifyIdentifiers.length > 0) {
+        return verifyIdentifiers;
+    }
+    if (!shouldUseQueryAlignedExactIdentifiers(context, query)) {
+        return [];
+    }
+    return collectQueryAlignedIdentifiers(context, filePath, query);
+}
+function shouldUseQueryAlignedExactIdentifiers(context, query) {
+    if ((context.analysis?.intent?.questions?.length ?? 0) > 1) {
+        return true;
+    }
+    if (context.analysis?.scopeType === "repo-wide") {
+        return true;
+    }
+    const normalized = query.trim().toLowerCase();
+    return /\b(explain|summarize|trace|how|where)\b/.test(normalized);
+}
+/**
+ * Falls back to query-aligned code identifiers when verify evidence did not preserve the exact symbol.
+ * Example: "How is verify triggered?" can surface `runVerify` from MainAgent.ts.
+ */
+function collectQueryAlignedIdentifiers(context, filePath, query) {
+    const code = context.workingFiles?.find(file => file.path === filePath)?.code ?? "";
+    if (!code.trim()) {
+        return [];
+    }
+    const queryTerms = extractQueryFocusTerms(query);
+    if (queryTerms.length === 0) {
+        return [];
+    }
+    const declarationIdentifiers = extractDeclarationIdentifiers(code)
+        .filter(identifier => {
+        const identifierParts = splitIdentifierParts(identifier);
+        const overlap = identifierParts.filter(part => queryTerms.includes(part));
+        return overlap.length > 0;
+    });
+    const preferredDeclarations = keepUsefulIdentifiers(declarationIdentifiers);
+    if (preferredDeclarations.length > 0) {
+        return preferredDeclarations.slice(0, 4);
+    }
+    const identifiers = code.match(/[A-Za-z_$][A-Za-z0-9_$]{2,}/g) ?? [];
+    const ranked = [];
+    const seen = new Set();
+    for (const identifier of identifiers) {
+        if (seen.has(identifier))
+            continue;
+        const identifierParts = splitIdentifierParts(identifier);
+        const overlap = identifierParts.filter(part => queryTerms.includes(part));
+        if (overlap.length === 0)
+            continue;
+        if (!/^(run|route|verify|search|resolve|trigger)/i.test(identifier) && overlap.length < 2) {
+            continue;
+        }
+        seen.add(identifier);
+        ranked.push(identifier);
+        if (ranked.length >= 4)
+            break;
+    }
+    return keepUsefulIdentifiers(ranked);
+}
+function extractDeclarationIdentifiers(code) {
+    const matches = Array.from(code.matchAll(/\b(?:export\s+)?(?:async\s+)?(?:function|const|let|var|class)\s+([A-Za-z_$][\w$]*)\b/g));
+    return matches.map(match => match[1]).filter(Boolean);
+}
+function buildQueryAlignedFileLabel(filePath, query) {
+    const stem = path.basename(filePath, path.extname(filePath));
+    const label = stem
+        .replace(/([a-z0-9])([A-Z])/g, "$1 $2")
+        .replace(/[_-]+/g, " ")
+        .trim();
+    if (!label) {
+        return undefined;
+    }
+    const normalizedLabel = label.toLowerCase();
+    const normalizedQuery = query.toLowerCase();
+    if (normalizedQuery.includes(normalizedLabel)) {
+        return label.replace(/\b\w/g, char => char.toUpperCase());
+    }
+    const labelTerms = normalizedLabel.split(/\s+/).filter(term => term.length >= 4);
+    const queryTerms = extractQueryFocusTerms(query);
+    const overlap = labelTerms.filter(term => queryTerms.includes(term));
+    if (overlap.length >= Math.min(2, labelTerms.length)) {
+        return label.replace(/\b\w/g, char => char.toUpperCase());
+    }
+    return undefined;
+}
+function extractQueryFocusTerms(query) {
+    const ignored = new Set([
+        "where", "what", "when", "why", "which", "who", "how", "is", "are", "do", "does",
+        "the", "this", "that", "these", "those", "and", "for", "with", "from", "into", "across",
+    ]);
+    return Array.from(new Set((query.match(/[A-Za-z][A-Za-z0-9]+/g) ?? [])
+        .map(token => normalizeQueryFocusTerm(token))
+        .filter(token => token.length >= 4 && !ignored.has(token))));
+}
+function normalizeQueryFocusTerm(token) {
+    const lower = token.toLowerCase();
+    if (lower.endsWith("ing") && lower.length > 5)
+        return lower.slice(0, -3);
+    if (lower.endsWith("ed") && lower.length > 4)
+        return lower.slice(0, -2);
+    if (lower.endsWith("es") && lower.length > 4)
+        return lower.slice(0, -2);
+    if (lower.endsWith("s") && lower.length > 4)
+        return lower.slice(0, -1);
+    return lower;
+}
+function splitIdentifierParts(identifier) {
+    return identifier
+        .replace(/([a-z0-9])([A-Z])/g, "$1 $2")
+        .replace(/[_-]+/g, " ")
+        .toLowerCase()
+        .split(/\s+/)
+        .map(part => normalizeQueryFocusTerm(part))
+        .filter(part => part.length >= 4);
+}
+/**
+ * Extracts declaration-like identifiers and drops weak generic tokens.
+ *
+ * Examples:
+ * - `export function getGroundingWaveBudget()` -> `getGroundingWaveBudget`
+ * - `import { upsertFileTemplate } from '../db/sqlTemplates.js';` -> `upsertFileTemplate`
+ * - comment-only snippets -> `[]`
+ */
+function extractUsefulExactIdentifiers(excerpt) {
+    const trimmed = excerpt.trim();
+    if (!trimmed)
+        return [];
+    const importIdentifiers = extractImportIdentifiers(trimmed);
+    if (importIdentifiers.length > 0) {
+        return importIdentifiers;
+    }
+    const declarationPatterns = [
+        /\b(?:export\s+)?(?:async\s+)?function\s+([A-Za-z_$][\w$]*)\b/,
+        /\b(?:export\s+)?(?:const|let|var|class|interface|type|enum)\s+([A-Za-z_$][\w$]*)\b/,
+        /\b([A-Za-z_$][\w$]*)\s*=\s*(?:async\s*)?\(/,
+    ];
+    for (const pattern of declarationPatterns) {
+        const match = trimmed.match(pattern);
+        const identifier = match?.[1];
+        if (identifier) {
+            return keepUsefulIdentifiers([identifier]);
+        }
+    }
+    if (/^[A-Za-z_$][\w$]*$/.test(trimmed)) {
+        return keepUsefulIdentifiers([trimmed]);
+    }
+    return [];
+}
+/**
+ * Extracts local names from import snippets so the final answer can cite exact imported symbols.
+ *
+ * Examples:
+ * - `import foo, { bar as baz } from 'pkg'` -> [`foo`, `baz`]
+ * - `import * as sqlTemplates from '../db/sqlTemplates.js'` -> [`sqlTemplates`]
+ */
+function extractImportIdentifiers(excerpt) {
+    if (!/\bimport\b/.test(excerpt)) {
+        return [];
+    }
+    const out = [];
+    const importStatements = excerpt.match(/import[\s\S]*?from\s+['"][^'"]+['"];?/g) ?? [];
+    for (const statement of importStatements) {
+        const namespaceMatch = statement.match(/import\s+\*\s+as\s+([A-Za-z_$][\w$]*)\s+from\b/);
+        if (namespaceMatch?.[1]) {
+            out.push(namespaceMatch[1]);
+        }
+        const defaultMatch = statement.match(/import\s+([A-Za-z_$][\w$]*)(?:\s*,|\s+from\b)/);
+        if (defaultMatch?.[1] && defaultMatch[1] !== "type") {
+            out.push(defaultMatch[1]);
+        }
+        const namedMatch = statement.match(/\{([^}]+)\}/);
+        if (namedMatch?.[1]) {
+            for (const part of namedMatch[1].split(",")) {
+                const cleaned = part.trim().replace(/^type\s+/, "");
+                if (!cleaned)
+                    continue;
+                const aliasMatch = cleaned.match(/^(?:[A-Za-z_$][\w$]*)\s+as\s+([A-Za-z_$][\w$]*)$/);
+                if (aliasMatch?.[1]) {
+                    out.push(aliasMatch[1]);
+                    continue;
+                }
+                const directMatch = cleaned.match(/^([A-Za-z_$][\w$]*)$/);
+                if (directMatch?.[1]) {
+                    out.push(directMatch[1]);
+                }
+            }
+        }
+    }
+    return keepUsefulIdentifiers(out);
+}
+function keepUsefulIdentifiers(identifiers) {
+    const out = [];
+    const seen = new Set();
+    for (const identifier of identifiers) {
+        const trimmed = identifier.trim();
+        if (!trimmed || GENERIC_VERIFY_IDENTIFIERS.has(trimmed.toLowerCase())) {
+            continue;
+        }
+        const key = trimmed.toLowerCase();
+        if (seen.has(key)) {
+            continue;
+        }
+        seen.add(key);
+        out.push(trimmed);
+    }
+    return out;
 }
+//# sourceMappingURL=finalAnswerModule.js.map