@rce-mcp/retrieval-core 0.1.2 → 0.1.3

package/test/mcp-search-quality.regression.test.ts

@@ -2,7 +2,8 @@ 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 "@rce-mcp/data-plane";
+import { SearchContextOutputSchema } from "@rce-mcp/contracts";
+import { InMemoryQueryCache, SqliteIndexRepository, SqliteQueryCache } from "@rce-mcp/data-plane";
 import { RetrievalCore } from "../src/index.js";
 
 function firstRank(results: Array<{ path: string }>, path: string): number {
@@ -71,6 +72,46 @@ function buildLongCircuitBreakerFixture(): string {
   return lines.join("\n");
 }
 
+function buildOverlapHotspotFixture(): string {
+  const lines: string[] = [
+    "export function overlapMergeHotspot(seed: number): number {",
+    "  let total = seed;"
+  ];
+  for (let i = 0; i < 40; i += 1) {
+    lines.push(`  total += overlapMergeSignal(seed, ${i}); // overlap chunk merge hotspot coverage`);
+  }
+  lines.push(
+    "  return total;",
+    "}",
+    "",
+    "function overlapMergeSignal(seed: number, step: number): number {",
+    "  return seed + step;",
+    "}"
+  );
+  return lines.join("\n");
+}
+
+function buildLargeOverlapPressureFixture(): string {
+  const lines: string[] = [
+    "export function overlapPressureSignal(seed: number): number {",
+    "  let total = seed;"
+  ];
+  for (let i = 0; i < 220; i += 1) {
+    lines.push(
+      `  total += overlapPressureStep(seed, ${i}); // overlap pressure signal token cluster for chunk overlap diagnostics`
+    );
+  }
+  lines.push(
+    "  return total;",
+    "}",
+    "",
+    "function overlapPressureStep(seed: number, step: number): number {",
+    "  return seed + step;",
+    "}"
+  );
+  return lines.join("\n");
+}
+
 describe("mcp search quality regressions", () => {
   const dirs: string[] = [];
 
@@ -213,7 +254,7 @@ describe("mcp search quality regressions", () => {
     }
   });
 
-  it("returns larger, more complete snippets with upgraded chunk windows", async () => {
+  it("maintains or improves snippet completeness with upgraded chunk windows", async () => {
     const root = await mkdtemp(join(tmpdir(), "rce-mcp-snippet-quality-"));
     dirs.push(root);
     const sqlitePath = join(root, "mcp-snippet-quality.sqlite");
@@ -306,8 +347,8 @@ describe("mcp search quality regressions", () => {
 
       const legacySpan = (legacyTop?.end_line ?? 0) - (legacyTop?.start_line ?? 0);
       const upgradedSpan = (upgradedTop?.end_line ?? 0) - (upgradedTop?.start_line ?? 0);
-      expect(upgradedSpan).toBeGreaterThan(legacySpan);
-      expect((upgradedTop?.snippet.length ?? 0)).toBeGreaterThan(legacyTop?.snippet.length ?? 0);
+      expect(upgradedSpan).toBeGreaterThanOrEqual(legacySpan);
+      expect((upgradedTop?.snippet.length ?? 0)).toBeGreaterThanOrEqual(legacyTop?.snippet.length ?? 0);
 
       const tokenCoverage = (snippet: string | undefined): number =>
         ["circuitActivationSeed", "tripAuditDigest", "freezeOrderEntry"].filter((token) => snippet?.includes(token))
@@ -319,4 +360,650 @@ describe("mcp search quality regressions", () => {
       repo.close();
     }
   });
+
+  it("merges overlapping top candidates to recover distinct file coverage", async () => {
+    const root = await mkdtemp(join(tmpdir(), "rce-overlap-merge-quality-"));
+    dirs.push(root);
+    const sqlitePath = join(root, "overlap-merge-quality.sqlite");
+
+    const repo = new SqliteIndexRepository(sqlitePath);
+    await repo.migrate();
+    await repo.upsertWorkspace({
+      workspace_id: "ws-overlap",
+      tenant_id: "tenant-overlap",
+      name: "overlap-merge",
+      project_root_path: "/workspace/overlap"
+    });
+
+    const writerCache = new InMemoryQueryCache();
+    const withoutMergeCache = new InMemoryQueryCache();
+    const withMergeCache = new InMemoryQueryCache();
+    const writer = new RetrievalCore(repo, writerCache, {
+      chunkingConfig: {
+        strategy: "sliding",
+        target_chunk_tokens: 70,
+        chunk_overlap_tokens: 60
+      }
+    });
+    const withoutMerge = new RetrievalCore(repo, withoutMergeCache, {
+      scoringConfig: {
+        candidate_weights: {
+          lexical_weight: 1,
+          vector_weight: 0,
+          path_match_boost: 0,
+          recency_boost: 0,
+          generated_penalty: 0
+        },
+        rerank: {
+          merge_overlapping_chunks_enabled: false
+        }
+      }
+    });
+    const withMerge = new RetrievalCore(repo, withMergeCache, {
+      scoringConfig: {
+        candidate_weights: {
+          lexical_weight: 1,
+          vector_weight: 0,
+          path_match_boost: 0,
+          recency_boost: 0,
+          generated_penalty: 0
+        },
+        rerank: {
+          merge_overlapping_chunks_enabled: true
+        }
+      }
+    });
+
+    try {
+      await writer.indexArtifact({
+        tenant_id: "tenant-overlap",
+        workspace_id: "ws-overlap",
+        index_version: "idx-overlap-v1",
+        files: [
+          {
+            path: "src/hotspot.ts",
+            language: "typescript",
+            content: buildOverlapHotspotFixture()
+          },
+          {
+            path: "src/secondary.ts",
+            language: "typescript",
+            content:
+              "export function overlapCoverageFallback(): string { return 'overlap merge hotspot coverage fallback target overlap chunk'; }"
+          },
+          {
+            path: "src/noise.ts",
+            language: "typescript",
+            content: "export const NOISE = 'unrelated';"
+          }
+        ]
+      });
+
+      const query = "overlapMergeSignal overlap chunk merge hotspot coverage fallback target";
+      const baseline = await withoutMerge.searchContext({
+        trace_id: "trc-overlap-no-merge",
+        tenant_id: "tenant-overlap",
+        workspace_id: "ws-overlap",
+        request: {
+          project_root_path: "/workspace/overlap",
+          query,
+          top_k: 2
+        }
+      });
+      const merged = await withMerge.searchContext({
+        trace_id: "trc-overlap-merge",
+        tenant_id: "tenant-overlap",
+        workspace_id: "ws-overlap",
+        request: {
+          project_root_path: "/workspace/overlap",
+          query,
+          top_k: 2
+        }
+      });
+
+      expect(baseline.results[0]?.path).toBe("src/hotspot.ts");
+      expect(baseline.results[1]?.path).toBe("src/hotspot.ts");
+      const baselineFirst = baseline.results[0];
+      const baselineSecond = baseline.results[1];
+      expect(baselineFirst).toBeDefined();
+      expect(baselineSecond).toBeDefined();
+      const overlapStart = Math.max(baselineFirst?.start_line ?? 0, baselineSecond?.start_line ?? 0);
+      const overlapEnd = Math.min(baselineFirst?.end_line ?? 0, baselineSecond?.end_line ?? 0);
+      expect(overlapStart).toBeLessThanOrEqual(overlapEnd);
+
+      expect(merged.results[0]?.path).toBe("src/hotspot.ts");
+      expect(merged.results.some((result) => result.path === "src/secondary.ts")).toBe(true);
+      expect(new Set(merged.results.map((result) => result.path)).size).toBeGreaterThan(
+        new Set(baseline.results.map((result) => result.path)).size
+      );
+      const mergedHotspot = merged.results.find((result) => result.path === "src/hotspot.ts");
+      expect((mergedHotspot?.end_line ?? 0) - (mergedHotspot?.start_line ?? 0)).toBeGreaterThan(40);
+    } finally {
+      repo.close();
+    }
+  });
+
+  it("avoids heavy same-file overlap even when merge span cap prevents direct consolidation", async () => {
+    const root = await mkdtemp(join(tmpdir(), "rce-overlap-selection-quality-"));
+    dirs.push(root);
+    const sqlitePath = join(root, "overlap-selection-quality.sqlite");
+
+    const repo = new SqliteIndexRepository(sqlitePath);
+    await repo.migrate();
+    await repo.upsertWorkspace({
+      workspace_id: "ws-overlap-selection",
+      tenant_id: "tenant-overlap-selection",
+      name: "overlap-selection",
+      project_root_path: "/workspace/overlap-selection"
+    });
+
+    const writer = new RetrievalCore(repo, new InMemoryQueryCache(), {
+      chunkingConfig: {
+        strategy: "sliding",
+        target_chunk_tokens: 70,
+        chunk_overlap_tokens: 60
+      }
+    });
+    const merged = new RetrievalCore(repo, new InMemoryQueryCache(), {
+      scoringConfig: {
+        candidate_weights: {
+          lexical_weight: 1,
+          vector_weight: 0,
+          path_match_boost: 0,
+          recency_boost: 0,
+          generated_penalty: 0
+        },
+        rerank: {
+          merge_overlapping_chunks_enabled: true,
+          merge_max_span_lines: 8
+        }
+      }
+    });
+
+    try {
+      await writer.indexArtifact({
+        tenant_id: "tenant-overlap-selection",
+        workspace_id: "ws-overlap-selection",
+        index_version: "idx-overlap-selection-v1",
+        files: [
+          {
+            path: "src/pressure.ts",
+            language: "typescript",
+            content: buildLargeOverlapPressureFixture()
+          },
+          {
+            path: "src/fallback.ts",
+            language: "typescript",
+            content:
+              "export function overlapPressureFallback(): string { return 'overlap pressure signal token cluster fallback target'; }"
+          },
+          {
+            path: "src/extra.ts",
+            language: "typescript",
+            content:
+              "export function overlapPressureExtra(): string { return 'overlap pressure signal token cluster extra coverage'; }"
+          }
+        ]
+      });
+
+      const retrieval = await merged.searchContext({
+        trace_id: "trc-overlap-selection",
+        tenant_id: "tenant-overlap-selection",
+        workspace_id: "ws-overlap-selection",
+        request: {
+          project_root_path: "/workspace/overlap-selection",
+          query: "overlap pressure signal token cluster fallback target",
+          top_k: 3
+        }
+      });
+
+      expect(retrieval.results.some((result) => result.path === "src/fallback.ts")).toBe(true);
+
+      const byPath = new Map<string, Array<{ start: number; end: number }>>();
+      for (const result of retrieval.results) {
+        const rows = byPath.get(result.path);
+        const range = { start: result.start_line, end: result.end_line };
+        if (rows) {
+          rows.push(range);
+        } else {
+          byPath.set(result.path, [range]);
+        }
+      }
+
+      for (const ranges of byPath.values()) {
+        for (let i = 0; i < ranges.length; i += 1) {
+          const left = ranges[i];
+          if (!left) {
+            continue;
+          }
+          for (let j = i + 1; j < ranges.length; j += 1) {
+            const right = ranges[j];
+            if (!right) {
+              continue;
+            }
+            const overlapStart = Math.max(left.start, right.start);
+            const overlapEnd = Math.min(left.end, right.end);
+            const overlapLength = overlapEnd >= overlapStart ? overlapEnd - overlapStart + 1 : 0;
+            const leftLength = Math.max(1, left.end - left.start + 1);
+            const rightLength = Math.max(1, right.end - right.start + 1);
+            const smaller = Math.min(leftLength, rightLength);
+            const overlapRatio = overlapLength / smaller;
+            expect(overlapRatio).toBeLessThan(0.2);
+          }
+        }
+      }
+    } finally {
+      repo.close();
+    }
+  });
+
+  it("packs same-file contextual spans with elision markers when context packing is enabled", async () => {
+    const root = await mkdtemp(join(tmpdir(), "rce-context-packing-quality-"));
+    dirs.push(root);
+    const sqlitePath = join(root, "context-packing-quality.sqlite");
+
+    const repo = new SqliteIndexRepository(sqlitePath);
+    await repo.migrate();
+    await repo.upsertWorkspace({
+      workspace_id: "ws-context-pack",
+      tenant_id: "tenant-context-pack",
+      name: "context-pack",
+      project_root_path: "/workspace/context-pack"
+    });
+
+    const cache = new InMemoryQueryCache();
+    const core = new RetrievalCore(repo, cache, {
+      chunkingConfig: {
+        strategy: "sliding",
+        target_chunk_tokens: 35,
+        chunk_overlap_tokens: 8
+      },
+      scoringConfig: {
+        rerank: {
+          merge_overlapping_chunks_enabled: false
+        }
+      },
+      contextPackingConfig: {
+        enabled: true,
+        max_spans_per_result: 2,
+        max_gap_lines: 90,
+        max_snippet_chars: 3_200,
+        enhancer_snippet_char_limit: 2_200
+      }
+    });
+
+    try {
+      const bridgeNoise = Array.from({ length: 60 }, (_, idx) => `const bridgeNoise${idx} = ${idx};`);
+      await core.indexArtifact({
+        tenant_id: "tenant-context-pack",
+        workspace_id: "ws-context-pack",
+        index_version: "idx-context-pack-v1",
+        files: [
+          {
+            path: "packages/oracle/src/estimator.ts",
+            language: "typescript",
+            content: [
+              "export function computeProbability(marketSignal: number): number {",
+              "  const base = marketSignal * 0.7;",
+              "  const normalized = Math.max(0, Math.min(1, base));",
+              "  return normalized;",
+              "}",
+              "",
+              ...bridgeNoise,
+              "",
+              "export function fetchLlmInputs(llmInputFlow: string[]): string[] {",
+              "  return llmInputFlow.filter(Boolean);",
+              "}"
+            ].join("\n")
+          }
+        ]
+      });
+
+      const retrieval = await core.searchContext({
+        trace_id: "trc-context-pack",
+        tenant_id: "tenant-context-pack",
+        workspace_id: "ws-context-pack",
+        request: {
+          project_root_path: "/workspace/context-pack",
+          query: "computeProbability marketSignal fetchLlmInputs llmInputFlow",
+          top_k: 1
+        }
+      });
+
+      const top = retrieval.results[0];
+      expect(top).toBeDefined();
+      expect(top?.path).toBe("packages/oracle/src/estimator.ts");
+      expect(top?.snippet.includes("computeProbability")).toBe(true);
+      expect(top?.snippet.includes("fetchLlmInputs")).toBe(true);
+      expect(top?.snippet.includes("...")).toBe(true);
+      expect(top?.reason.includes("contextual spans")).toBe(true);
+      expect((top?.end_line ?? 0) - (top?.start_line ?? 0)).toBeGreaterThan(20);
+    } finally {
+      repo.close();
+    }
+  });
+
+  it("adds deterministic truncation metadata marker for broken TS function boundaries when enabled", async () => {
+    const root = await mkdtemp(join(tmpdir(), "rce-snippet-integrity-quality-"));
+    dirs.push(root);
+    const sqlitePath = join(root, "snippet-integrity-quality.sqlite");
+
+    const repo = new SqliteIndexRepository(sqlitePath);
+    await repo.migrate();
+    await repo.upsertWorkspace({
+      workspace_id: "ws-snippet-integrity",
+      tenant_id: "tenant-snippet-integrity",
+      name: "snippet-integrity",
+      project_root_path: "/workspace/snippet-integrity"
+    });
+
+    const cache = new InMemoryQueryCache();
+    const core = new RetrievalCore(repo, cache, {
+      chunkingConfig: {
+        strategy: "sliding",
+        target_chunk_tokens: 35,
+        chunk_overlap_tokens: 8
+      },
+      scoringConfig: {
+        rerank: {
+          merge_overlapping_chunks_enabled: false
+        }
+      },
+      snippetIntegrityConfig: {
+        enabled: true,
+        target_languages: ["typescript"],
+        max_contiguous_gap_lines: 6,
+        marker_template_version: "v1"
+      }
+    });
+
+    try {
+      const body = Array.from(
+        { length: 500 },
+        (_, idx) => `  const checkpoint_${idx} = input + ${idx}; // estimator continuity signal`
+      );
+      await core.indexArtifact({
+        tenant_id: "tenant-snippet-integrity",
+        workspace_id: "ws-snippet-integrity",
+        index_version: "idx-snippet-integrity-v1",
+        files: [
+          {
+            path: "src/estimator.ts",
+            language: "typescript",
+            content: [
+              "export function estimateProbability(input: number): number {",
+              ...body,
+              "  return input;",
+              "}",
+              "",
+              "export function calibrateProbability(input: number): number {",
+              "  return estimateProbability(input + 1);",
+              "}"
+            ].join("\n")
+          }
+        ]
+      });
+
+      const retrieval = await core.searchContext({
+        trace_id: "trc-snippet-integrity",
+        tenant_id: "tenant-snippet-integrity",
+        workspace_id: "ws-snippet-integrity",
+        request: {
+          project_root_path: "/workspace/snippet-integrity",
+          query: "estimateProbability checkpoint_20 checkpoint_430",
+          top_k: 1
+        }
+      });
+
+      expect(() => SearchContextOutputSchema.parse(retrieval)).not.toThrow();
+      const top = retrieval.results[0];
+      expect(top).toBeDefined();
+      expect(top?.path).toBe("src/estimator.ts");
+      const markerLine = top?.snippet.split("\n").find((line) => line.includes("[truncated:v1"));
+      expect(markerLine).toBeDefined();
+      expect(markerLine).toMatch(/symbol=(?!unknown)[A-Za-z_$][\w$]*/);
+      expect(markerLine).toContain("estimated_total_lines=");
+      expect(markerLine).toContain("through_line=");
+      const omittedAfterMatch = markerLine?.match(/omitted_after=(\d+)/);
+      expect(Number.parseInt(omittedAfterMatch?.[1] ?? "0", 10)).toBeGreaterThan(0);
+    } finally {
+      repo.close();
+    }
+  });
+
+  it("repairs contiguous TS snippets before annotation when repair is enabled", async () => {
+    const root = await mkdtemp(join(tmpdir(), "rce-snippet-repair-quality-"));
+    dirs.push(root);
+    const sqlitePath = join(root, "snippet-repair-quality.sqlite");
+
+    const repo = new SqliteIndexRepository(sqlitePath);
+    await repo.migrate();
+    await repo.upsertWorkspace({
+      workspace_id: "ws-snippet-repair",
+      tenant_id: "tenant-snippet-repair",
+      name: "snippet-repair",
+      project_root_path: "/workspace/snippet-repair"
+    });
+
+    const cache = new InMemoryQueryCache();
+    const core = new RetrievalCore(repo, cache, {
+      chunkingConfig: {
+        strategy: "sliding",
+        target_chunk_tokens: 35,
+        chunk_overlap_tokens: 8
+      },
+      scoringConfig: {
+        rerank: {
+          merge_overlapping_chunks_enabled: false
+        }
+      },
+      snippetIntegrityConfig: {
+        enabled: true,
+        target_languages: ["typescript"],
+        max_contiguous_gap_lines: 6,
+        marker_template_version: "v1",
+        repair_enabled: true,
+        repair_max_envelope_lines: 260,
+        repair_max_snippet_chars: 8_000
+      }
+    });
+
+    try {
+      const body = Array.from(
+        { length: 120 },
+        (_, idx) => `  const checkpoint_${idx} = input + ${idx}; // repair continuity signal`
+      );
+      await core.indexArtifact({
+        tenant_id: "tenant-snippet-repair",
+        workspace_id: "ws-snippet-repair",
+        index_version: "idx-snippet-repair-v1",
+        files: [
+          {
+            path: "src/repair.ts",
+            language: "typescript",
+            content: [
+              "export function estimateRepair(input: number): number {",
+              ...body,
+              "  return input;",
+              "}"
+            ].join("\n")
+          }
+        ]
+      });
+
+      const retrieval = await core.searchContext({
+        trace_id: "trc-snippet-repair",
+        tenant_id: "tenant-snippet-repair",
+        workspace_id: "ws-snippet-repair",
+        request: {
+          project_root_path: "/workspace/snippet-repair",
+          query: "estimateRepair checkpoint_10 checkpoint_110",
+          top_k: 1
+        }
+      });
+
+      const top = retrieval.results[0];
+      expect(top).toBeDefined();
+      expect(top?.path).toBe("src/repair.ts");
+      expect(top?.snippet.includes("checkpoint_10")).toBe(true);
+      expect(top?.snippet.includes("checkpoint_110")).toBe(true);
+      expect(top?.snippet.includes("[truncated:v1")).toBe(false);
+      expect((top?.end_line ?? 0) - (top?.start_line ?? 0)).toBeGreaterThan(80);
+    } finally {
+      repo.close();
+    }
+  });
+
+  it("falls back to truncation marker when repair output still exceeds caps", async () => {
+    const root = await mkdtemp(join(tmpdir(), "rce-snippet-repair-fallback-"));
+    dirs.push(root);
+    const sqlitePath = join(root, "snippet-repair-fallback.sqlite");
+
+    const repo = new SqliteIndexRepository(sqlitePath);
+    await repo.migrate();
+    await repo.upsertWorkspace({
+      workspace_id: "ws-snippet-repair-fallback",
+      tenant_id: "tenant-snippet-repair-fallback",
+      name: "snippet-repair-fallback",
+      project_root_path: "/workspace/snippet-repair-fallback"
+    });
+
+    const cache = new InMemoryQueryCache();
+    const core = new RetrievalCore(repo, cache, {
+      chunkingConfig: {
+        strategy: "sliding",
+        target_chunk_tokens: 35,
+        chunk_overlap_tokens: 8
+      },
+      scoringConfig: {
+        rerank: {
+          merge_overlapping_chunks_enabled: false
+        }
+      },
+      snippetIntegrityConfig: {
+        enabled: true,
+        target_languages: ["typescript"],
+        max_contiguous_gap_lines: 6,
+        marker_template_version: "v1",
+        repair_enabled: true,
+        repair_max_envelope_lines: 260,
+        repair_max_snippet_chars: 220
+      }
+    });
+
+    try {
+      const body = Array.from(
+        { length: 120 },
+        (_, idx) => `  const checkpoint_${idx} = input + ${idx}; // repair fallback signal`
+      );
+      await core.indexArtifact({
+        tenant_id: "tenant-snippet-repair-fallback",
+        workspace_id: "ws-snippet-repair-fallback",
+        index_version: "idx-snippet-repair-fallback-v1",
+        files: [
+          {
+            path: "src/repair-fallback.ts",
+            language: "typescript",
+            content: [
+              "export function estimateRepairFallback(input: number): number {",
+              ...body,
+              "  return input;",
+              "}"
+            ].join("\n")
+          }
+        ]
+      });
+
+      const retrieval = await core.searchContext({
+        trace_id: "trc-snippet-repair-fallback",
+        tenant_id: "tenant-snippet-repair-fallback",
+        workspace_id: "ws-snippet-repair-fallback",
+        request: {
+          project_root_path: "/workspace/snippet-repair-fallback",
+          query: "estimateRepairFallback checkpoint_10 checkpoint_110",
+          top_k: 1
+        }
+      });
+
+      const top = retrieval.results[0];
+      expect(top).toBeDefined();
+      expect(top?.path).toBe("src/repair-fallback.ts");
+      expect(top?.snippet.includes("[truncated:v1")).toBe(true);
+    } finally {
+      repo.close();
+    }
+  });
+
+  it("does not add truncation marker for non-target languages", async () => {
+    const root = await mkdtemp(join(tmpdir(), "rce-snippet-integrity-language-gate-"));
+    dirs.push(root);
+    const sqlitePath = join(root, "snippet-integrity-language-gate.sqlite");
+
+    const repo = new SqliteIndexRepository(sqlitePath);
+    await repo.migrate();
+    await repo.upsertWorkspace({
+      workspace_id: "ws-snippet-language-gate",
+      tenant_id: "tenant-snippet-language-gate",
+      name: "snippet-language-gate",
+      project_root_path: "/workspace/snippet-language-gate"
+    });
+
+    const cache = new InMemoryQueryCache();
+    const core = new RetrievalCore(repo, cache, {
+      chunkingConfig: {
+        strategy: "language_aware",
+        target_chunk_tokens: 40,
+        chunk_overlap_tokens: 8,
+        enabled_languages: ["go"]
+      },
+      snippetIntegrityConfig: {
+        enabled: true,
+        target_languages: ["typescript"],
+        max_contiguous_gap_lines: 6,
+        marker_template_version: "v1"
+      }
+    });
+
+    try {
+      const steps = Array.from({ length: 220 }, (_, idx) => `\ttotal += input + ${idx}`);
+      await core.indexArtifact({
+        tenant_id: "tenant-snippet-language-gate",
+        workspace_id: "ws-snippet-language-gate",
+        index_version: "idx-snippet-language-gate-v1",
+        files: [
+          {
+            path: "pkg/runtime/estimate.go",
+            language: "go",
+            content: [
+              "package runtime",
+              "",
+              "func EstimateProbability(input int) int {",
+              "\ttotal := 0",
+              ...steps,
+              "\treturn total",
+              "}"
+            ].join("\n")
+          }
+        ]
+      });
+
+      const retrieval = await core.searchContext({
+        trace_id: "trc-snippet-language-gate",
+        tenant_id: "tenant-snippet-language-gate",
+        workspace_id: "ws-snippet-language-gate",
+        request: {
+          project_root_path: "/workspace/snippet-language-gate",
+          query: "EstimateProbability input 200",
+          top_k: 1
+        }
+      });
+
+      const top = retrieval.results[0];
+      expect(top).toBeDefined();
+      expect(top?.path).toBe("pkg/runtime/estimate.go");
+      expect(top?.snippet.includes("[truncated:v1")).toBe(false);
+    } finally {
+      repo.close();
+    }
+  });
 });