scai 0.1.178 → 1.0.0

package/dist/__tests__/agents/agentSearchRouting.test.js

@@ -0,0 +1,584 @@
+/**
+ * Covers modular-agent search routing and candidate shaping behavior.
+ *
+ * Why this file exists:
+ * - search mode routing should stay local to `agent/search/*`
+ * - lane-specific retention should be proven without exercising the full runtime loop
+ */
+import fs from "fs";
+import os from "os";
+import path from "path";
+import { afterEach, describe, expect, it } from "vitest";
+import { createAgentMemory } from "../../agents/agentMemory.js";
+import { finalizeLanePacket } from "../../agent/search/candidateRetentionPolicy.js";
+import { runSearchAuto, runSearchDb } from "../../agent/search/index.js";
+import { classifySearchLane } from "../../agent/search/laneClassifier.js";
+import { chooseSearchRoute } from "../../agent/search/routePolicy.js";
+import { buildSearchContext } from "../../agent/search/searchContext.js";
+import { tokenizeSearchTerms } from "../../agent/search/shared.js";
+const tempDirs = [];
+afterEach(() => {
+    while (tempDirs.length > 0) {
+        const dir = tempDirs.pop();
+        if (dir)
+            fs.rmSync(dir, { recursive: true, force: true });
+    }
+});
+describe("runSearchAuto", () => {
+    it("routes directory-listing questions to the directory lane", async () => {
+        const repoRoot = fs.mkdtempSync(path.join(os.tmpdir(), "scai-agent-search-routing-"));
+        tempDirs.push(repoRoot);
+        fs.mkdirSync(path.join(repoRoot, "cli", "src"), { recursive: true });
+        fs.writeFileSync(path.join(repoRoot, "cli", "src", "index.ts"), "export const ok = true;\n", "utf8");
+        fs.writeFileSync(path.join(repoRoot, "README.md"), "# Repo\n", "utf8");
+        const memory = createAgentMemory("list files in cli/src", repoRoot, repoRoot);
+        memory.task.queryScope = "targeted";
+        memory.task.softHints = ["cli/src"];
+        const packet = await runSearchAuto(memory, "list files in cli/src");
+        expect(packet.lane).toBe("directory");
+        expect(packet.summary).toContain("Contents of");
+        expect(packet.directoryEntries?.some((entry) => entry.name === "index.ts")).toBe(true);
+    });
+    it("routes quoted snippet questions to the fragment lane", async () => {
+        const repoRoot = fs.mkdtempSync(path.join(os.tmpdir(), "scai-agent-search-fragment-"));
+        tempDirs.push(repoRoot);
+        const targetFile = path.join(repoRoot, "cli", "src", "sample.ts");
+        fs.mkdirSync(path.dirname(targetFile), { recursive: true });
+        fs.writeFileSync(targetFile, "const currentQuestionId = task.currentQuestionId;\n", "utf8");
+        const memory = createAgentMemory("Find \"currentQuestionId = task.currentQuestionId\"", repoRoot, repoRoot);
+        memory.task.queryScope = "targeted";
+        memory.task.explicitTargets = ["currentQuestionId"];
+        const packet = await runSearchAuto(memory, "Find \"currentQuestionId = task.currentQuestionId\"");
+        expect(packet.lane).toBe("fragment");
+        expect(packet.filePaths).toContain(targetFile);
+        expect(packet.matches).toEqual(expect.arrayContaining([
+            expect.objectContaining({
+                filePath: targetFile,
+                line: 1,
+                matchKind: "fragment-content",
+            }),
+        ]));
+    });
+    it("keeps fragment search wide enough to retain concrete test files over docs", async () => {
+        const repoRoot = fs.mkdtempSync(path.join(os.tmpdir(), "scai-agent-search-fragment-width-"));
+        tempDirs.push(repoRoot);
+        const targetFile = path.join(repoRoot, "cli", "src", "__tests__", "search", "SearchOrchestrator.test.ts");
+        const evalFile = path.join(repoRoot, "cli", "src", "commands", "evalCommands.ts");
+        const registryFile = path.join(repoRoot, "cli", "src", "testing", "testRegistry.ts");
+        const docFile = path.join(repoRoot, "optimize.md");
+        fs.mkdirSync(path.dirname(targetFile), { recursive: true });
+        fs.mkdirSync(path.dirname(evalFile), { recursive: true });
+        fs.mkdirSync(path.dirname(registryFile), { recursive: true });
+        const fragment = "returns raw operator-pattern matches without semantic guessing";
+        fs.writeFileSync(targetFile, `it("${fragment}", () => {});\n`, "utf8");
+        fs.writeFileSync(evalFile, `query: "\\"${fragment}\\"",\n`, "utf8");
+        fs.writeFileSync(registryFile, `testName: "${fragment}",\n`, "utf8");
+        fs.writeFileSync(docFile, `${fragment}\n`, "utf8");
+        const memory = createAgentMemory(`"${fragment}"`, repoRoot, repoRoot);
+        memory.task.queryScope = "targeted";
+        const packet = await runSearchAuto(memory, `"${fragment}"`);
+        expect(packet.lane).toBe("fragment");
+        expect(packet.filePaths).toContain(targetFile);
+        expect(packet.topHits?.[0]?.filePath).toBe(targetFile);
+        expect(packet.topHits?.some((hit) => hit.filePath === docFile)).toBe(false);
+    });
+    it("prefers direct test ownership over meta snippet fixtures in fragment ranking", async () => {
+        const repoRoot = fs.mkdtempSync(path.join(os.tmpdir(), "scai-agent-search-fragment-meta-"));
+        tempDirs.push(repoRoot);
+        const directOwner = path.join(repoRoot, "cli", "src", "__tests__", "search", "SearchOrchestrator.test.ts");
+        const metaFixture = path.join(repoRoot, "cli", "src", "__tests__", "agents", "agentSearchRouting.test.ts");
+        fs.mkdirSync(path.dirname(directOwner), { recursive: true });
+        fs.mkdirSync(path.dirname(metaFixture), { recursive: true });
+        const fragment = "returns raw operator-pattern matches without semantic guessing";
+        fs.writeFileSync(directOwner, `it("${fragment}", () => {});\n`, "utf8");
+        fs.writeFileSync(metaFixture, `const fragment = "${fragment}";\nquery: "\\"${fragment}\\"",\n`, "utf8");
+        const memory = createAgentMemory(`"${fragment}"`, repoRoot, repoRoot);
+        memory.task.queryScope = "targeted";
+        const packet = await runSearchAuto(memory, `"${fragment}"`);
+        expect(packet.lane).toBe("fragment");
+        expect(packet.topHits?.[0]?.filePath).toBe(directOwner);
+    });
+    it("excludes dist outputs, source maps, and harness mirrors from fragment search", async () => {
+        const repoRoot = fs.mkdtempSync(path.join(os.tmpdir(), "scai-agent-search-fragment-artifacts-"));
+        tempDirs.push(repoRoot);
+        const sourceFile = path.join(repoRoot, "cli", "src", "__tests__", "search", "SearchOrchestrator.test.ts");
+        const distFile = path.join(repoRoot, "cli", "dist", "__tests__", "search", "SearchOrchestrator.test.js");
+        const mapFile = `${distFile}.map`;
+        fs.mkdirSync(path.dirname(sourceFile), { recursive: true });
+        fs.mkdirSync(path.dirname(distFile), { recursive: true });
+        const fragment = "returns raw operator-pattern matches without semantic guessing";
+        fs.writeFileSync(sourceFile, `it("${fragment}", () => {});\n`, "utf8");
+        fs.writeFileSync(distFile, `it("${fragment}", () => {});\n`, "utf8");
+        fs.writeFileSync(mapFile, JSON.stringify({ version: 3, file: "SearchOrchestrator.test.js" }), "utf8");
+        const memory = createAgentMemory(`"${fragment}"`, repoRoot, repoRoot);
+        memory.task.queryScope = "targeted";
+        const packet = await runSearchAuto(memory, `"${fragment}"`);
+        expect(packet.lane).toBe("fragment");
+        expect(packet.filePaths).toContain(sourceFile);
+        expect(packet.filePaths).not.toContain(distFile);
+        expect(packet.filePaths).not.toContain(mapFile);
+    });
+    it("keeps explicit file targets on exact-target even when the query also includes a quoted snippet", async () => {
+        const repoRoot = fs.mkdtempSync(path.join(os.tmpdir(), "scai-agent-search-explicit-fragment-"));
+        tempDirs.push(repoRoot);
+        const targetFile = path.join(repoRoot, "cli", "src", "sample.ts");
+        fs.mkdirSync(path.dirname(targetFile), { recursive: true });
+        fs.writeFileSync(targetFile, "const currentQuestionId = task.currentQuestionId;\n", "utf8");
+        const memory = createAgentMemory(`Explain sample.ts "currentQuestionId = task.currentQuestionId"`, repoRoot, repoRoot);
+        memory.task.queryScope = "targeted";
+        memory.task.explicitTargets = ["sample.ts"];
+        const packet = await runSearchAuto(memory, `Explain sample.ts "currentQuestionId = task.currentQuestionId"`);
+        expect(packet.lane).toBe("exact-target");
+        expect(packet.filePaths).toContain(targetFile);
+    });
+    it("routes operator-pattern questions to the regex lane", async () => {
+        const repoRoot = fs.mkdtempSync(path.join(os.tmpdir(), "scai-agent-search-regex-"));
+        tempDirs.push(repoRoot);
+        const targetFile = path.join(repoRoot, "cli", "src", "search.ts");
+        fs.mkdirSync(path.dirname(targetFile), { recursive: true });
+        fs.writeFileSync(targetFile, "function runSearch() {}\nfunction semanticSearchFiles() {}\n", "utf8");
+        const memory = createAgentMemory("runSearch|semanticSearchFiles", repoRoot, repoRoot);
+        memory.task.queryScope = "general";
+        const packet = await runSearchAuto(memory, "runSearch|semanticSearchFiles");
+        expect(packet.lane).toBe("regex");
+        expect(packet.filePaths).toContain(targetFile);
+        expect(packet.matches).toEqual(expect.arrayContaining([
+            expect.objectContaining({
+                filePath: targetFile,
+                line: 2,
+                matchKind: "regex-content",
+            }),
+        ]));
+    });
+    it("excludes dist outputs and source maps from regex search", async () => {
+        const repoRoot = fs.mkdtempSync(path.join(os.tmpdir(), "scai-agent-search-regex-artifacts-"));
+        tempDirs.push(repoRoot);
+        const sourceFile = path.join(repoRoot, "cli", "src", "search.ts");
+        const distFile = path.join(repoRoot, "cli", "dist", "search.js");
+        const mapFile = `${distFile}.map`;
+        fs.mkdirSync(path.dirname(sourceFile), { recursive: true });
+        fs.mkdirSync(path.dirname(distFile), { recursive: true });
+        fs.writeFileSync(sourceFile, "function runSearch() {}\nfunction semanticSearchFiles() {}\n", "utf8");
+        fs.writeFileSync(distFile, "function runSearch() {}\nfunction semanticSearchFiles() {}\n", "utf8");
+        fs.writeFileSync(mapFile, JSON.stringify({ version: 3, file: "search.js" }), "utf8");
+        const memory = createAgentMemory("runSearch|semanticSearchFiles", repoRoot, repoRoot);
+        memory.task.queryScope = "general";
+        const packet = await runSearchAuto(memory, "runSearch|semanticSearchFiles");
+        expect(packet.lane).toBe("regex");
+        expect(packet.filePaths).toContain(sourceFile);
+        expect(packet.filePaths).not.toContain(distFile);
+        expect(packet.filePaths).not.toContain(mapFile);
+    });
+    it("routes broad natural-language owner questions to the shell-content lane", async () => {
+        const repoRoot = fs.mkdtempSync(path.join(os.tmpdir(), "scai-agent-search-shell-"));
+        tempDirs.push(repoRoot);
+        const targetFile = path.join(repoRoot, "cli", "src", "agent", "state", "memory.ts");
+        fs.mkdirSync(path.dirname(targetFile), { recursive: true });
+        fs.writeFileSync(targetFile, "export const config = { maxTurns: 12, turnCount: 0 };\n", "utf8");
+        const memory = createAgentMemory("where do I set the max count for how many loops the agent can run?", repoRoot, repoRoot);
+        memory.task.queryScope = "general";
+        const packet = await runSearchDb(memory, "where do I set the max count for how many loops the agent can run?");
+        expect(packet.lane).toBe("shell-content");
+        expect(packet.filePaths).toContain(targetFile);
+        expect(packet.matches).toEqual(expect.arrayContaining([
+            expect.objectContaining({
+                filePath: targetFile,
+                matchKind: "shell-content",
+            }),
+        ]));
+    });
+    it("keeps semantic search matches on weak-signal questions", async () => {
+        const repoRoot = fs.mkdtempSync(path.join(os.tmpdir(), "scai-agent-search-semantic-matches-"));
+        tempDirs.push(repoRoot);
+        const targetFile = path.join(repoRoot, "cli", "src", "agent", "state", "memory.ts");
+        fs.mkdirSync(path.dirname(targetFile), { recursive: true });
+        fs.writeFileSync(targetFile, "export const config = { maxTurns: 12, turnCount: 0 };\n", "utf8");
+        const memory = createAgentMemory("agent loop limit configuration max count", repoRoot, repoRoot);
+        memory.task.queryScope = "general";
+        const packet = await runSearchAuto(memory, "agent loop limit configuration max count");
+        expect(packet.lane).toBe("semantic");
+        expect(packet.filePaths).toContain(targetFile);
+        expect(packet.matches).toEqual(expect.arrayContaining([
+            expect.objectContaining({
+                filePath: targetFile,
+                line: 1,
+                matchKind: "semantic-content",
+            }),
+        ]));
+    });
+    it("uses search term groups to continue semantic search when the base query is weak", async () => {
+        const repoRoot = fs.mkdtempSync(path.join(os.tmpdir(), "scai-agent-search-term-groups-"));
+        tempDirs.push(repoRoot);
+        const targetFile = path.join(repoRoot, "cli", "src", "testing", "registerDevCliCommands.ts");
+        const distractorFile = path.join(repoRoot, "cli", "src", "agent", "actions", "index.ts");
+        fs.mkdirSync(path.dirname(targetFile), { recursive: true });
+        fs.mkdirSync(path.dirname(distractorFile), { recursive: true });
+        fs.writeFileSync(targetFile, [
+            "/**",
+            " * Registers dev CLI commands.",
+            " */",
+            "export function registerDevCliCommands() {}",
+            "export const testCommands = registerDevCliCommands;",
+        ].join("\n"), "utf8");
+        fs.writeFileSync(distractorFile, [
+            "/**",
+            " * Generic action registry.",
+            " */",
+            "export function buildActionMenu() {}",
+        ].join("\n"), "utf8");
+        const query = "Explain how test execution is wired";
+        const memory = createAgentMemory(query, repoRoot, repoRoot);
+        memory.task.queryScope = "general";
+        memory.task.searchTermGroups = [
+            { kind: "generic", terms: ["repo", "test"] },
+            { kind: "repo-anchor", terms: ["registerDevCliCommands", "testCommands", "register"] },
+        ];
+        const packet = await runSearchDb(memory, query);
+        expect(packet.lane).toBe("semantic");
+        expect(packet.filePaths).toContain(targetFile);
+        expect(packet.debug?.batchDebug).toEqual([
+            expect.objectContaining({
+                query,
+                continued: true,
+                strongReason: "evidence is still driven by weak semantic terms",
+            }),
+            expect.objectContaining({
+                query: "registerDevCliCommands testCommands register",
+                kind: "repo-anchor",
+                continued: false,
+                strongEnough: true,
+            }),
+        ]);
+    });
+    it("filters shared stop words before shell-content ranking on repo test-entry queries", async () => {
+        const repoRoot = fs.mkdtempSync(path.join(os.tmpdir(), "scai-agent-search-shell-stopwords-"));
+        tempDirs.push(repoRoot);
+        const registerFile = path.join(repoRoot, "cli", "src", "testing", "registerDevCliCommands.ts");
+        const testCommandsFile = path.join(repoRoot, "cli", "src", "testing", "testCommands.ts");
+        const distractorFile = path.join(repoRoot, "cli", "src", "agent", "actions", "index.ts");
+        fs.mkdirSync(path.dirname(registerFile), { recursive: true });
+        fs.mkdirSync(path.dirname(distractorFile), { recursive: true });
+        fs.writeFileSync(registerFile, [
+            "/**",
+            " * Registers dev CLI commands for testing and eval work.",
+            " */",
+            "export function registerDevCliCommands() {}",
+        ].join("\n"), "utf8");
+        fs.writeFileSync(testCommandsFile, [
+            "/**",
+            " * Defines test entry points and test command wiring.",
+            " */",
+            "export function registerTestingCommands() {}",
+        ].join("\n"), "utf8");
+        fs.writeFileSync(distractorFile, [
+            "/**",
+            " * Why this file exists:",
+            " */",
+            "export function buildActionMenu() {}",
+        ].join("\n"), "utf8");
+        const query = "How does this repo run tests and where are the test entry points configured?";
+        const memory = createAgentMemory(query, repoRoot, repoRoot);
+        memory.task.queryScope = "general";
+        expect(tokenizeSearchTerms(query)).toEqual(expect.arrayContaining(["repo", "tests", "test", "entry", "points", "configured"]));
+        expect(tokenizeSearchTerms(query)).not.toEqual(expect.arrayContaining(["this", "how", "does", "run"]));
+        const packet = await runSearchDb(memory, query);
+        expect(packet.lane).toBe("shell-content");
+        expect(packet.filePaths).toEqual(expect.arrayContaining([registerFile, testCommandsFile]));
+        expect(packet.topHits?.slice(0, 2).map((hit) => hit.filePath)).toEqual(expect.arrayContaining([registerFile, testCommandsFile]));
+        expect(packet.topHits?.[0]?.filePath).not.toBe(distractorFile);
+        expect(packet.matches?.some((match) => (match.reasons ?? []).includes("term:this"))).toBe(false);
+    });
+    it("falls back to semantic when shell-content only finds generic weak matches", async () => {
+        const repoRoot = fs.mkdtempSync(path.join(os.tmpdir(), "scai-agent-search-shell-fallback-"));
+        tempDirs.push(repoRoot);
+        const targetFile = path.join(repoRoot, "cli", "src", "agent", "runtime", "config.ts");
+        fs.mkdirSync(path.dirname(targetFile), { recursive: true });
+        fs.writeFileSync(targetFile, [
+            "/**",
+            " * Generic runtime config holder.",
+            " */",
+            "export const runtimeConfig = { agent: true, config: true };",
+        ].join("\n"), "utf8");
+        const query = "where is the agent config in this repo?";
+        const memory = createAgentMemory(query, repoRoot, repoRoot);
+        memory.task.queryScope = "general";
+        const packet = await runSearchDb(memory, query);
+        expect(packet.lane).toBe("semantic");
+        expect(packet.filePaths).toContain(targetFile);
+    });
+    it("reranks a wider semantic frontier before returning the visible shortlist", () => {
+        const memory = createAgentMemory("where do I set the max count for how many loops the agent can run?", "/repo", "/repo");
+        memory.task.queryScope = "general";
+        const genericFiles = Array.from({ length: 11 }, (_, index) => `/repo/cli/src/agents/generic-${index}.ts`);
+        const memoryFile = "/repo/cli/src/agent/state/memory.ts";
+        const packet = finalizeLanePacket("semantic", memory, {
+            lane: "semantic",
+            query: "where do I set the max count for how many loops the agent can run?",
+            filePaths: [...genericFiles, memoryFile],
+            matches: [
+                {
+                    filePath: genericFiles[0],
+                    line: 1,
+                    snippet: "export class MainAgent {}",
+                    matchKind: "semantic-content",
+                    reasons: ["term:agent"],
+                },
+                {
+                    filePath: memoryFile,
+                    line: 40,
+                    snippet: "  maxTurns: 12,",
+                    matchKind: "semantic-content",
+                    reasons: ["term:maxTurns", "term:turnCount"],
+                },
+            ],
+        }, 8);
+        expect(packet.filePaths).toHaveLength(8);
+        expect(packet.filePaths[0]).toBe(memoryFile);
+        expect(packet.filePaths).toContain(memoryFile);
+        expect(packet.topHits?.[0]).toEqual(expect.objectContaining({
+            filePath: memoryFile,
+        }));
+    });
+});
+describe("chooseSearchRoute", () => {
+    it("routes resolved folder targets to the directory lane when listing wording is present", () => {
+        const repoRoot = fs.mkdtempSync(path.join(os.tmpdir(), "scai-agent-route-folder-"));
+        tempDirs.push(repoRoot);
+        const guardsDir = path.join(repoRoot, "cli", "src", "agents", "guards");
+        fs.mkdirSync(guardsDir, { recursive: true });
+        fs.writeFileSync(path.join(guardsDir, "executionPolicyResolver.ts"), "export const ok = true;\n", "utf8");
+        const memory = createAgentMemory("list files in cli/src/agents/guards", repoRoot, repoRoot);
+        memory.task.queryScope = "targeted";
+        memory.task.explicitTargets = [guardsDir];
+        const context = buildSearchContext(memory, "list files in cli/src/agents/guards", {
+            allowDirectoryLane: true,
+        });
+        const decision = classifySearchLane(context);
+        expect(decision).toEqual(expect.objectContaining({
+            lane: "directory",
+            resolvedTarget: guardsDir,
+        }));
+        expect(chooseSearchRoute(context)).toBe("directory");
+    });
+    it("prefers exact-target when explicit targets are present", () => {
+        const memory = createAgentMemory("Explain MainAgent.ts", "/repo", "/repo");
+        memory.task.queryScope = "targeted";
+        memory.task.explicitTargets = ["MainAgent.ts"];
+        const context = buildSearchContext(memory, "Explain the file", {
+            allowDirectoryLane: true,
+            allowRegexLane: true,
+        });
+        const decision = classifySearchLane(context);
+        expect(decision).toEqual(expect.objectContaining({
+            lane: "exact-target",
+            resolvedTarget: "MainAgent.ts",
+        }));
+        expect(chooseSearchRoute(context)).toBe("exact-target");
+    });
+    it("uses exact-target for unresolved explicit targets before semantic fallback", () => {
+        const memory = createAgentMemory("Explain guards", "/repo", "/repo");
+        memory.task.queryScope = "targeted";
+        memory.task.explicitTargets = ["guards"];
+        const context = buildSearchContext(memory, "Explain guards", {
+            allowDirectoryLane: true,
+            allowRegexLane: true,
+        });
+        const decision = classifySearchLane(context);
+        expect(decision).toEqual(expect.objectContaining({
+            lane: "exact-target",
+            resolvedTarget: "guards",
+        }));
+        expect(chooseSearchRoute(context)).toBe("exact-target");
+    });
+    it("does not route listing verbs to the directory lane when the hint is not folder-like", () => {
+        const memory = createAgentMemory("list files for retry policy", "/repo", "/repo");
+        memory.task.queryScope = "general";
+        memory.task.softHints = ["retry-policy"];
+        const context = buildSearchContext(memory, "list files for retry policy", {
+            allowDirectoryLane: true,
+        });
+        const decision = classifySearchLane(context);
+        expect(decision.lane).toBe("semantic");
+        expect(chooseSearchRoute(context)).toBe("semantic");
+    });
+    it("does not route file paths with listing wording to the directory lane", () => {
+        const memory = createAgentMemory("show contents of cli/src/agent/search/index.ts", "/repo", "/repo");
+        memory.task.queryScope = "targeted";
+        memory.task.explicitTargets = ["cli/src/agent/search/index.ts"];
+        const context = buildSearchContext(memory, "show contents of cli/src/agent/search/index.ts", {
+            allowDirectoryLane: true,
+        });
+        const decision = classifySearchLane(context);
+        expect(decision.lane).toBe("exact-target");
+        expect(chooseSearchRoute(context)).toBe("exact-target");
+    });
+    it("uses the regex lane for regex-like queries when enabled", () => {
+        const memory = createAgentMemory("runSearch|semanticSearchFiles", "/repo", "/repo");
+        memory.task.queryScope = "general";
+        const context = buildSearchContext(memory, "runSearch|semanticSearchFiles", {
+            allowDirectoryLane: true,
+            allowRegexLane: true,
+        });
+        const decision = classifySearchLane(context);
+        expect(decision.lane).toBe("regex");
+        expect(chooseSearchRoute(context)).toBe("regex");
+    });
+    it("uses the shell-content lane for broad owner questions", () => {
+        const memory = createAgentMemory("where do I set the max count for how many loops the agent can run?", "/repo", "/repo");
+        memory.task.queryScope = "general";
+        const context = buildSearchContext(memory, "where do I set the max count for how many loops the agent can run?", {
+            allowDirectoryLane: true,
+            allowRegexLane: true,
+        });
+        const decision = classifySearchLane(context);
+        expect(decision.lane).toBe("shell-content");
+        expect(chooseSearchRoute(context)).toBe("shell-content");
+    });
+    it("keeps broad architecture summaries on semantic instead of shell-content", () => {
+        const memory = createAgentMemory("summarize repo architecture and identify weak coupling points", "/repo", "/repo");
+        memory.task.queryScope = "broad-repo";
+        const context = buildSearchContext(memory, "summarize repo architecture and identify weak coupling points", {
+            allowDirectoryLane: true,
+            allowRegexLane: true,
+        });
+        const decision = classifySearchLane(context);
+        expect(decision.lane).toBe("semantic");
+        expect(chooseSearchRoute(context)).toBe("semantic");
+    });
+    it("uses the fragment lane for quoted snippets", () => {
+        const memory = createAgentMemory('Find "currentQuestionId = task.currentQuestionId"', "/repo", "/repo");
+        memory.task.queryScope = "targeted";
+        const context = buildSearchContext(memory, 'Find "currentQuestionId = task.currentQuestionId"', {
+            allowDirectoryLane: true,
+            allowRegexLane: true,
+        });
+        const decision = classifySearchLane(context);
+        expect(decision.lane).toBe("fragment");
+        expect(chooseSearchRoute(context)).toBe("fragment");
+    });
+});
+describe("runSearchDb", () => {
+    it("salvages concrete exact targets even when another target is ambiguous", async () => {
+        const repoRoot = fs.mkdtempSync(path.join(os.tmpdir(), "scai-agent-search-fallback-"));
+        tempDirs.push(repoRoot);
+        const cliIndex = path.join(repoRoot, "cli", "src", "index.ts");
+        const webIndex = path.join(repoRoot, "web", "src", "index.ts");
+        const factoryFile = path.join(repoRoot, "cli", "src", "commands", "factory.ts");
+        const daemonFile = path.join(repoRoot, "cli", "src", "runQueryWithDaemonControl.ts");
+        fs.mkdirSync(path.dirname(cliIndex), { recursive: true });
+        fs.mkdirSync(path.dirname(webIndex), { recursive: true });
+        fs.mkdirSync(path.dirname(factoryFile), { recursive: true });
+        fs.writeFileSync(cliIndex, "export const cli = true;\n", "utf8");
+        fs.writeFileSync(webIndex, "export const web = true;\n", "utf8");
+        fs.writeFileSync(factoryFile, "export const factory = true;\n", "utf8");
+        fs.writeFileSync(daemonFile, "export const daemon = true;\n", "utf8");
+        const memory = createAgentMemory("Summarize CLI architecture", repoRoot, repoRoot);
+        memory.task.queryScope = "multi-file";
+        memory.task.explicitTargets = ["index.ts", "commands/factory.ts", "runQueryWithDaemonControl.ts"];
+        const packet = await runSearchDb(memory, "Summarize CLI architecture", 5);
+        expect(packet.lane).toBe("exact-target");
+        expect(packet.filePaths).toContain(cliIndex);
+        expect(packet.filePaths).toContain(webIndex);
+        expect(packet.filePaths).toContain(factoryFile);
+        expect(packet.filePaths).toContain(daemonFile);
+        expect(packet.filePaths).not.toContain(path.join(repoRoot, "README.md"));
+    });
+    it("uses the fragment lane for quoted snippets without dispatching to regex or directory search", async () => {
+        const repoRoot = fs.mkdtempSync(path.join(os.tmpdir(), "scai-agent-search-db-fragment-"));
+        tempDirs.push(repoRoot);
+        const targetFile = path.join(repoRoot, "cli", "src", "sample.ts");
+        fs.mkdirSync(path.dirname(targetFile), { recursive: true });
+        fs.writeFileSync(targetFile, "const currentQuestionId = task.currentQuestionId;\n", "utf8");
+        const memory = createAgentMemory("Find \"currentQuestionId = task.currentQuestionId\"", repoRoot, repoRoot);
+        memory.task.queryScope = "targeted";
+        const packet = await runSearchDb(memory, "Find \"currentQuestionId = task.currentQuestionId\"");
+        expect(packet.lane).toBe("fragment");
+        expect(packet.filePaths).toContain(targetFile);
+    });
+    it("does not read eval artifacts for quoted snippet matches", async () => {
+        const repoRoot = fs.mkdtempSync(path.join(os.tmpdir(), "scai-agent-search-ignore-artifacts-"));
+        tempDirs.push(repoRoot);
+        const sourceFile = path.join(repoRoot, "cli", "src", "sample.ts");
+        const traceFile = path.join(repoRoot, "artifacts", "evals", "case1", "llm_calls", "0001_agent.understand.json");
+        fs.mkdirSync(path.dirname(sourceFile), { recursive: true });
+        fs.mkdirSync(path.dirname(traceFile), { recursive: true });
+        fs.writeFileSync(sourceFile, "return \"returns raw operator-pattern matches without semantic guessing\";\n", "utf8");
+        fs.writeFileSync(traceFile, "{\"query\":\"returns raw operator-pattern matches without semantic guessing\"}\n", "utf8");
+        const memory = createAgentMemory("\"returns raw operator-pattern matches without semantic guessing\"", repoRoot, repoRoot);
+        memory.task.queryScope = "targeted";
+        const packet = await runSearchDb(memory, "\"returns raw operator-pattern matches without semantic guessing\"");
+        expect(packet.lane).toBe("fragment");
+        expect(packet.filePaths).toContain(sourceFile);
+        expect(packet.filePaths).not.toContain(traceFile);
+    });
+});
+describe("candidateRetentionPolicy", () => {
+    it("injects well-known repo files only for sparse semantic repo-wide retrieval", () => {
+        const repoRoot = fs.mkdtempSync(path.join(os.tmpdir(), "scai-agent-search-semantic-fallback-"));
+        tempDirs.push(repoRoot);
+        const loopFile = path.join(repoRoot, "cli", "src", "agent", "runtime", "runAgentLoop.ts");
+        fs.mkdirSync(path.dirname(loopFile), { recursive: true });
+        fs.writeFileSync(loopFile, "export const loop = true;\n", "utf8");
+        fs.writeFileSync(path.join(repoRoot, "README.md"), "# Repo\n", "utf8");
+        fs.writeFileSync(path.join(repoRoot, "package.json"), "{ \"name\": \"repo\" }\n", "utf8");
+        const memory = createAgentMemory("Explain the repo structure", repoRoot, repoRoot);
+        memory.task.queryScope = "broad-repo";
+        const packet = finalizeLanePacket("semantic", memory, {
+            lane: "semantic",
+            query: "Explain the repo structure",
+            filePaths: [loopFile],
+        }, 5);
+        expect(packet.filePaths).toContain(path.join(repoRoot, "README.md"));
+    });
+    it("does not inject repo defaults into exact-target results", () => {
+        const repoRoot = fs.mkdtempSync(path.join(os.tmpdir(), "scai-agent-search-exact-fallback-"));
+        tempDirs.push(repoRoot);
+        const targetFile = path.join(repoRoot, "cli", "src", "commands", "EvalReportCmd.ts");
+        fs.mkdirSync(path.dirname(targetFile), { recursive: true });
+        fs.writeFileSync(targetFile, "export const evalReport = true;\n", "utf8");
+        fs.writeFileSync(path.join(repoRoot, "README.md"), "# Repo\n", "utf8");
+        const memory = createAgentMemory("Explain EvalReportCmd.ts", repoRoot, repoRoot);
+        memory.task.queryScope = "targeted";
+        memory.task.explicitTargets = ["EvalReportCmd.ts"];
+        const packet = finalizeLanePacket("exact-target", memory, {
+            lane: "exact-target",
+            query: "Explain EvalReportCmd.ts",
+            filePaths: [targetFile],
+        }, 5);
+        expect(packet.filePaths).toEqual([targetFile]);
+    });
+    it("keeps all resolved exact-target matches instead of trimming them like semantic search", () => {
+        const repoRoot = fs.mkdtempSync(path.join(os.tmpdir(), "scai-agent-search-exact-keep-"));
+        tempDirs.push(repoRoot);
+        const cliIndex = path.join(repoRoot, "cli", "src", "index.ts");
+        const factoryFile = path.join(repoRoot, "cli", "src", "commands", "factory.ts");
+        const daemonFile = path.join(repoRoot, "cli", "src", "runQueryWithDaemonControl.ts");
+        fs.mkdirSync(path.dirname(factoryFile), { recursive: true });
+        fs.writeFileSync(cliIndex, "export const cli = true;\n", "utf8");
+        fs.writeFileSync(factoryFile, "export const factory = true;\n", "utf8");
+        fs.writeFileSync(daemonFile, "export const daemon = true;\n", "utf8");
+        const memory = createAgentMemory("Summarize CLI architecture", repoRoot, repoRoot);
+        memory.task.queryScope = "multi-file";
+        memory.task.explicitTargets = ["index.ts", "commands/factory.ts", "runQueryWithDaemonControl.ts"];
+        const packet = finalizeLanePacket("exact-target", memory, {
+            lane: "exact-target",
+            query: "Summarize CLI architecture",
+            filePaths: [cliIndex, factoryFile, daemonFile],
+        }, 1);
+        expect(packet.filePaths).toEqual([cliIndex, factoryFile, daemonFile]);
+    });
+    it("prefers code and test files over markdown docs for fragment matches", () => {
+        const memory = createAgentMemory("\"alpha beta gamma\"", "/repo", "/repo");
+        memory.task.queryScope = "targeted";
+        const packet = finalizeLanePacket("fragment", memory, {
+            lane: "fragment",
+            query: "\"alpha beta gamma\"",
+            filePaths: [
+                "/repo/optimize.md",
+                "/repo/cli/src/__tests__/search/SearchOrchestrator.test.ts",
+            ],
+        }, 5);
+        expect(packet.topHits?.[0]?.filePath).toBe("/repo/cli/src/__tests__/search/SearchOrchestrator.test.ts");
+    });
+});
+//# sourceMappingURL=agentSearchRouting.test.js.map