@cue-dev/retrieval-core 0.1.3

package/test/benchmark.thresholds.test.ts

@@ -0,0 +1,815 @@
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, describe, expect, it } from "vitest";
+import { SqliteIndexRepository, SqliteQueryCache } from "@cue-dev/data-plane";
+import { RetrievalCore, mergeRetrievalScoringConfig, resolveRetrievalScoringProfile } from "../src/index.js";
+
+const QUALITY_THRESHOLD = 0.75;
+const P95_LATENCY_THRESHOLD_MS = 500;
+
+function percentile(values: number[], p: number): number {
+  if (values.length === 0) {
+    return 0;
+  }
+  const sorted = [...values].sort((a, b) => a - b);
+  const idx = Math.min(sorted.length - 1, Math.max(0, Math.ceil(sorted.length * p) - 1));
+  return sorted[idx] ?? 0;
+}
+
+describe("retrieval benchmark thresholds", () => {
+  const dirs: string[] = [];
+
+  afterEach(async () => {
+    while (dirs.length > 0) {
+      const dir = dirs.pop();
+      if (dir) {
+        await rm(dir, { recursive: true, force: true });
+      }
+    }
+  });
+
+  it("uses repository ranking path when available", async () => {
+    const root = await mkdtemp(join(tmpdir(), "cue-rank-path-"));
+    dirs.push(root);
+    const sqlitePath = join(root, "bench.sqlite");
+
+    const repo = new SqliteIndexRepository(sqlitePath);
+    await repo.migrate();
+    await repo.upsertWorkspace({
+      workspace_id: "ws-bench",
+      tenant_id: "tenant-bench",
+      name: "bench",
+      project_root_path: "/workspace/bench"
+    });
+
+    const cache = new SqliteQueryCache(sqlitePath);
+    const core = new RetrievalCore(repo, cache);
+
+    try {
+      await core.indexArtifact({
+        tenant_id: "tenant-bench",
+        workspace_id: "ws-bench",
+        index_version: "idx-rank",
+        files: [
+          {
+            path: "src/security/auth.ts",
+            language: "typescript",
+            content:
+              "export function requireTenant(id: string) {\n  if (!id) throw new Error('missing tenant');\n  return id;\n}\n"
+          }
+        ]
+      });
+
+      // Guardrail: if search falls back to in-memory list mode, this test should fail.
+      const originalList = repo.listChunksByIndex.bind(repo);
+      repo.listChunksByIndex = async () => {
+        throw new Error("fallback path should not execute when rankChunksByIndex is available");
+      };
+
+      const result = await core.searchContext({
+        trace_id: "trc-rank",
+        tenant_id: "tenant-bench",
+        workspace_id: "ws-bench",
+        request: {
+          project_root_path: "/workspace/bench",
+          query: "require tenant auth",
+          top_k: 5
+        }
+      });
+
+      expect(result.results.length).toBeGreaterThan(0);
+      repo.listChunksByIndex = originalList;
+    } finally {
+      cache.close();
+      repo.close();
+    }
+  });
+
+  it("meets latency and quality thresholds on benchmark queries", async () => {
+    const root = await mkdtemp(join(tmpdir(), "cue-benchmark-"));
+    dirs.push(root);
+    const sqlitePath = join(root, "bench.sqlite");
+
+    const repo = new SqliteIndexRepository(sqlitePath);
+    await repo.migrate();
+    await repo.upsertWorkspace({
+      workspace_id: "ws-bench",
+      tenant_id: "tenant-bench",
+      name: "bench",
+      project_root_path: "/workspace/bench"
+    });
+
+    const cache = new SqliteQueryCache(sqlitePath);
+    const core = new RetrievalCore(repo, cache);
+
+    try {
+      await core.indexArtifact({
+        tenant_id: "tenant-bench",
+        workspace_id: "ws-bench",
+        index_version: "idx-bench-v1",
+        files: [
+          {
+            path: "src/security/auth.ts",
+            language: "typescript",
+            content:
+              "export function requireTenant(id: string) {\n  if (!id) throw new Error('missing tenant');\n  return id;\n}\n"
+          },
+          {
+            path: "src/security/rbac.ts",
+            language: "typescript",
+            content:
+              "export function canAccess(role: string, action: string) {\n  return role === 'admin' || action === 'read';\n}\n"
+          },
+          {
+            path: "src/retrieval/search.ts",
+            language: "typescript",
+            content:
+              "export function searchContext(query: string) {\n  return query.toLowerCase().split(/\\s+/);\n}\n"
+          },
+          {
+            path: "src/retrieval/rerank.ts",
+            language: "typescript",
+            content:
+              "export function rerank(scores: number[]) {\n  return [...scores].sort((a, b) => b - a);\n}\n"
+          },
+          {
+            path: "src/indexer/queue.ts",
+            language: "typescript",
+            content:
+              "export async function claimNext() {\n  return { job_id: 'job-1', status: 'processing' };\n}\n"
+          },
+          {
+            path: "src/indexer/worker.ts",
+            language: "typescript",
+            content:
+              "export async function processIndexJob() {\n  return { status: 'ready', added: 1 };\n}\n"
+          },
+          {
+            path: "src/observability/metrics.ts",
+            language: "typescript",
+            content:
+              "export function emitMetric(name: string, value: number) {\n  return `${name}:${value}`;\n}\n"
+          },
+          {
+            path: "src/billing/metering.ts",
+            language: "typescript",
+            content:
+              "export function recordUsage(tenantId: string, units: number) {\n  return { tenantId, units };\n}\n"
+          }
+        ]
+      });
+
+      const suite = [
+        { query: "tenant auth check", expected_path: "src/security/auth.ts" },
+        { query: "rbac access role action", expected_path: "src/security/rbac.ts" },
+        { query: "search context query tokenizer", expected_path: "src/retrieval/search.ts" },
+        { query: "rerank score sorting", expected_path: "src/retrieval/rerank.ts" },
+        { query: "queue claim next processing", expected_path: "src/indexer/queue.ts" },
+        { query: "index worker status ready", expected_path: "src/indexer/worker.ts" },
+        { query: "emit metric name value", expected_path: "src/observability/metrics.ts" },
+        { query: "billing usage metering", expected_path: "src/billing/metering.ts" }
+      ];
+
+      let hits = 0;
+      const latencies: number[] = [];
+
+      for (const scenario of suite) {
+        const result = await core.searchContext({
+          trace_id: `trc-bench-${scenario.expected_path}`,
+          tenant_id: "tenant-bench",
+          workspace_id: "ws-bench",
+          request: {
+            project_root_path: "/workspace/bench",
+            query: scenario.query,
+            top_k: 5
+          }
+        });
+
+        latencies.push(result.search_metadata.latency_ms);
+        if (result.results.slice(0, 5).some((candidate) => candidate.path === scenario.expected_path)) {
+          hits += 1;
+        }
+      }
+
+      const hitRatio = hits / suite.length;
+      const p95 = percentile(latencies, 0.95);
+
+      expect(hitRatio).toBeGreaterThanOrEqual(QUALITY_THRESHOLD);
+      expect(p95).toBeLessThanOrEqual(P95_LATENCY_THRESHOLD_MS);
+    } finally {
+      cache.close();
+      repo.close();
+    }
+  });
+
+  it("prefers source paths over archived docs for implementation queries", async () => {
+    const root = await mkdtemp(join(tmpdir(), "cue-path-bias-"));
+    dirs.push(root);
+    const sqlitePath = join(root, "bias.sqlite");
+
+    const repo = new SqliteIndexRepository(sqlitePath);
+    await repo.migrate();
+    await repo.upsertWorkspace({
+      workspace_id: "ws-bias",
+      tenant_id: "tenant-bias",
+      name: "bias",
+      project_root_path: "/workspace/bias"
+    });
+
+    const cache = new SqliteQueryCache(sqlitePath);
+    const core = new RetrievalCore(repo, cache);
+
+    try {
+      await core.indexArtifact({
+        tenant_id: "tenant-bias",
+        workspace_id: "ws-bias",
+        index_version: "idx-bias-v1",
+        files: [
+          {
+            path: "src/security/session.ts",
+            language: "typescript",
+            content:
+              "export function validateSessionToken(token: string) {\n  return token.length > 10;\n}\n"
+          },
+          {
+            path: "docs/_archive/security-notes.md",
+            language: "markdown",
+            content:
+              "session token validation implementation notes and historical behavior for archived systems."
+          }
+        ]
+      });
+
+      const result = await core.searchContext({
+        trace_id: "trc-path-bias",
+        tenant_id: "tenant-bias",
+        workspace_id: "ws-bias",
+        request: {
+          project_root_path: "/workspace/bias",
+          query: "where is session token validation implemented",
+          top_k: 5
+        }
+      });
+
+      expect(result.results[0]?.path).toBe("src/security/session.ts");
+    } finally {
+      cache.close();
+      repo.close();
+    }
+  });
+
+  it("matches slash-delimited query terms against source identifiers", async () => {
+    const root = await mkdtemp(join(tmpdir(), "cue-tokenize-"));
+    dirs.push(root);
+    const sqlitePath = join(root, "tokenize.sqlite");
+
+    const repo = new SqliteIndexRepository(sqlitePath);
+    await repo.migrate();
+    await repo.upsertWorkspace({
+      workspace_id: "ws-tokenize",
+      tenant_id: "tenant-tokenize",
+      name: "tokenize",
+      project_root_path: "/workspace/tokenize"
+    });
+
+    const cache = new SqliteQueryCache(sqlitePath);
+    const core = new RetrievalCore(repo, cache);
+
+    try {
+      await core.indexArtifact({
+        tenant_id: "tenant-tokenize",
+        workspace_id: "ws-tokenize",
+        index_version: "idx-tokenize-v1",
+        files: [
+          {
+            path: "src/security/session.ts",
+            language: "typescript",
+            content:
+              "export function validateSessionToken(token: string) {\n  return token.startsWith('tok_');\n}\n"
+          }
+        ]
+      });
+
+      const result = await core.searchContext({
+        trace_id: "trc-tokenize",
+        tenant_id: "tenant-tokenize",
+        workspace_id: "ws-tokenize",
+        request: {
+          project_root_path: "/workspace/tokenize",
+          query: "where is auth/session/token validation implemented",
+          top_k: 5
+        }
+      });
+
+      expect(result.results[0]?.path).toBe("src/security/session.ts");
+    } finally {
+      cache.close();
+      repo.close();
+    }
+  });
+
+  it("matches singular and plural morphology for path tokens", async () => {
+    const root = await mkdtemp(join(tmpdir(), "cue-morphology-"));
+    dirs.push(root);
+    const sqlitePath = join(root, "morphology.sqlite");
+
+    const repo = new SqliteIndexRepository(sqlitePath);
+    await repo.migrate();
+    await repo.upsertWorkspace({
+      workspace_id: "ws-morphology",
+      tenant_id: "tenant-morphology",
+      name: "morphology",
+      project_root_path: "/workspace/morphology"
+    });
+
+    const cache = new SqliteQueryCache(sqlitePath);
+    const core = new RetrievalCore(repo, cache);
+
+    try {
+      await core.indexArtifact({
+        tenant_id: "tenant-morphology",
+        workspace_id: "ws-morphology",
+        index_version: "idx-morphology-v1",
+        files: [
+          {
+            path: "src/flask/blueprints.py",
+            language: "python",
+            content:
+              "def register_blueprint(app, blueprint):\n  app.blueprints[blueprint.name] = blueprint\n  return app\n"
+          }
+        ]
+      });
+
+      const result = await core.searchContext({
+        trace_id: "trc-morphology",
+        tenant_id: "tenant-morphology",
+        workspace_id: "ws-morphology",
+        request: {
+          project_root_path: "/workspace/morphology",
+          query: "where is blueprint registration implemented",
+          top_k: 5
+        }
+      });
+
+      expect(result.results[0]?.path).toBe("src/flask/blueprints.py");
+    } finally {
+      cache.close();
+      repo.close();
+    }
+  });
+
+  it("downranks lockfiles for implementation queries", async () => {
+    const root = await mkdtemp(join(tmpdir(), "cue-lockfile-"));
+    dirs.push(root);
+    const sqlitePath = join(root, "lockfile.sqlite");
+
+    const repo = new SqliteIndexRepository(sqlitePath);
+    await repo.migrate();
+    await repo.upsertWorkspace({
+      workspace_id: "ws-lockfile",
+      tenant_id: "tenant-lockfile",
+      name: "lockfile",
+      project_root_path: "/workspace/lockfile"
+    });
+
+    const cache = new SqliteQueryCache(sqlitePath);
+    const core = new RetrievalCore(repo, cache);
+
+    try {
+      await core.indexArtifact({
+        tenant_id: "tenant-lockfile",
+        workspace_id: "ws-lockfile",
+        index_version: "idx-lockfile-v1",
+        files: [
+          {
+            path: "bun.lock",
+            content: "session token validation auth tenant retry queue"
+          },
+          {
+            path: "src/security/auth.ts",
+            language: "typescript",
+            content:
+              "export function validateTenantSessionToken(token: string) {\n  return token.length > 16;\n}\n"
+          }
+        ]
+      });
+
+      const result = await core.searchContext({
+        trace_id: "trc-lockfile",
+        tenant_id: "tenant-lockfile",
+        workspace_id: "ws-lockfile",
+        request: {
+          project_root_path: "/workspace/lockfile",
+          query: "where is tenant session token validation implemented",
+          top_k: 5
+        }
+      });
+
+      expect(result.results[0]?.path).toBe("src/security/auth.ts");
+    } finally {
+      cache.close();
+      repo.close();
+    }
+  });
+
+  it("supports conservative scoring profile without breaking retrieval", async () => {
+    const root = await mkdtemp(join(tmpdir(), "cue-profile-"));
+    dirs.push(root);
+    const sqlitePath = join(root, "profile.sqlite");
+
+    const repo = new SqliteIndexRepository(sqlitePath);
+    await repo.migrate();
+    await repo.upsertWorkspace({
+      workspace_id: "ws-profile",
+      tenant_id: "tenant-profile",
+      name: "profile",
+      project_root_path: "/workspace/profile"
+    });
+
+    const cache = new SqliteQueryCache(sqlitePath);
+    const core = new RetrievalCore(repo, cache, {
+      scoringProfile: "conservative",
+      scoringProfileId: "conservative:test"
+    });
+
+    try {
+      await core.indexArtifact({
+        tenant_id: "tenant-profile",
+        workspace_id: "ws-profile",
+        index_version: "idx-profile-v1",
+        files: [
+          {
+            path: "src/security/auth.ts",
+            language: "typescript",
+            content:
+              "export function requireTenant(id: string) {\n  if (!id) throw new Error('missing tenant');\n  return id;\n}\n"
+          }
+        ]
+      });
+
+      const result = await core.searchContext({
+        trace_id: "trc-profile",
+        tenant_id: "tenant-profile",
+        workspace_id: "ws-profile",
+        request: {
+          project_root_path: "/workspace/profile",
+          query: "where is requireTenant implemented",
+          top_k: 5
+        }
+      });
+
+      expect(result.results.length).toBeGreaterThan(0);
+      expect(result.results[0]?.path).toBe("src/security/auth.ts");
+    } finally {
+      cache.close();
+      repo.close();
+    }
+  });
+
+  it("downranks test files for implementation queries", async () => {
+    const root = await mkdtemp(join(tmpdir(), "cue-test-path-bias-"));
+    dirs.push(root);
+    const sqlitePath = join(root, "test-path-bias.sqlite");
+
+    const repo = new SqliteIndexRepository(sqlitePath);
+    await repo.migrate();
+    await repo.upsertWorkspace({
+      workspace_id: "ws-test-path-bias",
+      tenant_id: "tenant-test-path-bias",
+      name: "test-path-bias",
+      project_root_path: "/workspace/test-path-bias"
+    });
+
+    const cache = new SqliteQueryCache(sqlitePath);
+    const core = new RetrievalCore(repo, cache);
+
+    try {
+      await core.indexArtifact({
+        tenant_id: "tenant-test-path-bias",
+        workspace_id: "ws-test-path-bias",
+        index_version: "idx-test-path-bias-v1",
+        files: [
+          {
+            path: "lib/request.js",
+            language: "javascript",
+            content:
+              "function parseRequestHeaders(req) {\n  return req.headers;\n}\nmodule.exports = { parseRequestHeaders };\n"
+          },
+          {
+            path: "test/request.test.js",
+            language: "javascript",
+            content:
+              "test('request headers parser', () => {\n  expect(parseRequestHeaders({ headers: {} })).toEqual({});\n});\n"
+          }
+        ]
+      });
+
+      const result = await core.searchContext({
+        trace_id: "trc-test-path-bias",
+        tenant_id: "tenant-test-path-bias",
+        workspace_id: "ws-test-path-bias",
+        request: {
+          project_root_path: "/workspace/test-path-bias",
+          query: "where is request headers parser implemented",
+          top_k: 5
+        }
+      });
+
+      expect(result.results[0]?.path).toBe("lib/request.js");
+    } finally {
+      cache.close();
+      repo.close();
+    }
+  });
+
+  it("matches camelCase identifiers with split query terms", async () => {
+    const root = await mkdtemp(join(tmpdir(), "cue-camel-case-"));
+    dirs.push(root);
+    const sqlitePath = join(root, "camel-case.sqlite");
+
+    const repo = new SqliteIndexRepository(sqlitePath);
+    await repo.migrate();
+    await repo.upsertWorkspace({
+      workspace_id: "ws-camel-case",
+      tenant_id: "tenant-camel-case",
+      name: "camel-case",
+      project_root_path: "/workspace/camel-case"
+    });
+
+    const cache = new SqliteQueryCache(sqlitePath);
+    const core = new RetrievalCore(repo, cache);
+
+    try {
+      await core.indexArtifact({
+        tenant_id: "tenant-camel-case",
+        workspace_id: "ws-camel-case",
+        index_version: "idx-camel-case-v1",
+        files: [
+          {
+            path: "lib/core/mergeConfig.js",
+            language: "javascript",
+            content:
+              "function mergeConfig(base, next) {\n  return { ...base, ...next };\n}\nmodule.exports = mergeConfig;\n"
+          }
+        ]
+      });
+
+      const result = await core.searchContext({
+        trace_id: "trc-camel-case",
+        tenant_id: "tenant-camel-case",
+        workspace_id: "ws-camel-case",
+        request: {
+          project_root_path: "/workspace/camel-case",
+          query: "where are merge config options combined",
+          top_k: 5
+        }
+      });
+
+      expect(result.results[0]?.path).toBe("lib/core/mergeConfig.js");
+    } finally {
+      cache.close();
+      repo.close();
+    }
+  });
+
+  it("matches ALL_CAPS env-var literals for config parsing paths", async () => {
+    const root = await mkdtemp(join(tmpdir(), "cue-env-var-tokenize-"));
+    dirs.push(root);
+    const sqlitePath = join(root, "env-var-tokenize.sqlite");
+
+    const repo = new SqliteIndexRepository(sqlitePath);
+    await repo.migrate();
+    await repo.upsertWorkspace({
+      workspace_id: "ws-env-var",
+      tenant_id: "tenant-env-var",
+      name: "env-var",
+      project_root_path: "/workspace/env-var"
+    });
+
+    const cache = new SqliteQueryCache(sqlitePath);
+    const core = new RetrievalCore(repo, cache);
+
+    try {
+      await core.indexArtifact({
+        tenant_id: "tenant-env-var",
+        workspace_id: "ws-env-var",
+        index_version: "idx-env-var-v1",
+        files: [
+          {
+            path: "apps/mcp-api/src/state.ts",
+            language: "typescript",
+            content:
+              "const CUE_MCP_TOKEN_BINDINGS_JSON = process.env.CUE_MCP_TOKEN_BINDINGS_JSON;\nfunction parseMcpTokenBindingsJson(raw) { return raw; }\n"
+          },
+          {
+            path: "apps/mcp-api/src/mcp-tool-guidance.ts",
+            language: "typescript",
+            content: "guidance tenant_id workspace_id project_root_path token binding json config"
+          }
+        ]
+      });
+
+      const result = await core.searchContext({
+        trace_id: "trc-env-var-tokenize",
+        tenant_id: "tenant-env-var",
+        workspace_id: "ws-env-var",
+        request: {
+          project_root_path: "/workspace/env-var",
+          query: "CUE_MCP_TOKEN_BINDINGS_JSON parse token bindings tenant_id workspace_id project_root_path",
+          top_k: 5
+        }
+      });
+
+      expect(result.results[0]?.path).toBe("apps/mcp-api/src/state.ts");
+    } finally {
+      cache.close();
+      repo.close();
+    }
+  });
+
+  it("improves enhancer retrieval for framework-specific symbols", async () => {
+    const root = await mkdtemp(join(tmpdir(), "cue-enhancer-symbols-"));
+    dirs.push(root);
+    const sqlitePath = join(root, "enhancer-symbols.sqlite");
+
+    const repo = new SqliteIndexRepository(sqlitePath);
+    await repo.migrate();
+    await repo.upsertWorkspace({
+      workspace_id: "ws-enhancer-symbols",
+      tenant_id: "tenant-enhancer-symbols",
+      name: "enhancer-symbols",
+      project_root_path: "/workspace/enhancer-symbols"
+    });
+
+    const cache = new SqliteQueryCache(sqlitePath);
+    const core = new RetrievalCore(repo, cache);
+
+    try {
+      await core.indexArtifact({
+        tenant_id: "tenant-enhancer-symbols",
+        workspace_id: "ws-enhancer-symbols",
+        index_version: "idx-enhancer-symbols-v1",
+        files: [
+          {
+            path: "src/flask/templating.py",
+            language: "python",
+            content:
+              "def render_template(template_name_or_list, **context):\n  return _render(app, template_name_or_list, context)\n\ndef render_template_string(source, **context):\n  return _render(app, source, context)\n"
+          },
+          {
+            path: "src/flask/signals.py",
+            language: "python",
+            content: "before_render_template = signal('before-render-template')\n"
+          },
+          {
+            path: "fastify.js",
+            language: "javascript",
+            content:
+              "function addHook(name, fn) { return hooks.add(name, fn) }\nfunction setErrorHandler(fn) { return buildErrorHandler(fn) }\n"
+          },
+          {
+            path: "lib/hooks.js",
+            language: "javascript",
+            content: "const supportedHooks = ['onRequest', 'preHandler', 'onError'];\nmodule.exports = { supportedHooks };\n"
+          },
+          {
+            path: "lib/error-handler.js",
+            language: "javascript",
+            content: "function buildErrorHandler(parent, func) { return function handleError(err) { return func(err) } }\n"
+          },
+          {
+            path: "docs/reference/hooks.md",
+            language: "markdown",
+            content:
+              "addHook setErrorHandler render_template examples. This is docs-only guidance and not implementation code."
+          }
+        ]
+      });
+
+      const scenarios = [
+        {
+          prompt: "Refactor render_template flow and keep extension compatibility.",
+          expected_any_of: ["src/flask/templating.py"]
+        },
+        {
+          prompt: "Tighten addHook lifecycle ordering while preserving plugin behavior.",
+          expected_any_of: ["fastify.js", "lib/hooks.js"]
+        },
+        {
+          prompt: "Refine setErrorHandler behavior while preserving request pipeline semantics.",
+          expected_any_of: ["fastify.js", "lib/error-handler.js"]
+        }
+      ];
+
+      for (const scenario of scenarios) {
+        const result = await core.enhancePrompt({
+          trace_id: `trc-enhancer-${scenario.expected_any_of[0]}`,
+          tenant_id: "tenant-enhancer-symbols",
+          workspace_id: "ws-enhancer-symbols",
+          request: {
+            prompt: scenario.prompt,
+            project_root_path: "/workspace/enhancer-symbols",
+            conversation_history: [{ role: "user", content: scenario.prompt }]
+          }
+        });
+
+        const topPaths = result.context_refs.slice(0, 3).map((ref) => ref.path);
+        expect(topPaths.some((path) => scenario.expected_any_of.includes(path))).toBe(true);
+      }
+    } finally {
+      cache.close();
+      repo.close();
+    }
+  });
+
+  it("collapses same-directory refs for symbol-heavy enhancer prompts", async () => {
+    const root = await mkdtemp(join(tmpdir(), "cue-enhancer-collapse-"));
+    dirs.push(root);
+    const sqlitePath = join(root, "enhancer-collapse.sqlite");
+
+    const repo = new SqliteIndexRepository(sqlitePath);
+    await repo.migrate();
+    await repo.upsertWorkspace({
+      workspace_id: "ws-enhancer-collapse",
+      tenant_id: "tenant-enhancer-collapse",
+      name: "enhancer-collapse",
+      project_root_path: "/workspace/enhancer-collapse"
+    });
+
+    const cache = new SqliteQueryCache(sqlitePath);
+    const core = new RetrievalCore(repo, cache);
+
+    try {
+      await core.indexArtifact({
+        tenant_id: "tenant-enhancer-collapse",
+        workspace_id: "ws-enhancer-collapse",
+        index_version: "idx-enhancer-collapse-v1",
+        files: [
+          {
+            path: "lib/hooks.js",
+            language: "javascript",
+            content:
+              "function addHook(name, fn) { return hooks.add(name, fn) }\nfunction onRequest(fn) { return fn }\nmodule.exports = { addHook, onRequest };\n"
+          },
+          {
+            path: "lib/error-handler.js",
+            language: "javascript",
+            content:
+              "function setErrorHandler(fn) { return buildErrorHandler(fn) }\nmodule.exports = { setErrorHandler };\n"
+          },
+          {
+            path: "lib/route.js",
+            language: "javascript",
+            content:
+              "function preHandler(fn) { return fn }\nfunction onError(fn) { return fn }\nmodule.exports = { preHandler, onError };\n"
+          },
+          {
+            path: "src/runtime/lifecycle.ts",
+            language: "typescript",
+            content:
+              "export function wireLifecycleHooks() { return ['addHook', 'onRequest', 'preHandler', 'setErrorHandler']; }\n"
+          }
+        ]
+      });
+
+      const result = await core.enhancePrompt({
+        trace_id: "trc-enhancer-collapse",
+        tenant_id: "tenant-enhancer-collapse",
+        workspace_id: "ws-enhancer-collapse",
+        request: {
+          prompt: "Tighten `setErrorHandler` `addHook` `onRequest` `preHandler` behavior.",
+          project_root_path: "/workspace/enhancer-collapse",
+          conversation_history: [{ role: "user", content: "Use symbol-focused implementation context only." }]
+        }
+      });
+
+      expect(result.context_refs.length).toBeLessThanOrEqual(3);
+      const libRefs = result.context_refs.filter((ref) => ref.path.startsWith("lib/"));
+      expect(libRefs.length).toBeLessThanOrEqual(1);
+    } finally {
+      cache.close();
+      repo.close();
+    }
+  });
+
+  it("rejects invalid scoring config merges", () => {
+    const baseline = resolveRetrievalScoringProfile("baseline");
+    expect(() =>
+      mergeRetrievalScoringConfig(baseline.config, {
+        candidate_weights: {
+          lexical_weight: 0.8,
+          vector_weight: 0.8
+        }
+      })
+    ).toThrow(/lexical_weight \+ vector_weight must equal 1/);
+
+    expect(() =>
+      mergeRetrievalScoringConfig(baseline.config, {
+        rerank: {
+          merge_gap_lines: -1
+        }
+      })
+    ).toThrow(/merge_gap_lines must be an integer >= 0/);
+  });
+});