recallnest 3.0.0 → 3.0.1

package/src/__tests__/query-entity-detector.test.ts

@@ -1,171 +0,0 @@
-import { describe, expect, it } from "bun:test";
-import { detectEntitiesSync, detectEntities } from "../query-entity-detector.js";
-
-// ============================================================================
-// Sync detection (no KG validation)
-// ============================================================================
-
-describe("detectEntitiesSync", () => {
-  describe("English entity extraction", () => {
-    it("extracts capitalized names", () => {
-      const result = detectEntitiesSync("What does Alice use?");
-      expect(result.entities).toContain("Alice");
-    });
-
-    it("extracts multi-word capitalized names", () => {
-      const result = detectEntitiesSync("Tell me about Claude Code");
-      expect(result.entities).toContain("Claude Code");
-    });
-
-    it("extracts CamelCase identifiers (normalized to title case)", () => {
-      const result = detectEntitiesSync("How does RecallNest work?");
-      // normalizeEntity applies title case: RecallNest -> Recallnest
-      expect(result.entities).toContain("Recallnest");
-    });
-
-    it("extracts quoted strings (normalized to title case)", () => {
-      const result = detectEntitiesSync('Search for "LanceDB" docs');
-      expect(result.entities).toContain("Lancedb");
-    });
-
-    it("extracts backtick-quoted strings (normalized to title case)", () => {
-      const result = detectEntitiesSync("What is `OpenAI` embedding?");
-      expect(result.entities).toContain("Openai");
-    });
-
-    it("skips stop words even when capitalized", () => {
-      const result = detectEntitiesSync("The quick brown fox");
-      // "The" should be filtered as stop word
-      expect(result.entities).not.toContain("The");
-    });
-
-    it("deduplicates entities (case-insensitive)", () => {
-      const result = detectEntitiesSync('Alice uses "alice" tool');
-      // Should have only one Alice entry
-      const aliceCount = result.entities.filter(e => e.toLowerCase() === "alice").length;
-      expect(aliceCount).toBe(1);
-    });
-
-    it("returns empty for queries without entities", () => {
-      const result = detectEntitiesSync("what happened yesterday?");
-      expect(result.entities.length).toBe(0);
-    });
-  });
-
-  describe("multi-hop detection — English", () => {
-    it("detects possessive friend pattern", () => {
-      const result = detectEntitiesSync("Alice's friends");
-      expect(result.isMultiHop).toBe(true);
-      expect(result.hopPredicate).toBe("friend_of");
-    });
-
-    it("detects 'friend of' pattern", () => {
-      const result = detectEntitiesSync("friends of Bob");
-      expect(result.isMultiHop).toBe(true);
-      expect(result.hopPredicate).toBe("friend_of");
-    });
-
-    it("detects 'what does X use' pattern", () => {
-      const result = detectEntitiesSync("what does Alice use?");
-      expect(result.isMultiHop).toBe(true);
-      expect(result.hopPredicate).toBe("uses");
-    });
-
-    it("detects 'who created' pattern", () => {
-      const result = detectEntitiesSync("who created RecallNest?");
-      expect(result.isMultiHop).toBe(true);
-      expect(result.hopPredicate).toBe("created_by");
-    });
-
-    it("detects 'who manages' pattern", () => {
-      const result = detectEntitiesSync("who manages the team?");
-      expect(result.isMultiHop).toBe(true);
-      expect(result.hopPredicate).toBe("manages");
-    });
-
-    it("detects 'X depends on' pattern", () => {
-      const result = detectEntitiesSync("what depends on LanceDB?");
-      expect(result.isMultiHop).toBe(true);
-      expect(result.hopPredicate).toBe("depends_on");
-    });
-
-    it("returns isMultiHop=false for simple queries", () => {
-      const result = detectEntitiesSync("Tell me about Python");
-      expect(result.isMultiHop).toBe(false);
-      expect(result.hopPredicate).toBeUndefined();
-    });
-  });
-
-  describe("multi-hop detection — Chinese", () => {
-    it("detects 的朋友 pattern", () => {
-      const result = detectEntitiesSync("Alice的朋友有谁？");
-      expect(result.isMultiHop).toBe(true);
-      expect(result.hopPredicate).toBe("friend_of");
-    });
-
-    it("detects 谁和X一起 pattern", () => {
-      const result = detectEntitiesSync("谁和Bob一起工作？");
-      expect(result.isMultiHop).toBe(true);
-      expect(result.hopPredicate).toBe("works_with");
-    });
-
-    it("detects 谁创建了 pattern", () => {
-      const result = detectEntitiesSync("谁创建了RecallNest？");
-      expect(result.isMultiHop).toBe(true);
-      expect(result.hopPredicate).toBe("created_by");
-    });
-
-    it("detects 依赖什么 pattern", () => {
-      const result = detectEntitiesSync("RecallNest依赖什么？");
-      expect(result.isMultiHop).toBe(true);
-      expect(result.hopPredicate).toBe("depends_on");
-    });
-  });
-});
-
-// ============================================================================
-// Async detection with KG validation
-// ============================================================================
-
-describe("detectEntities (async with mock KG)", () => {
-  function createMockKGStore(knownEntities: string[]) {
-    return {
-      async getAllEntities() {
-        return knownEntities;
-      },
-    } as any;
-  }
-
-  it("validates entities against KG", async () => {
-    const kgStore = createMockKGStore(["Alice", "Python", "LanceDB"]);
-    const result = await detectEntities("Alice uses Python and React", kgStore);
-
-    // Alice and Python are in KG, React is not
-    expect(result.entities).toContain("Alice");
-    expect(result.entities).toContain("Python");
-    expect(result.entities).not.toContain("React");
-  });
-
-  it("falls back to heuristic when KG validates nothing", async () => {
-    const kgStore = createMockKGStore([]); // empty KG
-    const result = await detectEntities("Alice uses Python", kgStore);
-
-    // Should fall back to heuristic candidates
-    expect(result.entities).toContain("Alice");
-    expect(result.entities).toContain("Python");
-  });
-
-  it("preserves KG canonical casing", async () => {
-    const kgStore = createMockKGStore(["alice"]); // lowercase in KG
-    const result = await detectEntities("Tell me about Alice", kgStore);
-
-    // Should use KG's casing
-    expect(result.entities).toContain("alice");
-  });
-
-  it("works without KG store", async () => {
-    const result = await detectEntities("Alice uses Python");
-    expect(result.entities).toContain("Alice");
-    expect(result.entities).toContain("Python");
-  });
-});

package/src/__tests__/query-expander-alias.test.ts

@@ -1,146 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from "bun:test";
-import { expandQuery, setAliasMapPath, resetAliasMapCache, upsertUserAlias, removeUserAlias, listUserAliases, explainUserAliases } from "../query-expander.js";
-import { expandQueryWithAliases, ALIAS_QUERY_MAX_LENGTH } from "../aliases.js";
-import { writeFileSync, unlinkSync, existsSync, mkdirSync } from "fs";
-import { join } from "path";
-
-const TEST_DIR = join(import.meta.dir, "../../.test-data");
-const TEST_ALIAS = join(TEST_DIR, "test-alias-map.json");
-
-function cleanup() {
-  try { if (existsSync(TEST_ALIAS)) unlinkSync(TEST_ALIAS); } catch {}
-}
-
-describe("expandQuery with alias-map", () => {
-  beforeEach(() => {
-    if (!existsSync(TEST_DIR)) mkdirSync(TEST_DIR, { recursive: true });
-    cleanup();
-    resetAliasMapCache();
-  });
-  afterEach(() => {
-    cleanup();
-    resetAliasMapCache();
-  });
-
-  it("expands short query using alias-map", () => {
-    writeFileSync(TEST_ALIAS, JSON.stringify([
-      { trigger: "轮巡", expansions: ["仓库", "patrol", "repo", "每日检查"] },
-    ]));
-    setAliasMapPath(TEST_ALIAS);
-
-    const expanded = expandQuery("轮巡");
-    expect(expanded).toContain("轮巡");
-    expect(expanded).toContain("仓库");
-    expect(expanded).toContain("patrol");
-  });
-
-  it("does not expand when trigger not matched", () => {
-    writeFileSync(TEST_ALIAS, JSON.stringify([
-      { trigger: "轮巡", expansions: ["仓库", "patrol"] },
-    ]));
-    setAliasMapPath(TEST_ALIAS);
-
-    const expanded = expandQuery("部署");
-    // "部署" matches built-in synonym map, but should NOT match alias "轮巡"
-    expect(expanded).not.toContain("patrol");
-  });
-
-  it("works with empty alias-map file", () => {
-    writeFileSync(TEST_ALIAS, "[]");
-    setAliasMapPath(TEST_ALIAS);
-
-    const result = expandQuery("轮巡");
-    // Should still work (only built-in synonyms)
-    expect(result).toContain("轮巡");
-  });
-
-  it("works with missing alias-map file", () => {
-    setAliasMapPath(join(TEST_DIR, "nonexistent.json"));
-
-    const result = expandQuery("轮巡");
-    expect(result).toContain("轮巡");
-  });
-
-  it("skips expansion terms already in query", () => {
-    writeFileSync(TEST_ALIAS, JSON.stringify([
-      { trigger: "轮巡", expansions: ["轮巡", "仓库", "patrol"] },
-    ]));
-    setAliasMapPath(TEST_ALIAS);
-
-    const expanded = expandQuery("轮巡仓库");
-    // "仓库" already in query, should not be duplicated
-    const occurrences = expanded.split("仓库").length - 1;
-    expect(occurrences).toBe(1);
-  });
-
-  it("respects MAX_EXPANSION_TERMS cap", () => {
-    writeFileSync(TEST_ALIAS, JSON.stringify([
-      {
-        trigger: "测试",
-        expansions: ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j"],
-      },
-    ]));
-    setAliasMapPath(TEST_ALIAS);
-
-    const expanded = expandQuery("测试");
-    // Built-in synonyms + alias expansions, but capped at MAX_EXPANSION_TERMS (5)
-    const addedTerms = expanded.replace("测试", "").trim().split(/\s+/);
-    expect(addedTerms.length).toBeLessThanOrEqual(5);
-  });
-});
-
-describe("manage_alias backend (P1-B)", () => {
-  beforeEach(() => {
-    if (!existsSync(TEST_DIR)) mkdirSync(TEST_DIR, { recursive: true });
-    cleanup();
-    setAliasMapPath(TEST_ALIAS);
-    resetAliasMapCache();
-  });
-  afterEach(() => {
-    cleanup();
-    resetAliasMapCache();
-  });
-
-  it("upserts, lists, expands, and removes a user alias", () => {
-    const added = upsertUserAlias("我的桥", ["telegram-ai-bridge", "tg-bridge-channel"]);
-    expect(added.ok).toBe(true);
-    expect(listUserAliases()).toHaveLength(1);
-
-    // 写完即生效(缓存失效),BM25 通道扩展可见
-    const expanded = expandQuery("我的桥怎么挂了");
-    expect(expanded).toContain("telegram-ai-bridge");
-
-    // update 路径
-    const updated = upsertUserAlias("我的桥", ["telegram-ai-bridge"]);
-    expect(updated.ok && updated.action === "updated").toBe(true);
-    expect(listUserAliases()[0].expansions).toEqual(["telegram-ai-bridge"]);
-
-    expect(explainUserAliases("我的桥呢")).toHaveLength(1);
-    expect(removeUserAlias("我的桥")).toBe(true);
-    expect(removeUserAlias("我的桥")).toBe(false);
-    expect(listUserAliases()).toHaveLength(0);
-  });
-
-  it("rejects invalid rules with reasons", () => {
-    const tooShort = upsertUserAlias("桥", ["x-bridge"]);
-    expect(tooShort.ok).toBe(false);
-
-    const tooMany = upsertUserAlias("我的桥", ["a1", "a2", "a3", "a4", "a5", "a6", "a7", "a8", "a9"]);
-    expect(tooMany.ok).toBe(false);
-
-    const selfRef = upsertUserAlias("我的桥", ["我的桥"]);
-    expect(selfRef.ok).toBe(false);
-
-    const empty = upsertUserAlias("我的桥", ["  "]);
-    expect(empty.ok).toBe(false);
-  });
-});
-
-describe("expandQueryWithAliases length gate (P1-B)", () => {
-  it("skips expansion for queries beyond ALIAS_QUERY_MAX_LENGTH", () => {
-    const longQuery = "我的记忆项目".padEnd(ALIAS_QUERY_MAX_LENGTH + 10, "字");
-    expect(expandQueryWithAliases(longQuery)).toBe(longQuery);
-    // 短 query 照常扩展
-    expect(expandQueryWithAliases("我的记忆项目")).toContain("recallnest");
-  });
-});

package/src/__tests__/query-expander.test.ts

@@ -1,34 +0,0 @@
-import { describe, it, expect } from "bun:test";
-import { expandQuery } from "../query-expander.js";
-
-describe("expandQuery", () => {
-  it("expands colloquial Chinese to technical terms", () => {
-    const result = expandQuery("bot 突然挂了");
-    expect(result).toContain("崩溃");
-    expect(result).toContain("crash");
-    expect(result).toContain("挂了");
-  });
-
-  it("expands fuzzy feeling queries", () => {
-    const result = expandQuery("AI 到底有没有感受");
-    expect(result).toContain("意识");
-    expect(result).toContain("consciousness");
-    expect(result).toContain("感受");
-  });
-
-  it("preserves original query terms", () => {
-    const result = expandQuery("配图风格");
-    expect(result).toContain("配图");
-    expect(result).toContain("风格");
-  });
-
-  it("returns original for already-precise queries", () => {
-    const result = expandQuery("JINA_API_KEY");
-    expect(result).toBe("JINA_API_KEY");
-  });
-
-  it("handles empty/short queries", () => {
-    expect(expandQuery("")).toBe("");
-    expect(expandQuery("hi")).toBe("hi");
-  });
-});

package/src/__tests__/recall-gate.test.ts

@@ -1,266 +0,0 @@
-import { afterEach, describe, expect, it } from "bun:test";
-import { existsSync, mkdtempSync, readFileSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-
-import { runAutoRecall } from "../auto-recall.js";
-import {
-  RECALL_GATE_SHADOW_FILE,
-  classifyRecallGate,
-  resolveRecallGateMode,
-  type RecallGateDecision,
-} from "../recall-gate.js";
-import type { RetrievalContext, RetrievalResult } from "../retriever.js";
-
-const savedGateEnv = process.env.RECALLNEST_RECALL_GATE;
-const savedDataDirEnv = process.env.RECALLNEST_DATA_DIR;
-const cleanupPaths: string[] = [];
-
-afterEach(() => {
-  if (savedGateEnv === undefined) delete process.env.RECALLNEST_RECALL_GATE;
-  else process.env.RECALLNEST_RECALL_GATE = savedGateEnv;
-  if (savedDataDirEnv === undefined) delete process.env.RECALLNEST_DATA_DIR;
-  else process.env.RECALLNEST_DATA_DIR = savedDataDirEnv;
-  while (cleanupPaths.length > 0) {
-    const target = cleanupPaths.pop();
-    if (target) rmSync(target, { recursive: true, force: true });
-  }
-});
-
-function tempDataDir(): string {
-  const dir = mkdtempSync(join(tmpdir(), "recallnest-gate-"));
-  cleanupPaths.push(dir);
-  process.env.RECALLNEST_DATA_DIR = dir;
-  return dir;
-}
-
-function expectDecision(message: string, decision: RecallGateDecision, ruleId?: string) {
-  const verdict = classifyRecallGate(message);
-  expect(`${message} → ${verdict.decision}`).toBe(`${message} → ${decision}`);
-  if (ruleId) expect(verdict.ruleId).toBe(ruleId);
-}
-
-describe("classifyRecallGate — verdict matrix", () => {
-  it("force cues win over every short-text rule", () => {
-    expectDecision("可以按上次方案做", "full-recall", "force:memory-cue-zh");
-    expectDecision("记得我说过什么吗", "full-recall");
-    expectDecision("我的偏好是什么", "full-recall");
-    expectDecision("do you remember my setup?", "full-recall", "force:memory-cue-en");
-    expectDecision("what did we discussed last time", "full-recall");
-    // Force cue inside an otherwise long message still labels full-recall.
-    const long = `${"背景介绍。".repeat(20)}上次的结论是什么?`;
-    expectDecision(long, "full-recall");
-  });
-
-  it("whole-message acks skip; acks with real content pass", () => {
-    expectDecision("好的", "skip-all", "skip:ack");
-    expectDecision("好的吧。", "skip-all");
-    expectDecision("嗯嗯", "skip-all");
-    expectDecision("OK", "skip-all");
-    expectDecision("Thanks!", "skip-all");
-    expectDecision("好的 谢谢", "skip-all");
-    expectDecision("收到了哈", "skip-all");
-    expectDecision("好的,先跑测试再说", "pass");
-    expectDecision("可以先做项1", "pass");
-  });
-
-  it("continuity nudges are resume-only; nudge + content passes", () => {
-    expectDecision("继续", "resume-only", "resume:continuity");
-    expectDecision("继续吧", "resume-only");
-    expectDecision("接着来", "resume-only");
-    expectDecision("下一步", "resume-only");
-    expectDecision("开始", "resume-only");
-    expectDecision("开始吧", "resume-only");
-    expectDecision("continue", "resume-only");
-    expectDecision("接着改 auto-recall 的闸", "pass");
-    // "继续讨论上次的方案" carries a force cue → full-recall, not resume-only.
-    expectDecision("继续讨论上次的方案", "full-recall");
-  });
-
-  it("bare CLI invocations skip; CLI words inside prose pass", () => {
-    expectDecision("git push", "skip-all", "skip:cli");
-    expectDecision("npm test", "skip-all");
-    expectDecision("bun test src/__tests__/recall-gate.test.ts", "skip-all");
-    expectDecision("git", "skip-all");
-    expectDecision("git 为什么失败", "pass");
-    expectDecision("why does npm test hang?", "pass");
-    expectDecision("测试之前讨论的方案", "full-recall"); // force cue, not cli
-  });
-
-  it("slash commands and heartbeats skip", () => {
-    expectDecision("/compact", "skip-all", "skip:slash");
-    expectDecision("/goal 写个爬虫", "skip-all");
-    expectDecision("HEARTBEAT_OK", "skip-all", "skip:heartbeat");
-  });
-
-  it("pure emoji skips; bare digits/#/* are NOT emoji", () => {
-    expectDecision("👍", "skip-all", "skip:emoji");
-    expectDecision("👍👍 🎉", "skip-all");
-    expectDecision("🇸🇬", "skip-all");
-    expectDecision("42", "pass");
-    expectDecision("#1", "pass");
-    expectDecision("*", "pass");
-  });
-
-  it("greetings skip as whole messages only", () => {
-    expectDecision("你好", "skip-all", "skip:greeting");
-    expectDecision("早", "skip-all");
-    expectDecision("hello", "skip-all");
-    expectDecision("在吗", "skip-all");
-    expectDecision("你好,帮我查一下部署状态", "pass");
-  });
-
-  it("long messages without force cues always pass", () => {
-    const long = "这条消息足够长,描述了一个具体的问题背景和期望的处理方式,值得走完整的检索管线来补上下文。".repeat(2);
-    expect(long.length).toBeGreaterThan(80);
-    expectDecision(long, "pass", "pass:long");
-  });
-
-  it("empty input degrades to skip:empty", () => {
-    expectDecision("   ", "skip-all", "skip:empty");
-  });
-});
-
-describe("resolveRecallGateMode", () => {
-  it("defaults to observe; parses enforce/off; junk falls back to observe", () => {
-    expect(resolveRecallGateMode({})).toBe("observe");
-    expect(resolveRecallGateMode({ RECALLNEST_RECALL_GATE: "enforce" })).toBe("enforce");
-    expect(resolveRecallGateMode({ RECALLNEST_RECALL_GATE: "OFF" })).toBe("off");
-    expect(resolveRecallGateMode({ RECALLNEST_RECALL_GATE: "banana" })).toBe("observe");
-  });
-});
-
-// --- integration through runAutoRecall ---
-
-function buildResult(id: string, text: string): RetrievalResult {
-  return {
-    entry: {
-      id,
-      text,
-      vector: [],
-      category: "events",
-      scope: "project:gate",
-      importance: 0.8,
-      timestamp: Date.parse("2026-07-01T00:00:00.000Z"),
-      metadata: "{}",
-    },
-    score: 0.9,
-    sources: { fused: { score: 0.9 } },
-  };
-}
-
-function makeDeps() {
-  const calls: RetrievalContext[] = [];
-  return {
-    calls,
-    deps: {
-      retriever: {
-        async retrieve(context: RetrievalContext): Promise<RetrievalResult[]> {
-          calls.push(context);
-          if (!context.category) return [buildResult("hit-1", "focused hit")];
-          return [];
-        },
-      },
-      checkpointStore: { async getLatest() { return null; } },
-      listPins: () => [],
-    },
-  };
-}
-
-describe("runAutoRecall × recall gate", () => {
-  it("observe mode leaves behavior unchanged and appends a shadow entry", async () => {
-    const dir = tempDataDir();
-    const { deps, calls } = makeDeps();
-
-    const response = await runAutoRecall(deps, {
-      message: "好的",
-      scope: "project:gate",
-      operation: "test:gate-observe",
-      env: { RECALLNEST_RECALL_GATE: "observe" } as NodeJS.ProcessEnv,
-    });
-
-    // Unchanged behavior: full resume+search pipeline still ran.
-    expect(response.mode).toBe("resume+search");
-    expect(calls.length).toBeGreaterThan(0);
-    expect(response.results.length).toBe(1);
-
-    const shadowPath = join(dir, RECALL_GATE_SHADOW_FILE);
-    expect(existsSync(shadowPath)).toBe(true);
-    const entry = JSON.parse(readFileSync(shadowPath, "utf8").trim().split("\n")[0] ?? "{}");
-    expect(entry.decision).toBe("skip-all");
-    expect(entry.ruleId).toBe("skip:ack");
-    expect(entry.mode).toBe("observe");
-    expect(entry.msgLen).toBe(2);
-    expect(entry.source).toBe("test:gate-observe");
-    expect(JSON.stringify(entry)).not.toContain("好的"); // never log message text
-  });
-
-  it("enforce + skip-all short-circuits before any retriever call", async () => {
-    tempDataDir();
-    const { deps, calls } = makeDeps();
-
-    const response = await runAutoRecall(deps, {
-      message: "👍",
-      scope: "project:gate",
-      operation: "test:gate-enforce-skip",
-      env: { RECALLNEST_RECALL_GATE: "enforce" } as NodeJS.ProcessEnv,
-    });
-
-    expect(response.mode).toBe("resume-only");
-    expect(response.results.length).toBe(0);
-    expect(response.searchSkippedReason).toContain("skip-all");
-    expect(response.searchSkippedReason).toContain("skip:emoji");
-    expect(calls.length).toBe(0); // neither compose nor focused search hit the retriever
-  });
-
-  it("enforce + resume-only keeps resume context but skips the focused search", async () => {
-    tempDataDir();
-    const { deps, calls } = makeDeps();
-
-    const response = await runAutoRecall(deps, {
-      message: "继续",
-      scope: "project:gate",
-      operation: "test:gate-enforce-resume",
-      env: { RECALLNEST_RECALL_GATE: "enforce" } as NodeJS.ProcessEnv,
-    });
-
-    expect(response.mode).toBe("resume-only");
-    expect(response.results.length).toBe(0);
-    expect(response.searchSkippedReason).toContain("resume-only");
-    // Resume composition ran (retriever called with categories), but no
-    // focused search (which would be the category-less call).
-    const focusedCalls = calls.filter((c) => !c.category);
-    expect(focusedCalls.length).toBe(0);
-    expect(calls.length).toBeGreaterThan(0);
-  });
-
-  it("enforce mode leaves normal content untouched", async () => {
-    tempDataDir();
-    const { deps } = makeDeps();
-
-    const response = await runAutoRecall(deps, {
-      message: "帮我看看 retriever 的打分逻辑有没有问题",
-      scope: "project:gate",
-      operation: "test:gate-enforce-pass",
-      env: { RECALLNEST_RECALL_GATE: "enforce" } as NodeJS.ProcessEnv,
-    });
-
-    expect(response.mode).toBe("resume+search");
-    expect(response.results.length).toBe(1);
-  });
-
-  it("off mode computes nothing and writes no shadow log", async () => {
-    const dir = tempDataDir();
-    const { deps } = makeDeps();
-
-    const response = await runAutoRecall(deps, {
-      message: "好的",
-      scope: "project:gate",
-      operation: "test:gate-off",
-      env: { RECALLNEST_RECALL_GATE: "off" } as NodeJS.ProcessEnv,
-    });
-
-    expect(response.mode).toBe("resume+search");
-    expect(existsSync(join(dir, RECALL_GATE_SHADOW_FILE))).toBe(false);
-  });
-});