scai 0.1.178 → 1.0.1

package/dist/__tests__/pipeline/modules/finalAnswerModule.test.js

@@ -0,0 +1,1139 @@
+// Verifies final grounding uses compact answer packets instead of planning-heavy prompt dumps.
+// It mocks generation so the test only covers source selection and prompt context assembly.
+import { beforeEach, describe, expect, it, vi } from "vitest";
+vi.mock("../../../lib/generate.js", () => ({
+    generate: vi.fn(),
+}));
+import { generate } from "../../../lib/generate.js";
+import { finalAnswerModule } from "../../../pipeline/modules/finalAnswerModule.js";
+describe("finalAnswerModule", () => {
+    beforeEach(() => {
+        vi.mocked(generate).mockReset();
+        vi.mocked(generate).mockResolvedValue({
+            query: "",
+            data: "Grounded answer",
+        });
+    });
+    it("uses verify-relevant selected files when semantic meaningful files are missing", async () => {
+        const verifyFile = "/repo/cli/src/agents/mainAgentVerify.ts";
+        const readinessFile = "/repo/cli/src/agents/readinessGateStep.ts";
+        const context = {
+            initContext: {
+                userQuery: "Trace how selectedFiles and candidateFiles evolve across verify waves for this query.",
+            },
+            analysis: {
+                focus: {
+                    selectedFiles: [verifyFile, readinessFile],
+                    candidateFiles: [],
+                    rationale: "Verify selected these files.",
+                },
+                verify: {
+                    byFile: {
+                        [verifyFile]: { isRelevant: true, fileConfidence: 0.78 },
+                        [readinessFile]: { isRelevant: true, fileConfidence: 0.64 },
+                    },
+                },
+                fileAnalysis: {},
+            },
+            workingFiles: [
+                { path: verifyFile, code: "const selectedFiles = []; const candidateFiles = [];" },
+                { path: readinessFile, code: "const selectedFiles = focus.selectedFiles ?? [];" },
+            ],
+            task: {
+                steps: [],
+            },
+            execution: {},
+        };
+        const out = await finalAnswerModule.run({ query: context.initContext.userQuery, context });
+        expect(String(out.content)).toContain(verifyFile);
+        expect(String(out.content)).toContain(readinessFile);
+        expect(context.analysis.finalAnswer).toContain("Analyzed files:");
+    });
+    it("ignores verify-relevant files that were never selected or loaded", async () => {
+        const selectedFile = "/repo/cli/src/agents/mainAgentVerify.ts";
+        const contextualFile = "/repo/cli/src/agents/structuralPreloadStep.ts";
+        const context = {
+            initContext: {
+                userQuery: "Trace how selectedFiles evolve across verify waves for this query.",
+            },
+            analysis: {
+                focus: {
+                    selectedFiles: [selectedFile],
+                    candidateFiles: [],
+                    rationale: "Verify selected one file.",
+                },
+                verify: {
+                    byFile: {
+                        [selectedFile]: { isRelevant: true, fileConfidence: 0.78 },
+                        [contextualFile]: { isRelevant: true, fileConfidence: 0.66 },
+                    },
+                },
+                fileAnalysis: {},
+            },
+            workingFiles: [
+                { path: selectedFile, code: "const selectedFiles = [];" },
+            ],
+            task: {
+                steps: [],
+            },
+            execution: {},
+        };
+        const out = await finalAnswerModule.run({ query: context.initContext.userQuery, context });
+        expect(String(out.content)).toContain(selectedFile);
+        expect(String(out.content)).not.toContain(contextualFile);
+    });
+    it("prefers verify pipeline files ahead of docs when both are verify-relevant", async () => {
+        const verifyFile = "/repo/cli/src/agents/mainAgentVerify.ts";
+        const readmeFile = "/repo/README.md";
+        const context = {
+            initContext: {
+                userQuery: "Trace how selectedFiles and candidateFiles evolve across verify waves for this query.",
+            },
+            analysis: {
+                focus: {
+                    selectedFiles: [verifyFile, readmeFile],
+                    candidateFiles: [],
+                    rationale: "Verify selected both files.",
+                },
+                verify: {
+                    byFile: {
+                        [verifyFile]: { isRelevant: true, fileConfidence: 0.62 },
+                        [readmeFile]: { isRelevant: true, fileConfidence: 0.72 },
+                    },
+                },
+                fileAnalysis: {},
+            },
+            workingFiles: [
+                { path: verifyFile, code: "const selectedFiles = []; const candidateFiles = [];" },
+                { path: readmeFile, code: "# verify selectedFiles candidateFiles" },
+            ],
+            task: {
+                steps: [],
+            },
+            execution: {},
+        };
+        const out = await finalAnswerModule.run({ query: context.initContext.userQuery, context });
+        const analyzedFiles = out.data.analyzedFiles;
+        expect(analyzedFiles[0]).toBe(verifyFile);
+    });
+    it("keeps verify-backed implementation files in the answer packet when semantic docs are also relevant", async () => {
+        const verifyFile = "/repo/cli/src/agents/mainAgentVerify.ts";
+        const fileCheckFile = "/repo/cli/src/agents/fileCheckStep.ts";
+        const readmeFile = "/repo/README.md";
+        const context = {
+            initContext: {
+                userQuery: "Trace how selectedFiles and candidateFiles evolve across verify waves for this query.",
+            },
+            analysis: {
+                focus: {
+                    selectedFiles: [verifyFile, fileCheckFile],
+                    candidateFiles: [readmeFile],
+                    rationale: "Verify selected the implementation files, while semantic analysis also saw docs.",
+                },
+                verify: {
+                    byFile: {
+                        [verifyFile]: { isRelevant: true, fileConfidence: 0.81 },
+                        [fileCheckFile]: { isRelevant: true, fileConfidence: 0.77 },
+                    },
+                },
+                fileAnalysis: {
+                    [readmeFile]: {
+                        semanticAnalyzed: true,
+                        intent: "relevant",
+                        proposedChanges: {
+                            summary: "Architecture overview mentions selectedFiles and candidateFiles.",
+                        },
+                    },
+                },
+            },
+            workingFiles: [
+                { path: verifyFile, code: "export async function runVerify() { const selectedFiles = []; }" },
+                { path: fileCheckFile, code: "export async function fileCheckStep() { const candidateFiles = []; }" },
+                { path: readmeFile, code: "# verify selectedFiles candidateFiles" },
+            ],
+            task: { steps: [] },
+            execution: {},
+        };
+        const out = await finalAnswerModule.run({ query: context.initContext.userQuery, context });
+        const analyzedFiles = out.data.analyzedFiles;
+        expect(analyzedFiles).toContain(verifyFile);
+        expect(analyzedFiles).toContain(fileCheckFile);
+        expect(String(out.content)).toContain(verifyFile);
+        expect(String(out.content)).toContain(fileCheckFile);
+    });
+    it("keeps selected working verify files even when verify metadata only grounded docs", async () => {
+        const verifyFile = "/repo/cli/src/agents/mainAgentVerify.ts";
+        const fileCheckFile = "/repo/cli/src/agents/fileCheckStep.ts";
+        const readmeFile = "/repo/README.md";
+        const context = {
+            initContext: {
+                userQuery: "Trace how selectedFiles and candidateFiles evolve across verify waves for this query.",
+            },
+            analysis: {
+                focus: {
+                    selectedFiles: [verifyFile, fileCheckFile],
+                    candidateFiles: [readmeFile],
+                    rationale: "The selectedFiles are directly related to the core logic of verification waves and file handling within the agent system.",
+                },
+                verify: {
+                    byFile: {
+                        [readmeFile]: { isRelevant: true, fileConfidence: 1 },
+                    },
+                },
+                fileAnalysis: {
+                    [readmeFile]: {
+                        semanticAnalyzed: true,
+                        intent: "relevant",
+                        proposedChanges: {
+                            summary: "Architecture overview mentions selectedFiles and candidateFiles.",
+                        },
+                    },
+                },
+            },
+            workingFiles: [
+                { path: verifyFile, code: "export async function runVerify() { const selectedFiles = []; }" },
+                { path: fileCheckFile, code: "export async function fileCheckStep() { const candidateFiles = []; }" },
+                { path: readmeFile, code: "# verify selectedFiles candidateFiles" },
+            ],
+            task: {
+                steps: [
+                    { filePath: verifyFile, status: "completed", type: "analysis" },
+                    { filePath: fileCheckFile, status: "completed", type: "analysis" },
+                ],
+            },
+            execution: {},
+        };
+        const out = await finalAnswerModule.run({ query: context.initContext.userQuery, context });
+        const analyzedFiles = out.data.analyzedFiles;
+        expect(analyzedFiles).toContain(verifyFile);
+        expect(analyzedFiles).toContain(fileCheckFile);
+        expect(String(out.content)).toContain(verifyFile);
+        expect(String(out.content)).toContain(fileCheckFile);
+    });
+    it("passes exact verify structural symbols into the final prompt", async () => {
+        const verifyFile = "/repo/cli/src/agents/mainAgentVerify.ts";
+        vi.mocked(generate).mockResolvedValueOnce({
+            query: "",
+            data: "Grounded answer",
+        });
+        const context = {
+            initContext: {
+                userQuery: "For repo-wide analysis questions, which method decides verify wave budget and why?",
+            },
+            analysis: {
+                focus: {
+                    selectedFiles: [verifyFile],
+                    candidateFiles: [],
+                    rationale: "Verify selected the controller file.",
+                },
+                verify: {
+                    byFile: {
+                        [verifyFile]: {
+                            isRelevant: true,
+                            fileConfidence: 0.91,
+                            evidence: [
+                                {
+                                    type: "structural",
+                                    excerpt: "getGroundingWaveBudget",
+                                    claim: "Function name matches query intent: \"getGroundingWaveBudget\"",
+                                    confidence: 0.96,
+                                },
+                            ],
+                        },
+                    },
+                },
+                fileAnalysis: {},
+            },
+            workingFiles: [
+                { path: verifyFile, code: "export function getGroundingWaveBudget() { return 4; }" },
+            ],
+            task: {
+                steps: [],
+            },
+            execution: {},
+        };
+        await finalAnswerModule.run({ query: context.initContext.userQuery, context });
+        const generateCalls = vi.mocked(generate).mock.calls;
+        const lastCall = generateCalls[generateCalls.length - 1];
+        const prompt = String(lastCall?.[0]?.content ?? "");
+        expect(prompt).toContain("Exact identifiers:");
+        expect(prompt).toContain("getGroundingWaveBudget");
+        expect(prompt).toContain("Use exact identifiers only when they materially support the answer.");
+        expect(prompt).not.toContain("getVerifyWaveBudget");
+        expect(prompt).not.toContain("PROPOSED CHANGES");
+    });
+    it("surfaces module label and query-aligned identifiers for single-file explanations", async () => {
+        const filePath = "/repo/cli/src/pipeline/modules/finalAnswerModule.ts";
+        const context = {
+            initContext: {
+                userQuery: "Explain final answer module",
+            },
+            analysis: {
+                focus: {
+                    selectedFiles: [filePath],
+                    candidateFiles: [],
+                    rationale: "The finalAnswerModule.ts file is the direct answer target.",
+                },
+                fileAnalysis: {
+                    [filePath]: {
+                        semanticAnalyzed: true,
+                        intent: "relevant",
+                        proposedChanges: {
+                            summary: "Final answer assembly lives here.",
+                        },
+                    },
+                },
+            },
+            workingFiles: [
+                {
+                    path: filePath,
+                    code: [
+                        "export const finalAnswerModule = {};",
+                        "function buildFinalAnswer() { return ''; }",
+                        "function renderFinalAnswerPrompt() { return ''; }",
+                    ].join("\n"),
+                },
+            ],
+            task: { steps: [] },
+            execution: {},
+        };
+        await finalAnswerModule.run({ query: context.initContext.userQuery, context });
+        const prompt = String(vi.mocked(generate).mock.calls.slice(-1)[0]?.[0]?.content ?? "");
+        expect(prompt).toContain("Final Answer Module");
+        expect(prompt).toContain("buildFinalAnswer");
+        expect(prompt).toContain("finalAnswerModule");
+    });
+    it("keeps preferred grounded files from research synthesis for repo-wide answers", async () => {
+        const testCmdFile = "/repo/cli/src/commands/TestCmd.ts";
+        const testCommandsFile = "/repo/cli/src/testing/testCommands.ts";
+        const context = {
+            initContext: {
+                userQuery: "How does this repo run tests and where are the test entry points configured?",
+            },
+            analysis: {
+                scopeType: "repo-wide",
+                intent: {
+                    questions: [
+                        { id: "q1", order: 0, text: "How does this repo run tests?", normalizedQuery: "How does this repo run tests?", intentCategory: "question" },
+                        { id: "q2", order: 1, text: "where are the test entry points configured?", normalizedQuery: "where are the test entry points configured?", intentCategory: "question" },
+                    ],
+                },
+                focus: {
+                    selectedFiles: [],
+                    candidateFiles: [testCmdFile, testCommandsFile],
+                    rationale: `The strongest files are ${testCmdFile} and ${testCommandsFile}.`,
+                },
+                verify: {
+                    byFile: {
+                        [testCommandsFile]: { isRelevant: true, fileConfidence: 0.91 },
+                    },
+                },
+                fileAnalysis: {
+                    [testCommandsFile]: {
+                        semanticAnalyzed: true,
+                        intent: "relevant",
+                        proposedChanges: { summary: "Test command wrappers live here." },
+                    },
+                },
+                researchArtifacts: {
+                    latestByAction: {
+                        "research-architecture-synthesis": {
+                            summary: "Architecture synthesis completed from 2 analyzed file(s).",
+                            collectedData: {
+                                problemStatement: "Summarize test entry points.",
+                                architectureInputFiles: [testCmdFile, testCommandsFile],
+                            },
+                        },
+                    },
+                },
+            },
+            workingFiles: [
+                { path: testCmdFile, code: "export class TestCmd {}" },
+                { path: testCommandsFile, code: "export function runAllTestsCommand() {}" },
+            ],
+            task: { steps: [] },
+            execution: {},
+        };
+        const out = await finalAnswerModule.run({ query: context.initContext.userQuery, context });
+        const analyzedFiles = out.data.analyzedFiles;
+        expect(analyzedFiles).toContain(testCmdFile);
+        expect(String(out.content)).toContain(testCmdFile);
+    });
+    it("prefers rationale-mentioned grounded files for snippet-only explanations", async () => {
+        const targetFile = "/repo/cli/src/__tests__/search/SearchOrchestrator.test.ts";
+        const fallbackFile = "/repo/cli/src/testing/testRegistry.ts";
+        const context = {
+            initContext: {
+                userQuery: '"returns raw operator-pattern matches without semantic guessing"',
+            },
+            analysis: {
+                focus: {
+                    selectedFiles: [fallbackFile],
+                    candidateFiles: [targetFile],
+                    rationale: `Quoted snippet is grounded in ${targetFile}.`,
+                },
+                fileAnalysis: {
+                    [fallbackFile]: {
+                        semanticAnalyzed: true,
+                        intent: "relevant",
+                        proposedChanges: { summary: "Registry references the test target." },
+                    },
+                },
+            },
+            workingFiles: [
+                { path: targetFile, code: "it('returns raw operator-pattern matches without semantic guessing', () => {});" },
+                { path: fallbackFile, code: "export const REGISTERED_TEST_TARGETS = [];" },
+            ],
+            task: { steps: [] },
+            execution: {},
+        };
+        const out = await finalAnswerModule.run({ query: context.initContext.userQuery, context });
+        const analyzedFiles = out.data.analyzedFiles;
+        expect(analyzedFiles).toContain(targetFile);
+        expect(String(out.content)).toContain(targetFile);
+    });
+    it("compresses long supporting excerpts around exact identifiers instead of dumping file headers", async () => {
+        const filePath = "/repo/cli/src/db/fileIndex.ts";
+        const longHeader = [
+            "/**",
+            " * Owns indexed file discovery and DB-backed search primitives for the CLI.",
+            " */",
+            "import fg from 'fast-glob';",
+            "import path from 'path';",
+            "import lockfile from 'proper-lockfile';",
+            "import { initSchema } from '../db/schema.js';",
+            "import { getDbForRepo } from '../db/client.js';",
+            "import { upsertFileTemplate } from '../db/sqlTemplates.js';",
+            "",
+            "async function expandQueryWithModel(query: string): Promise<string | null> {",
+            "  const response = await generate({ content: query, query: '' }, { caller: 'x' });",
+            "  return response.data as string;",
+            "}",
+        ].join("\n");
+        const context = {
+            initContext: {
+                userQuery: "Where are SQLite queries defined in db/fileIndex.ts?",
+            },
+            analysis: {
+                focus: {
+                    selectedFiles: [filePath],
+                    candidateFiles: [],
+                    rationale: "Focused DB query lookup.",
+                },
+                verify: {
+                    byFile: {
+                        [filePath]: {
+                            isRelevant: true,
+                            fileConfidence: 0.94,
+                            evidence: [
+                                {
+                                    type: "structural",
+                                    excerpt: "import { upsertFileTemplate } from '../db/sqlTemplates.js';",
+                                    claim: "Import identifier",
+                                    confidence: 0.96,
+                                },
+                            ],
+                        },
+                    },
+                },
+                fileAnalysis: {
+                    [filePath]: {
+                        semanticAnalyzed: true,
+                        intent: "relevant",
+                        proposedChanges: {
+                            summary: "SQLite helpers live in fileIndex.ts.",
+                        },
+                        excerpts: [
+                            {
+                                description: "Large excerpt",
+                                code: longHeader,
+                            },
+                        ],
+                    },
+                },
+            },
+            workingFiles: [
+                { path: filePath, code: longHeader },
+            ],
+            task: { steps: [] },
+            execution: {},
+        };
+        await finalAnswerModule.run({ query: context.initContext.userQuery, context });
+        const prompt = String(vi.mocked(generate).mock.calls.slice(-1)[0]?.[0]?.content ?? "");
+        expect(prompt).toContain("upsertFileTemplate");
+        expect(prompt).not.toContain("import fg from 'fast-glob';");
+        expect(prompt).not.toContain("Owns indexed file discovery and DB-backed search primitives");
+    });
+    it("reduces verbose focus rationale before final grounding", async () => {
+        const filePath = "/repo/cli/src/db/fileIndex.ts";
+        const context = {
+            initContext: {
+                userQuery: "Where are SQLite queries defined?",
+            },
+            analysis: {
+                focus: {
+                    selectedFiles: [filePath],
+                    candidateFiles: [],
+                    rationale: [
+                        "Pre-check: +0 selected / +0 candidate(s); totals 2 selected, 0 candidate(s).",
+                        "[Post-check] Both files are relevant based on the user's query about where SQLite queries are defined.",
+                        "[selectRelevantSources] Working files mirrored from execution lane snapshot.",
+                        "Extra line that should not survive into the final grounding packet because it is too detailed.",
+                    ].join("\n"),
+                },
+                fileAnalysis: {
+                    [filePath]: {
+                        semanticAnalyzed: true,
+                        intent: "relevant",
+                        proposedChanges: { summary: "Query helpers live here." },
+                    },
+                },
+            },
+            workingFiles: [{ path: filePath, code: "export const queryFiles = () => {};" }],
+            task: { steps: [] },
+            execution: {},
+        };
+        await finalAnswerModule.run({ query: context.initContext.userQuery, context });
+        const prompt = String(vi.mocked(generate).mock.calls.slice(-1)[0]?.[0]?.content ?? "");
+        expect(prompt).toContain("Rationale for focus:");
+        expect(prompt).toContain("Pre-check: +0 selected / +0 candidate(s); totals 2 selected, 0 candidate(s).");
+        expect(prompt).toContain("[Post-check] Both files are relevant based on the user's query about where SQLite queries are defined.");
+        expect(prompt).not.toContain("[selectRelevantSources]");
+        expect(prompt).not.toContain("Extra line that should not survive into the final grounding packet");
+    });
+    it("passes ordered question parts into the final prompt for multi-question tasks", async () => {
+        const filePath = "/repo/cli/src/agents/MainAgent.ts";
+        const context = {
+            initContext: {
+                userQuery: "Where is search routed? How is verify triggered?",
+            },
+            analysis: {
+                intent: {
+                    questions: [
+                        {
+                            id: "q1",
+                            order: 0,
+                            text: "Where is search routed?",
+                            normalizedQuery: "Where is search routed?",
+                            intentCategory: "question",
+                        },
+                        {
+                            id: "q2",
+                            order: 1,
+                            text: "How is verify triggered?",
+                            normalizedQuery: "How is verify triggered?",
+                            intentCategory: "question",
+                        },
+                    ],
+                },
+                focus: {
+                    selectedFiles: [filePath],
+                    candidateFiles: [],
+                    rationale: "Main agent file is selected.",
+                },
+                fileAnalysis: {
+                    [filePath]: {
+                        semanticAnalyzed: true,
+                        intent: "relevant",
+                        proposedChanges: {
+                            summary: "Main agent handles routing and verify entry.",
+                        },
+                    },
+                },
+            },
+            workingFiles: [
+                { path: filePath, code: "export class MainAgent {}" },
+            ],
+            task: {
+                steps: [],
+            },
+            execution: {},
+        };
+        await finalAnswerModule.run({ query: context.initContext.userQuery, context });
+        const prompt = String(vi.mocked(generate).mock.calls.slice(-1)[0]?.[0]?.content ?? "");
+        expect(prompt).toContain("Ordered question parts:");
+        expect(prompt).toContain("1. Where is search routed?");
+        expect(prompt).toContain("2. How is verify triggered?");
+        expect(prompt).toContain("answer in that exact order with numbered sections");
+    });
+    it("falls back to query-aligned exact identifiers when verify evidence omits them", async () => {
+        const filePath = "/repo/cli/src/agents/MainAgent.ts";
+        const context = {
+            initContext: {
+                userQuery: "Where is search routed? How is verify triggered?",
+            },
+            analysis: {
+                focus: {
+                    selectedFiles: [filePath],
+                    candidateFiles: [],
+                    rationale: "MainAgent handles the orchestration path.",
+                },
+                fileAnalysis: {
+                    [filePath]: {
+                        semanticAnalyzed: true,
+                        intent: "relevant",
+                        proposedChanges: {
+                            summary: "MainAgent coordinates routing and verify.",
+                        },
+                    },
+                },
+            },
+            workingFiles: [
+                {
+                    path: filePath,
+                    code: [
+                        "export class MainAgent {",
+                        "  private async runVerify(): Promise<void> {}",
+                        "  private async runVerifyBridge(): Promise<void> {",
+                        "    await this.runVerify();",
+                        "  }",
+                        "}",
+                    ].join("\n"),
+                },
+            ],
+            task: { steps: [] },
+            execution: {},
+        };
+        await finalAnswerModule.run({ query: context.initContext.userQuery, context });
+        const prompt = String(vi.mocked(generate).mock.calls.slice(-1)[0]?.[0]?.content ?? "");
+        expect(prompt).toContain("runVerify");
+    });
+    it("renders structured multi-question answers in deterministic numbered order", async () => {
+        const filePath = "/repo/cli/src/agents/MainAgent.ts";
+        vi.mocked(generate).mockResolvedValueOnce({
+            query: "",
+            data: JSON.stringify({
+                answers: [
+                    { questionId: "q1", answer: "Search is routed through MainAgent.", evidenceStatus: "grounded" },
+                    { questionId: "q2", answer: "Verify is triggered after evidence collection.", evidenceStatus: "grounded" },
+                ],
+            }),
+        });
+        const context = {
+            initContext: {
+                userQuery: "Where is search routed? How is verify triggered?",
+            },
+            analysis: {
+                intent: {
+                    questions: [
+                        { id: "q1", order: 0, text: "Where is search routed?", normalizedQuery: "Where is search routed?", intentCategory: "question" },
+                        { id: "q2", order: 1, text: "How is verify triggered?", normalizedQuery: "How is verify triggered?", intentCategory: "question" },
+                    ],
+                },
+                focus: {
+                    selectedFiles: [filePath],
+                    candidateFiles: [],
+                    rationale: "MainAgent selected.",
+                },
+                fileAnalysis: {
+                    [filePath]: {
+                        semanticAnalyzed: true,
+                        intent: "relevant",
+                        proposedChanges: { summary: "MainAgent owns loop routing and verify entry." },
+                    },
+                },
+            },
+            workingFiles: [{ path: filePath, code: "export class MainAgent {}" }],
+            task: { steps: [] },
+            execution: {},
+        };
+        const out = await finalAnswerModule.run({ query: context.initContext.userQuery, context });
+        expect(String(out.content)).toContain("1. Where is search routed?");
+        expect(String(out.content)).toContain("Search is routed through MainAgent.");
+        expect(String(out.content)).toContain("2. How is verify triggered?");
+        expect(String(out.content)).toContain("Verify is triggered after evidence collection.");
+    });
+    it("keeps plain-text multi-question answers instead of forcing missing placeholders", async () => {
+        const filePath = "/repo/cli/src/agents/MainAgent.ts";
+        vi.mocked(generate).mockResolvedValueOnce({
+            query: "",
+            data: "1. Where is search routed?\nSearch is routed through MainAgent.\n\n2. How is verify triggered?\nVerify is triggered after evidence collection.",
+        });
+        const context = {
+            initContext: {
+                userQuery: "Where is search routed? How is verify triggered?",
+            },
+            analysis: {
+                intent: {
+                    questions: [
+                        { id: "q1", order: 0, text: "Where is search routed?", normalizedQuery: "Where is search routed?", intentCategory: "question" },
+                        { id: "q2", order: 1, text: "How is verify triggered?", normalizedQuery: "How is verify triggered?", intentCategory: "question" },
+                    ],
+                },
+                focus: {
+                    selectedFiles: [filePath],
+                    candidateFiles: [],
+                    rationale: "MainAgent selected.",
+                },
+                fileAnalysis: {
+                    [filePath]: {
+                        semanticAnalyzed: true,
+                        intent: "relevant",
+                        proposedChanges: { summary: "MainAgent owns loop routing and verify entry." },
+                    },
+                },
+            },
+            workingFiles: [{ path: filePath, code: "export class MainAgent {}" }],
+            task: { steps: [] },
+            execution: {},
+        };
+        const out = await finalAnswerModule.run({ query: context.initContext.userQuery, context });
+        expect(String(out.content)).toContain("1. Where is search routed?");
+        expect(String(out.content)).toContain("2. How is verify triggered?");
+        expect(String(out.content)).not.toContain("Not enough grounded evidence");
+    });
+    it("prefers exact verify symbols over conflicting semantic prose", async () => {
+        const verifyFile = "/repo/cli/src/agents/mainAgentVerify.ts";
+        const context = {
+            initContext: {
+                userQuery: "For repo-wide analysis questions, which method decides verify wave budget and why?",
+            },
+            analysis: {
+                focus: {
+                    selectedFiles: [verifyFile],
+                    candidateFiles: [],
+                    rationale: "Verify selected the controller file.",
+                },
+                verify: {
+                    byFile: {
+                        [verifyFile]: {
+                            isRelevant: true,
+                            fileConfidence: 0.91,
+                            evidence: [
+                                {
+                                    type: "structural",
+                                    excerpt: "getGroundingWaveBudget",
+                                    claim: "Function-like declaration matches query intent: \"getGroundingWaveBudget\"",
+                                    confidence: 0.96,
+                                },
+                            ],
+                        },
+                    },
+                },
+                fileAnalysis: {
+                    [verifyFile]: {
+                        semanticAnalyzed: true,
+                        intent: "relevant",
+                        proposedChanges: {
+                            summary: "This file uses getVerifyWaveBudget to compute the budget.",
+                            scope: "minor",
+                            targets: ["getVerifyWaveBudget"],
+                            rationale: "Conflicting semantic summary",
+                        },
+                    },
+                },
+            },
+            workingFiles: [
+                { path: verifyFile, code: "export function getGroundingWaveBudget() { return 4; }" },
+            ],
+            task: {
+                steps: [],
+            },
+            execution: {},
+        };
+        await finalAnswerModule.run({ query: context.initContext.userQuery, context });
+        const generateCalls = vi.mocked(generate).mock.calls;
+        const lastCall = generateCalls[generateCalls.length - 1];
+        const prompt = String(lastCall?.[0]?.content ?? "");
+        expect(prompt).toContain("getGroundingWaveBudget");
+        expect(prompt).not.toContain("getVerifyWaveBudget");
+    });
+    it("does not let low-confidence verify symbols replace semantic analysis", async () => {
+        const verifyFile = "/repo/cli/src/agents/mainAgentVerify.ts";
+        const context = {
+            initContext: {
+                userQuery: "For repo-wide analysis questions, which method decides verify wave budget and why?",
+            },
+            analysis: {
+                focus: {
+                    selectedFiles: [verifyFile],
+                    candidateFiles: [],
+                    rationale: "Verify selected the controller file.",
+                },
+                verify: {
+                    byFile: {
+                        [verifyFile]: {
+                            isRelevant: true,
+                            fileConfidence: 0.91,
+                            evidence: [
+                                {
+                                    type: "structural",
+                                    excerpt: "getGroundingWaveBudget",
+                                    claim: "Import/Export matches query intent: \"getGroundingWaveBudget\"",
+                                    confidence: 0.55,
+                                },
+                            ],
+                        },
+                    },
+                },
+                fileAnalysis: {
+                    [verifyFile]: {
+                        semanticAnalyzed: true,
+                        intent: "relevant",
+                        proposedChanges: {
+                            summary: "Semantic analysis identifies computeVerifyBudget as the deciding method.",
+                            scope: "minor",
+                            targets: ["computeVerifyBudget"],
+                            rationale: "Semantic summary should remain authoritative here.",
+                        },
+                        excerpts: [
+                            {
+                                description: "Relevant code excerpt",
+                                code: "export function computeVerifyBudget() { return 4; }",
+                            },
+                        ],
+                    },
+                },
+            },
+            workingFiles: [
+                { path: verifyFile, code: "export function computeVerifyBudget() { return 4; }" },
+            ],
+            task: {
+                steps: [],
+            },
+            execution: {},
+        };
+        await finalAnswerModule.run({ query: context.initContext.userQuery, context });
+        const generateCalls = vi.mocked(generate).mock.calls;
+        const lastCall = generateCalls[generateCalls.length - 1];
+        const prompt = String(lastCall?.[0]?.content ?? "");
+        expect(prompt).toContain("Semantic analysis identifies computeVerifyBudget as the deciding method.");
+        expect(prompt).toContain("[No exact identifiers needed]");
+        expect(prompt).not.toContain("Verify evidence identifies getGroundingWaveBudget as an exact symbol relevant to the answer.");
+    });
+    it("prefers stored research synthesis for repo-wide grounding", async () => {
+        const registryFile = "/repo/cli/src/pipeline/registry/moduleRegistry.ts";
+        const finalFile = "/repo/cli/src/pipeline/modules/finalAnswerModule.ts";
+        const context = {
+            initContext: {
+                userQuery: "summarize this repo architecture and identify weak coupling points",
+            },
+            analysis: {
+                scopeType: "repo-wide",
+                focus: {
+                    selectedFiles: [registryFile, finalFile],
+                    candidateFiles: [],
+                    rationale: "Repo-wide architecture review.",
+                },
+                researchArtifacts: {
+                    latestByAction: {
+                        "research-architecture-synthesis": {
+                            action: "research-architecture-synthesis",
+                            summary: "Architecture synthesis completed from 6 analyzed file(s).",
+                            completedAt: "2026-04-02T00:00:00.000Z",
+                            collectedData: {
+                                problemStatement: "Summarize repository architecture and identify weak coupling points.",
+                                priorResearchSummaries: [
+                                    { action: "research-impact-map", summary: "Impact map across files." },
+                                ],
+                                sharedPatterns: ["Shared Module/ModuleIO contract."],
+                                hotspots: ["Registry layer is high impact."],
+                                couplingPoints: ["Central registry point."],
+                                architectureInputFiles: [registryFile, finalFile],
+                            },
+                        },
+                    },
+                    touchedFiles: [registryFile, finalFile],
+                },
+                fileAnalysis: {},
+            },
+            workingFiles: [
+                { path: registryFile, code: "export const builtInModules = {};" },
+                { path: finalFile, code: "export const finalAnswerModule = {};" },
+            ],
+            task: {
+                steps: [],
+            },
+            execution: {},
+        };
+        await finalAnswerModule.run({ query: context.initContext.userQuery, context });
+        const generateCalls = vi.mocked(generate).mock.calls;
+        const lastCall = generateCalls[generateCalls.length - 1];
+        const prompt = String(lastCall?.[0]?.content ?? "");
+        const options = lastCall?.[1];
+        expect(prompt).toContain("Answer mode:\nrepo-wide");
+        expect(prompt).toContain("Research synthesis:");
+        expect(prompt).toContain("Architecture synthesis completed from 6 analyzed file(s).");
+        expect(prompt).not.toContain("[No combined analysis available]");
+        expect(options?.inputContext?.researchSummary).toContain("Architecture synthesis completed from 6 analyzed file(s).");
+    });
+    it("reduces continuity capsules before final grounding", async () => {
+        const actionRouterFile = "/repo/cli/src/agents/actionRouter.ts";
+        const context = {
+            initContext: {
+                userQuery: "what should we do next?",
+                resumedContextCapsule: [
+                    "Original task: Explain routing in MainAgent.ts.",
+                    "Current task status: active",
+                    "Repo root: /repo",
+                    "Execution path: /repo",
+                    "Current intent state:",
+                    "- Normalized intent: Explain routing in MainAgent.ts",
+                    "Current routing/focus state:",
+                    "- Selected files: /repo/cli/src/agents/MainAgent.ts",
+                    "Known assumptions:",
+                    "- some assumption",
+                    "Next plan hints:",
+                    "- inspect action router",
+                    "New user query: what should we do next?",
+                ].join("\n"),
+            },
+            analysis: {
+                resumeIntent: {
+                    kind: "continuity-next-step",
+                },
+                focus: {
+                    selectedFiles: [actionRouterFile],
+                    candidateFiles: [],
+                    rationale: "Continuity fallback answer.",
+                },
+                fileAnalysis: {},
+            },
+            workingFiles: [
+                { path: actionRouterFile, code: "export async function routeAction() {}" },
+            ],
+            task: {
+                steps: [],
+            },
+            execution: {},
+        };
+        await finalAnswerModule.run({ query: context.initContext.userQuery, context });
+        const generateCalls = vi.mocked(generate).mock.calls;
+        const lastCall = generateCalls[generateCalls.length - 1];
+        const prompt = String(lastCall?.[0]?.content ?? "");
+        expect(prompt).toContain("Reduced resumed context:");
+        expect(prompt).toContain("Original task: Explain routing in MainAgent.ts.");
+        expect(prompt).toContain("New user query: what should we do next?");
+        expect(prompt).not.toContain("Repo root: /repo");
+        expect(prompt).not.toContain("Known assumptions:");
+    });
+    it("filters weak generic verify evidence before final grounding", async () => {
+        const filePath = "/repo/cli/src/db/fileIndex.ts";
+        const context = {
+            initContext: {
+                userQuery: "Where are SQLite queries defined in db/fileIndex.ts?",
+            },
+            analysis: {
+                focus: {
+                    selectedFiles: [filePath],
+                    candidateFiles: [],
+                    rationale: "Focused DB query lookup.",
+                },
+                verify: {
+                    byFile: {
+                        [filePath]: {
+                            isRelevant: true,
+                            fileConfidence: 0.91,
+                            evidence: [
+                                {
+                                    type: "symbol",
+                                    excerpt: "module",
+                                    claim: "Generic token.",
+                                    confidence: 0.96,
+                                },
+                                {
+                                    type: "structural",
+                                    excerpt: "export function compileSearchQuery() { return ''; }",
+                                    claim: "Function declaration.",
+                                    confidence: 0.96,
+                                },
+                            ],
+                        },
+                    },
+                },
+                fileAnalysis: {},
+            },
+            workingFiles: [
+                { path: filePath, code: "export function compileSearchQuery() { return ''; }" },
+            ],
+            task: {
+                steps: [],
+            },
+            execution: {},
+        };
+        await finalAnswerModule.run({ query: context.initContext.userQuery, context });
+        const generateCalls = vi.mocked(generate).mock.calls;
+        const lastCall = generateCalls[generateCalls.length - 1];
+        const prompt = String(lastCall?.[0]?.content ?? "");
+        expect(prompt).toContain("compileSearchQuery");
+        expect(prompt).not.toContain("\n- module");
+    });
+    it("drops non-canonical candidate paths from final grounding input", async () => {
+        const selectedFile = "/repo/cli/src/db/fileIndex.ts";
+        const context = {
+            initContext: {
+                userQuery: "Where are SQLite queries defined?",
+            },
+            analysis: {
+                focus: {
+                    selectedFiles: [selectedFile],
+                    candidateFiles: ["db/fileIndex.ts", "__research__/impact-map"],
+                    rationale: "Focused DB query lookup with stale compatibility candidates.",
+                },
+                fileAnalysis: {},
+            },
+            workingFiles: [
+                { path: selectedFile, code: "export const queryFiles = () => {};" },
+            ],
+            task: {
+                steps: [],
+            },
+            execution: {},
+        };
+        await finalAnswerModule.run({ query: context.initContext.userQuery, context });
+        const generateCalls = vi.mocked(generate).mock.calls;
+        const lastCall = generateCalls[generateCalls.length - 1];
+        const prompt = String(lastCall?.[0]?.content ?? "");
+        const options = lastCall?.[1];
+        expect(prompt).toContain(selectedFile);
+        expect(prompt).not.toContain("__research__/impact-map");
+        expect(prompt).toContain("Candidate answer files:");
+        expect(options?.inputContext?.answerFiles).toEqual([selectedFile]);
+        expect(options?.inputContext?.executedAnswerFiles).toEqual([]);
+        expect(options?.inputContext?.candidateAnswerFiles).toEqual([selectedFile]);
+    });
+    it("does not report analyzed files from candidate-only metadata", async () => {
+        const candidateFile = "/repo/cli/src/db/fileIndex.ts";
+        const context = {
+            initContext: {
+                userQuery: "Where are SQLite queries defined?",
+            },
+            analysis: {
+                focus: {
+                    selectedFiles: [candidateFile],
+                    candidateFiles: [],
+                    rationale: "Candidate-only focus.",
+                },
+                verify: {
+                    byFile: {
+                        [candidateFile]: {
+                            isRelevant: true,
+                            fileConfidence: 0.22,
+                        },
+                    },
+                },
+                fileAnalysis: {},
+            },
+            workingFiles: [
+                { path: candidateFile, code: "export const queryFiles = () => {};" },
+            ],
+            task: {
+                steps: [],
+            },
+            execution: {},
+        };
+        const out = await finalAnswerModule.run({ query: context.initContext.userQuery, context });
+        const analyzedFiles = out.data.analyzedFiles;
+        const generateCalls = vi.mocked(generate).mock.calls;
+        const lastCall = generateCalls[generateCalls.length - 1];
+        const options = lastCall?.[1];
+        expect(analyzedFiles).toEqual(["[none]"]);
+        expect(options?.inputContext?.executedAnswerFiles).toEqual([]);
+        expect(options?.inputContext?.candidateAnswerFiles).toEqual([candidateFile]);
+        expect(options?.inputContext?.answerEvidenceLevel).toBe("candidate-only");
+    });
+    it("does not label analysis-only steps as executed answer evidence", async () => {
+        const targetFile = "/repo/cli/src/agents/MainAgent.ts";
+        const context = {
+            initContext: {
+                userQuery: "Explain MainAgent.ts",
+            },
+            analysis: {
+                focus: {
+                    selectedFiles: [targetFile],
+                    candidateFiles: [],
+                    rationale: "Exact target explanation.",
+                },
+                fileAnalysis: {},
+            },
+            workingFiles: [
+                { path: targetFile, code: "export class MainAgent {}" },
+            ],
+            task: {
+                steps: [
+                    { taskId: 1, filePath: targetFile, status: "completed", action: "semanticAnalysis" },
+                ],
+            },
+            execution: {},
+        };
+        await finalAnswerModule.run({ query: context.initContext.userQuery, context });
+        const generateCalls = vi.mocked(generate).mock.calls;
+        const lastCall = generateCalls[generateCalls.length - 1];
+        const options = lastCall?.[1];
+        expect(options?.inputContext?.executedAnswerFiles).toEqual([]);
+        expect(options?.inputContext?.candidateAnswerFiles).toEqual([targetFile]);
+        expect(options?.inputContext?.answerEvidenceLevel).toBe("candidate-only");
+    });
+    it("reports execution-grade answer evidence from validation and verify separately", async () => {
+        const validatedFile = "/repo/cli/src/search/SearchOrchestrator.ts";
+        const verifyFile = "/repo/cli/src/agents/mainAgentVerify.ts";
+        const validationContext = {
+            initContext: {
+                userQuery: "Explain SearchOrchestrator.ts",
+            },
+            analysis: {
+                focus: {
+                    selectedFiles: [validatedFile],
+                    candidateFiles: [],
+                    rationale: "Validated execution evidence.",
+                },
+                executionOutcome: {
+                    validations: [
+                        {
+                            filePath: validatedFile,
+                            actualChange: "validated",
+                            status: "valid",
+                            requiresRedo: false,
+                        },
+                    ],
+                },
+                fileAnalysis: {},
+            },
+            workingFiles: [
+                { path: validatedFile, code: "export class SearchOrchestrator {}" },
+            ],
+            task: {
+                steps: [],
+            },
+            execution: {},
+        };
+        await finalAnswerModule.run({ query: validationContext.initContext.userQuery, context: validationContext });
+        let generateCalls = vi.mocked(generate).mock.calls;
+        let lastCall = generateCalls[generateCalls.length - 1];
+        let options = lastCall?.[1];
+        expect(options?.inputContext?.executedAnswerFiles).toEqual([validatedFile]);
+        expect(options?.inputContext?.answerEvidenceLevel).toBe("executed");
+        const verifyContext = {
+            initContext: {
+                userQuery: "Explain mainAgentVerify.ts",
+            },
+            analysis: {
+                focus: {
+                    selectedFiles: [verifyFile],
+                    candidateFiles: [],
+                    rationale: "Verify evidence only.",
+                },
+                verify: {
+                    byFile: {
+                        [verifyFile]: { isRelevant: true, fileConfidence: 0.8 },
+                    },
+                },
+                fileAnalysis: {},
+            },
+            workingFiles: [
+                { path: verifyFile, code: "export const verify = true;" },
+            ],
+            task: {
+                steps: [],
+            },
+            execution: {},
+        };
+        await finalAnswerModule.run({ query: verifyContext.initContext.userQuery, context: verifyContext });
+        generateCalls = vi.mocked(generate).mock.calls;
+        lastCall = generateCalls[generateCalls.length - 1];
+        options = lastCall?.[1];
+        expect(options?.inputContext?.executedAnswerFiles).toEqual([verifyFile]);
+        expect(options?.inputContext?.answerEvidenceLevel).toBe("verify");
+    });
+});
+//# sourceMappingURL=finalAnswerModule.test.js.map