@danielblomma/cortex-mcp 2.2.5 → 2.4.0

package/scaffold/mcp/tests/enterprise-pattern-context.test.mjs

@@ -0,0 +1,322 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { execFileSync } from "node:child_process";
+import {
+  buildPatternReviewContext,
+  createLocalPatternRunner,
+  PATTERN_REVIEW_QUESTION,
+} from "../dist/enterprise/reviews/pattern-context.js";
+import {
+  buildContextReviewAuditInput,
+  registerEnterpriseTools,
+} from "../dist/enterprise/tools/enterprise.js";
+
+function evidence(overrides = {}) {
+  return {
+    query: "error handling",
+    query_source: "explicit",
+    local_pattern_found: false,
+    fallback_used: false,
+    evidence_order: ["same_file", "same_module", "same_feature_area", "repo_wide"],
+    tiers: [
+      { name: "same_file", evidence: [] },
+      { name: "same_module", evidence: [] },
+      { name: "same_feature_area", evidence: [] },
+      { name: "repo_wide", evidence: [] },
+    ],
+    ...overrides,
+  };
+}
+
+test("composes deterministic non-blocking pattern context without inventing pass or fail", async () => {
+  const runner = async ({ target }) => {
+    if (target === "missing.ts") {
+      throw new Error("Pattern target was not found in indexed context: /private/repo/missing.ts");
+    }
+    if (target === "error.ts") {
+      throw new Error("secret internal stack detail");
+    }
+    if (target === "a.ts") {
+      return evidence({
+        local_pattern_found: true,
+        tiers: [
+          {
+            name: "same_file",
+            evidence: [{ id: "chunk:a", path: "a.ts", start_line: 2, end_line: 8 }],
+          },
+        ],
+      });
+    }
+    if (target === "b.ts") {
+      return evidence({
+        fallback_used: true,
+        tiers: [
+          {
+            name: "repo_wide",
+            evidence: [{ id: "file:docs/review.md", path: "docs/review.md" }],
+          },
+        ],
+      });
+    }
+    return evidence();
+  };
+
+  const result = await buildPatternReviewContext({
+    files: ["z.ts", "a.ts", "b.ts", "a.ts", "../secret.ts", "c.ts", "missing.ts", "error.ts"],
+    enabled: true,
+    query: "error handling",
+    topK: 2,
+    limit: 10,
+    runner,
+  });
+
+  assert.equal(result.enabled, true);
+  assert.equal(result.non_blocking, true);
+  assert.equal(result.affects_policy_summary, false);
+  assert.equal(result.review_question, PATTERN_REVIEW_QUESTION);
+  assert.deepEqual(result.targets.map((target) => target.path), [
+    "a.ts",
+    "b.ts",
+    "c.ts",
+    "error.ts",
+    "missing.ts",
+    "z.ts",
+  ]);
+  assert.deepEqual(result.targets.map((target) => target.status), [
+    "local_evidence",
+    "repo_fallback",
+    "no_evidence",
+    "error",
+    "not_indexed",
+    "no_evidence",
+  ]);
+  assert.equal(result.targets[0].tiers[0].evidence[0].start_line, 2);
+  assert.equal(result.targets[3].message, "Pattern evidence could not be produced for this target.");
+  assert.equal(result.targets[3].local_pattern_found, false);
+  assert.equal(result.targets[3].fallback_used, false);
+  assert.equal(result.targets[3].tiers.length, 4);
+  assert.equal(result.targets[4].query, "error handling");
+  const targetKeys = Object.keys(result.targets[0]).sort();
+  for (const target of result.targets) {
+    assert.deepEqual(Object.keys(target).sort(), targetKeys);
+  }
+  assert.doesNotMatch(JSON.stringify(result), /secret internal stack detail|\/private\/repo/u);
+  assert.deepEqual(result.summary, {
+    requested: 8,
+    eligible: 6,
+    analyzed: 6,
+    local_evidence: 1,
+    repo_fallback: 1,
+    no_evidence: 2,
+    not_indexed: 1,
+    errors: 1,
+    omitted: 0,
+    invalid_paths: 1,
+  });
+});
+
+test("sanitizes runtime warnings and unsafe citation paths", async () => {
+  const result = await buildPatternReviewContext({
+    files: ["src/a.ts"],
+    enabled: true,
+    topK: 5,
+    limit: 1,
+    runner: async () => evidence({
+      warning: "model cache failed at /Users/alice/private/model and C:\\Users\\alice\\model",
+      tiers: [
+        {
+          name: "same_file",
+          evidence: [
+            { id: "chunk:src/a.ts:run", path: "src/a.ts", start_line: 1, end_line: 3 },
+            { id: "chunk:/Users/alice/private", path: "/Users/alice/private/a.ts" },
+            { id: "chunk:C:/Users/alice/private", path: "C:\\Users\\alice\\private\\a.ts" },
+            { id: "chunk:../secret", path: "../secret.ts" },
+          ],
+        },
+      ],
+    }),
+  });
+
+  assert.equal(result.targets[0].status, "local_evidence");
+  assert.equal(result.targets[0].tiers[0].evidence.length, 1);
+  assert.equal(result.targets[0].citations_dropped, 3);
+  assert.equal(result.targets[0].warning, "Pattern evidence completed with local runtime warnings.");
+  assert.doesNotMatch(JSON.stringify(result), /Users[\\/]alice|\.\.\/secret/u);
+});
+
+test("audit projection records query size but not query text", () => {
+  const input = buildContextReviewAuditInput({
+    scope: "changed",
+    include_passed: true,
+    include_pattern_evidence: true,
+    pattern_query: "SECRET_API_KEY=do-not-retain",
+    pattern_top_k: 2,
+    pattern_limit: 10,
+  });
+
+  assert.equal(input.pattern_query_present, true);
+  assert.equal(input.pattern_query_length, 28);
+  assert.equal("pattern_query" in input, false);
+  assert.doesNotMatch(JSON.stringify(input), /SECRET_API_KEY/u);
+});
+
+test("bounds review targets after normalized deterministic ordering", async () => {
+  const calls = [];
+  const result = await buildPatternReviewContext({
+    files: ["z.ts", "./b.ts", "a.ts", "b.ts"],
+    enabled: true,
+    topK: 1,
+    limit: 2,
+    runner: async ({ target }) => {
+      calls.push(target);
+      return evidence();
+    },
+  });
+
+  assert.deepEqual(calls, ["a.ts", "b.ts"]);
+  assert.equal(result.summary.requested, 4);
+  assert.equal(result.summary.eligible, 3);
+  assert.equal(result.summary.analyzed, 2);
+  assert.equal(result.summary.omitted, 1);
+});
+
+test("default local pattern runner loads context data once across targets", async () => {
+  const document = (id, filePath) => ({
+    id,
+    path: filePath,
+    kind: "CODE",
+    updated_at: "2026-07-12T00:00:00.000Z",
+    source_of_truth: false,
+    trust_level: 60,
+    status: "active",
+    excerpt: "export const value = 1;",
+    content: "export const value = 1;",
+  });
+  const data = {
+    documents: [document("file:src/a.ts", "src/a.ts"), document("file:src/b.ts", "src/b.ts")],
+    chunks: [],
+    rules: [],
+    adrs: [],
+    modules: [],
+    projects: [],
+    relations: [],
+    ranking: { semantic: 0.4, graph: 0.25, trust: 0.2, recency: 0.15 },
+    source: "cache",
+  };
+  let loads = 0;
+  const runner = createLocalPatternRunner(async () => {
+    loads += 1;
+    return data;
+  });
+
+  await runner({ target: "src/a.ts", top_k: 1 });
+  await runner({ target: "src/b.ts", top_k: 1 });
+
+  assert.equal(loads, 1);
+});
+
+test("disabled mode does not invoke pattern retrieval", async () => {
+  let called = false;
+  const result = await buildPatternReviewContext({
+    files: ["a.ts", "b.ts"],
+    enabled: false,
+    topK: 2,
+    limit: 10,
+    runner: async () => {
+      called = true;
+      return evidence();
+    },
+  });
+
+  assert.equal(called, false);
+  assert.equal(result.enabled, false);
+  assert.equal(result.affects_policy_summary, false);
+  assert.equal(result.summary.requested, 2);
+  assert.deepEqual(result.targets, []);
+});
+
+test("context.review includes pattern context without changing validator summary", async () => {
+  const projectRoot = fs.mkdtempSync(path.join(os.tmpdir(), "cortex-pattern-review-tool-"));
+  const contextDir = path.join(projectRoot, ".context");
+  const previousProjectRoot = process.env.CORTEX_PROJECT_ROOT;
+  fs.mkdirSync(path.join(projectRoot, "src"), { recursive: true });
+  fs.writeFileSync(path.join(projectRoot, ".gitignore"), ".context/\nignored.ts\n", "utf8");
+  execFileSync("git", ["init"], { cwd: projectRoot, stdio: "ignore" });
+  execFileSync("git", ["add", ".gitignore"], { cwd: projectRoot, stdio: "ignore" });
+  execFileSync("git", ["-c", "user.name=Cortex Test", "-c", "user.email=cortex@example.invalid", "commit", "-m", "fixture"], {
+    cwd: projectRoot,
+    stdio: "ignore",
+  });
+  fs.mkdirSync(contextDir, { recursive: true });
+  fs.writeFileSync(path.join(projectRoot, "src", "new-file.ts"), "export const value = 1;\n", "utf8");
+  fs.writeFileSync(path.join(projectRoot, "ignored.ts"), "ignored\n", "utf8");
+  process.env.CORTEX_PROJECT_ROOT = projectRoot;
+
+  try {
+    const tools = new Map();
+    const server = {
+      registerTool(name, definition, handler) {
+        tools.set(name, { definition, handler });
+      },
+    };
+    const config = {
+      enterprise: { endpoint: "", api_key: "", base_url: "" },
+      telemetry: { enabled: false, endpoint: "", api_key: "", interval_minutes: 10 },
+      audit: { enabled: false, retention_days: 90 },
+      policy: { enabled: false, endpoint: "", api_key: "", sync_interval_minutes: 240 },
+      rbac: { enabled: false, default_role: "developer" },
+      validators: {},
+      compliance: { frameworks: [], eu_addons: false },
+      govern: {
+        mode: "off",
+        sync_on_startup: false,
+        sync_interval_minutes: 60,
+        tier_claude: "prevent",
+        tier_codex: "prevent",
+        tier_copilot: "wrap",
+        detect_ungoverned: false,
+        govern_endpoint: "",
+      },
+    };
+    registerEnterpriseTools(
+      server,
+      {},
+      null,
+      config,
+      contextDir,
+      { getMergedPolicies: () => [] },
+      "2.3.0",
+    );
+
+    const reviewTool = tools.get("context.review");
+    assert.ok(reviewTool);
+    const result = await reviewTool.handler({
+      scope: "changed",
+      include_passed: true,
+    });
+    const output = result.structuredContent;
+
+    assert.equal(output.summary.total, 0);
+    assert.equal("pattern_analyzed" in output.summary, false);
+    assert.equal(output.pattern_review.enabled, true);
+    assert.equal(output.pattern_review.affects_policy_summary, false);
+    assert.equal(output.pattern_review.limit, 10);
+    assert.equal(output.pattern_review.top_k_per_tier, 2);
+    assert.equal(output.pattern_review.summary.analyzed, 1);
+    assert.equal(output.pattern_review.targets[0].path, "src/new-file.ts");
+    assert.equal(output.pattern_review.targets[0].status, "not_indexed");
+    assert.equal(output.pattern_review.targets[0].local_pattern_found, false);
+    assert.equal(output.pattern_review.targets[0].fallback_used, false);
+    assert.equal(output.pattern_review.targets[0].tiers.length, 4);
+  } finally {
+    if (previousProjectRoot === undefined) {
+      delete process.env.CORTEX_PROJECT_ROOT;
+    } else {
+      process.env.CORTEX_PROJECT_ROOT = previousProjectRoot;
+    }
+    fs.rmSync(projectRoot, { recursive: true, force: true });
+  }
+});

package/scaffold/mcp/tests/paths.test.mjs

@@ -4,13 +4,15 @@ import { mkdtempSync, mkdirSync, realpathSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import path from "node:path";
 import { spawnSync } from "node:child_process";
-import { pathToFileURL } from "node:url";
+import { fileURLToPath, pathToFileURL } from "node:url";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
 
 test("paths resolve the project root from cwd without duplicating .context", () => {
   const projectRoot = mkdtempSync(path.join(tmpdir(), "cortex-paths-"));
   const contextDir = path.join(projectRoot, ".context");
   const mcpDir = path.join(contextDir, "mcp");
-  const pathsModuleUrl = pathToFileURL(path.resolve("dist/paths.js")).href;
+  const pathsModuleUrl = pathToFileURL(path.resolve(__dirname, "..", "dist", "paths.js")).href;
 
   mkdirSync(mcpDir, { recursive: true });
   writeFileSync(path.join(contextDir, "config.yaml"), "source_paths:\n  - src\n");
@@ -20,7 +22,7 @@ test("paths resolve the project root from cwd without duplicating .context", ()
     [
       "--input-type=module",
       "-e",
-      `import { REPO_ROOT, CONTEXT_DIR, CACHE_DIR } from ${JSON.stringify(pathsModuleUrl)}; console.log(JSON.stringify({ REPO_ROOT, CONTEXT_DIR, CACHE_DIR }));`
+      `import { REPO_ROOT, CONTEXT_DIR, CACHE_DIR, DEFAULT_RANKING } from ${JSON.stringify(pathsModuleUrl)}; console.log(JSON.stringify({ REPO_ROOT, CONTEXT_DIR, CACHE_DIR, DEFAULT_RANKING }));`
     ],
     {
       cwd: mcpDir,
@@ -35,4 +37,10 @@ test("paths resolve the project root from cwd without duplicating .context", ()
   assert.equal(parsed.REPO_ROOT, resolvedProjectRoot);
   assert.equal(parsed.CONTEXT_DIR, path.join(resolvedProjectRoot, ".context"));
   assert.equal(parsed.CACHE_DIR, path.join(resolvedProjectRoot, ".context", "cache"));
+  assert.deepEqual(parsed.DEFAULT_RANKING, {
+    semantic: 0.4,
+    graph: 0.25,
+    trust: 0.2,
+    recency: 0.15
+  });
 });

package/scaffold/mcp/tests/pattern-evidence.test.mjs

@@ -0,0 +1,321 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import {
+  classifyPatternEvidence,
+  contextReferenceTimeMs,
+  runLocalPatternEvidence,
+  runPatternEvidence,
+} from "../dist/patternEvidence.js";
+
+function chunk(id, fileId, startLine, endLine) {
+  return {
+    id,
+    file_id: fileId,
+    name: id,
+    kind: "function",
+    signature: "",
+    body: "",
+    description: "",
+    start_line: startLine,
+    end_line: endLine,
+    language: "typescript",
+    exported: false,
+    updated_at: "2026-07-12T00:00:00.000Z",
+    source_of_truth: false,
+    trust_level: 60,
+    status: "active",
+  };
+}
+
+function document(id, filePath, kind, content = "") {
+  return {
+    id,
+    path: filePath,
+    kind,
+    updated_at: "2026-07-12T00:00:00.000Z",
+    source_of_truth: false,
+    trust_level: kind === "DOC" ? 80 : 60,
+    status: "active",
+    excerpt: content,
+    content,
+  };
+}
+
+function contextData({ documents, chunks = [] }) {
+  return {
+    documents,
+    chunks,
+    rules: [],
+    adrs: [],
+    modules: [],
+    projects: [],
+    relations: [],
+    ranking: { semantic: 0.4, graph: 0.25, trust: 0.2, recency: 0.15 },
+    source: "cache",
+  };
+}
+
+test("classifies helper, error, and config evidence in local-first order with line citations", () => {
+  const target = {
+    input: "src/features/auth/controller.ts",
+    entity_id: "file:src/features/auth/controller.ts",
+    entity_type: "File",
+    path: "src/features/auth/controller.ts",
+  };
+  const results = [
+    {
+      id: target.entity_id,
+      entity_type: "File",
+      kind: "CODE",
+      title: target.path,
+      path: target.path,
+      excerpt: "target must not cite itself",
+      score: 0.99,
+    },
+    {
+      id: "chunk:helper",
+      entity_type: "Chunk",
+      kind: "function",
+      title: "normalizeUser",
+      path: "src\\features\\auth\\controller.ts",
+      excerpt: "file-local helper shape",
+      score: 0.9,
+      matched_rules: ["rule.repo_local_pattern_review", "rule.repo_local_pattern_review"],
+    },
+    {
+      id: "chunk:error",
+      entity_type: "Chunk",
+      kind: "function",
+      title: "toAuthError",
+      path: "src/features/auth/errors.ts",
+      excerpt: "module-local error handling",
+      score: 0.8,
+    },
+    {
+      id: "chunk:config",
+      entity_type: "Chunk",
+      kind: "function",
+      title: "parseFeatureEnv",
+      path: "src/features/config/env.ts",
+      excerpt: "feature-local config parsing",
+      score: 0.7,
+    },
+    {
+      id: "file:docs/conventions.md",
+      entity_type: "File",
+      kind: "DOC",
+      title: "docs/conventions.md",
+      path: "docs/conventions.md",
+      excerpt: "repository fallback",
+      score: 0.6,
+    },
+  ];
+  const chunks = [
+    chunk("chunk:helper", "file:src/features/auth/controller.ts", 10, 18),
+    chunk("chunk:error", "file:src/features/auth/errors.ts", 4, 12),
+    chunk("chunk:config", "file:src/features/config/env.ts", 20, 31),
+  ];
+
+  const classified = classifyPatternEvidence({ target, results, chunks, topK: 3 });
+
+  assert.deepEqual(classified.tiers.map((tier) => tier.name), [
+    "same_file",
+    "same_module",
+    "same_feature_area",
+    "repo_wide",
+  ]);
+  assert.deepEqual(classified.tiers.map((tier) => tier.evidence.map((item) => item.id)), [
+    ["chunk:helper"],
+    ["chunk:error"],
+    ["chunk:config"],
+    ["file:docs/conventions.md"],
+  ]);
+  assert.equal(classified.tiers[0].evidence[0].path, "src/features/auth/controller.ts");
+  assert.equal(classified.tiers[0].evidence[0].start_line, 10);
+  assert.equal(classified.tiers[0].evidence[0].end_line, 18);
+  assert.deepEqual(classified.tiers[0].evidence[0].matched_rules, ["rule.repo_local_pattern_review"]);
+  assert.equal(classified.localPatternFound, true);
+  assert.equal(classified.fallbackUsed, false);
+});
+
+test("reports repository fallback without claiming a local pattern", () => {
+  const classified = classifyPatternEvidence({
+    target: {
+      input: "src/isolated.ts",
+      entity_id: "file:src/isolated.ts",
+      entity_type: "File",
+      path: "src/isolated.ts",
+    },
+    results: [
+      {
+        id: "file:docs/general-practices.md",
+        entity_type: "File",
+        kind: "DOC",
+        title: "docs/general-practices.md",
+        path: "docs/general-practices.md",
+        excerpt: "general fallback only",
+      },
+    ],
+    chunks: [],
+    topK: 3,
+  });
+
+  assert.equal(classified.localPatternFound, false);
+  assert.equal(classified.fallbackUsed, true);
+  assert.deepEqual(classified.tiers.slice(0, 3).flatMap((tier) => tier.evidence), []);
+  assert.equal(classified.tiers[3].evidence.length, 1);
+});
+
+test("filters chunk evidence when indexed line bounds are missing or invalid", () => {
+  const target = {
+    input: "src/a.ts",
+    entity_id: "file:src/a.ts",
+    entity_type: "File",
+    path: "src/a.ts",
+  };
+  const results = [
+    {
+      id: "chunk:missing",
+      entity_type: "Chunk",
+      kind: "function",
+      title: "missing",
+      path: "src/b.ts",
+      excerpt: "missing metadata",
+    },
+    {
+      id: "chunk:invalid",
+      entity_type: "Chunk",
+      kind: "function",
+      title: "invalid",
+      path: "src/c.ts",
+      excerpt: "invalid metadata",
+    },
+  ];
+
+  const classified = classifyPatternEvidence({
+    target,
+    results,
+    chunks: [chunk("chunk:invalid", "file:src/c.ts", 0, 0)],
+    topK: 3,
+  });
+
+  assert.deepEqual(classified.tiers.flatMap((tier) => tier.evidence), []);
+  assert.equal(classified.localPatternFound, false);
+  assert.equal(classified.fallbackUsed, false);
+});
+
+test("retrieves each locality tier before cutoff and stays deterministic", async () => {
+  const target = document("file:src/auth/handler.ts", "src/auth/handler.ts", "CODE");
+  const localFile = document("file:src/auth/config.ts", "src/auth/config.ts", "CODE");
+  const localChunk = {
+    ...chunk("chunk:local-config", localFile.id, 7, 14),
+    name: "parseLocalSetting",
+    body: "environment",
+    description: "module-local environment parsing",
+  };
+  const repoDocuments = Array.from({ length: 60 }, (_, index) =>
+    document(
+      `file:docs/pattern-${index}.md`,
+      `docs/pattern-${index}.md`,
+      "DOC",
+      "environment variable parsing configuration pattern",
+    ));
+  const data = contextData({ documents: [target, localFile, ...repoDocuments], chunks: [localChunk] });
+  const input = {
+    target: target.path,
+    query: "environment variable parsing configuration pattern",
+    top_k: 2,
+    include_deprecated: false,
+  };
+
+  const first = await runPatternEvidence(input, { data });
+  const second = await runPatternEvidence(input, { data });
+  const moduleTier = first.tiers.find((tier) => tier.name === "same_module");
+
+  assert.ok(moduleTier.evidence.some((evidence) => evidence.id === localChunk.id));
+  assert.equal(first.local_pattern_found, true);
+  assert.equal(first.ranking_reference_time, "2026-07-12T00:00:00.000Z");
+  assert.deepEqual(second, first);
+});
+
+test("runtime response exposes repository-only fallback and warning", async () => {
+  const target = document("file:src/isolated.ts", "src/isolated.ts", "CODE");
+  const fallback = document(
+    "file:docs/general-practices.md",
+    "docs/general-practices.md",
+    "DOC",
+    "general retry convention",
+  );
+  const result = await runPatternEvidence({
+    target: target.path,
+    query: "general retry convention",
+    top_k: 2,
+    include_deprecated: false,
+  }, {
+    data: contextData({ documents: [target, fallback] }),
+  });
+
+  assert.equal(result.local_pattern_found, false);
+  assert.equal(result.fallback_used, true);
+  assert.match(result.warning, /No applicable file-local, module-local, or feature-local pattern/);
+  assert.equal(result.tiers[3].evidence[0].id, fallback.id);
+});
+
+test("reference time calculation stays bounded for large indexes", () => {
+  const documents = Array.from({ length: 200_000 }, (_, index) => ({
+    updated_at: index === 199_999 ? "2026-07-13T00:00:00.000Z" : "2026-07-12T00:00:00.000Z",
+  }));
+  const data = contextData({ documents });
+
+  assert.equal(contextReferenceTimeMs(data), Date.parse("2026-07-13T00:00:00.000Z"));
+});
+
+test("equal-score evidence is stable across reversed source order", async () => {
+  const target = document("file:src/isolated.ts", "src/isolated.ts", "CODE");
+  const a = document("file:docs/a.md", "docs/a.md", "DOC", "shared convention");
+  const b = document("file:docs/b.md", "docs/b.md", "DOC", "shared convention");
+  const input = {
+    target: target.path,
+    query: "shared convention",
+    top_k: 1,
+    include_deprecated: false,
+  };
+
+  const forward = await runPatternEvidence(input, {
+    data: contextData({ documents: [target, a, b] }),
+  });
+  const reversed = await runPatternEvidence(input, {
+    data: contextData({ documents: [target, b, a] }),
+  });
+
+  assert.deepEqual(reversed, forward);
+  assert.equal(forward.tiers[3].evidence[0].id, a.id);
+});
+
+test("local-only pattern evidence uses lexical search without network fetch", async () => {
+  const target = document("file:src/a.ts", "src/a.ts", "CODE");
+  const fallback = document("file:docs/pattern.md", "docs/pattern.md", "DOC", "shared retry convention");
+  const originalFetch = globalThis.fetch;
+  let fetchCalls = 0;
+  globalThis.fetch = async () => {
+    fetchCalls += 1;
+    throw new Error("network access is forbidden in local review");
+  };
+
+  try {
+    const result = await runLocalPatternEvidence({
+      target: target.path,
+      query: "shared retry convention",
+      top_k: 1,
+      include_deprecated: false,
+    }, {
+      data: contextData({ documents: [target, fallback] }),
+    });
+
+    assert.equal(fetchCalls, 0);
+    assert.equal(result.semantic_engine, "lexical-only");
+    assert.equal(result.fallback_used, true);
+  } finally {
+    globalThis.fetch = originalFetch;
+  }
+});