recallnest 3.0.0 → 3.0.1

package/src/__tests__/temporal-parser.test.ts

@@ -1,241 +0,0 @@
-import { describe, expect, it } from "bun:test";
-import {
-  parseTemporalQuery,
-  matchesTemporalConstraint,
-  temporalWhereClause,
-  type TemporalConstraint,
-} from "../temporal-parser.js";
-
-// ============================================================================
-// parseTemporalQuery
-// ============================================================================
-
-describe("parseTemporalQuery", () => {
-  // --- Absolute year (ZH) ---
-  it("parses '2023年的记忆'", () => {
-    const result = parseTemporalQuery("2023年的记忆里有什么");
-    expect(result.constraint).not.toBeNull();
-    expect(result.constraint!.type).toBe("range");
-    expect(result.constraint!.startMs).toBe(new Date(2023, 0, 1).getTime());
-    expect(result.constraint!.endMs).toBe(new Date(2024, 0, 1).getTime() - 1);
-    // Time expression removed from cleaned query
-    expect(result.cleanedQuery).not.toContain("2023年");
-    expect(result.cleanedQuery).toContain("里有什么");
-  });
-
-  it("parses standalone '2024年'", () => {
-    const result = parseTemporalQuery("关于 2024年 的项目");
-    expect(result.constraint).not.toBeNull();
-    expect(result.constraint!.type).toBe("range");
-  });
-
-  // --- Absolute year+month (ZH) ---
-  it("parses '2023年3月'", () => {
-    const result = parseTemporalQuery("2023年3月我们讨论了什么");
-    expect(result.constraint).not.toBeNull();
-    expect(result.constraint!.startMs).toBe(new Date(2023, 2, 1).getTime());
-    expect(result.constraint!.endMs).toBe(new Date(2023, 3, 1).getTime() - 1);
-  });
-
-  it("parses '2023年三月'", () => {
-    const result = parseTemporalQuery("2023年三月的对话");
-    expect(result.constraint).not.toBeNull();
-    expect(result.constraint!.startMs).toBe(new Date(2023, 2, 1).getTime());
-  });
-
-  // --- Absolute year+month (EN) ---
-  it("parses 'March 2023'", () => {
-    const result = parseTemporalQuery("What did we discuss in March 2023");
-    expect(result.constraint).not.toBeNull();
-    expect(result.constraint!.startMs).toBe(new Date(2023, 2, 1).getTime());
-    expect(result.constraint!.endMs).toBe(new Date(2023, 3, 1).getTime() - 1);
-  });
-
-  // --- "in YYYY" ---
-  it("parses 'in 2022'", () => {
-    const result = parseTemporalQuery("Projects discussed in 2022");
-    expect(result.constraint).not.toBeNull();
-    expect(result.constraint!.type).toBe("range");
-    expect(result.constraint!.startMs).toBe(new Date(2022, 0, 1).getTime());
-  });
-
-  // --- Relative: 最近N天/周/月 ---
-  it("parses '最近7天'", () => {
-    const result = parseTemporalQuery("最近7天的记忆");
-    expect(result.constraint).not.toBeNull();
-    expect(result.constraint!.type).toBe("range");
-    const now = Date.now();
-    expect(result.constraint!.startMs).toBeGreaterThan(now - 8 * 86_400_000);
-    expect(result.constraint!.endMs).toBeLessThanOrEqual(now + 1000);
-  });
-
-  it("parses '最近2周'", () => {
-    const result = parseTemporalQuery("最近2周讨论过什么");
-    expect(result.constraint).not.toBeNull();
-    const now = Date.now();
-    expect(result.constraint!.startMs).toBeGreaterThan(now - 15 * 86_400_000);
-  });
-
-  it("parses '最近3个月'", () => {
-    const result = parseTemporalQuery("最近3个月的项目进展");
-    expect(result.constraint).not.toBeNull();
-    const now = Date.now();
-    expect(result.constraint!.startMs).toBeGreaterThan(now - 100 * 86_400_000);
-  });
-
-  // --- Relative: last N days/weeks/months ---
-  it("parses 'last 30 days'", () => {
-    const result = parseTemporalQuery("What happened in the last 30 days");
-    expect(result.constraint).not.toBeNull();
-    expect(result.constraint!.type).toBe("range");
-    const now = Date.now();
-    expect(result.constraint!.startMs).toBeGreaterThan(now - 31 * 86_400_000);
-  });
-
-  it("parses 'last 2 weeks'", () => {
-    const result = parseTemporalQuery("Changes in the last 2 weeks");
-    expect(result.constraint).not.toBeNull();
-  });
-
-  // --- Relative: 上周/上个月/去年 ---
-  it("parses '去年'", () => {
-    const result = parseTemporalQuery("去年我们做了什么项目");
-    expect(result.constraint).not.toBeNull();
-    const lastYear = new Date().getFullYear() - 1;
-    expect(result.constraint!.startMs).toBe(new Date(lastYear, 0, 1).getTime());
-    expect(result.constraint!.endMs).toBe(new Date(lastYear + 1, 0, 1).getTime() - 1);
-  });
-
-  it("parses 'last year'", () => {
-    const result = parseTemporalQuery("Projects from last year");
-    expect(result.constraint).not.toBeNull();
-    expect(result.constraint!.type).toBe("range");
-  });
-
-  it("parses '上个月'", () => {
-    const result = parseTemporalQuery("上个月的讨论");
-    expect(result.constraint).not.toBeNull();
-  });
-
-  it("parses '去年3月'", () => {
-    const result = parseTemporalQuery("去年3月的事情");
-    expect(result.constraint).not.toBeNull();
-    const lastYear = new Date().getFullYear() - 1;
-    expect(result.constraint!.startMs).toBe(new Date(lastYear, 2, 1).getTime());
-  });
-
-  // --- Operator syntax ---
-  it("parses 'after:2024-01'", () => {
-    const result = parseTemporalQuery("TypeScript projects after:2024-01");
-    expect(result.constraint).not.toBeNull();
-    expect(result.constraint!.type).toBe("after");
-    expect(result.constraint!.startMs).toBe(new Date(2024, 0, 1).getTime());
-    expect(result.cleanedQuery).toContain("TypeScript projects");
-  });
-
-  it("parses 'before:2025-06'", () => {
-    const result = parseTemporalQuery("memory entries before:2025-06");
-    expect(result.constraint).not.toBeNull();
-    expect(result.constraint!.type).toBe("before");
-  });
-
-  // --- No temporal expression ---
-  it("returns null for non-temporal queries", () => {
-    const result = parseTemporalQuery("How to configure TypeScript");
-    expect(result.constraint).toBeNull();
-    expect(result.cleanedQuery).toBe("How to configure TypeScript");
-  });
-
-  it("returns null for empty query", () => {
-    const result = parseTemporalQuery("");
-    expect(result.constraint).toBeNull();
-  });
-
-  // --- Cleaned query ---
-  it("removes temporal expression and preserves the rest", () => {
-    const result = parseTemporalQuery("2023年我们讨论了 Docker 配置");
-    expect(result.cleanedQuery).toContain("Docker");
-    expect(result.cleanedQuery).not.toContain("2023年");
-  });
-});
-
-// ============================================================================
-// matchesTemporalConstraint
-// ============================================================================
-
-describe("matchesTemporalConstraint", () => {
-  it("matches timestamp within range", () => {
-    const constraint: TemporalConstraint = {
-      type: "range",
-      startMs: new Date(2023, 0, 1).getTime(),
-      endMs: new Date(2024, 0, 1).getTime() - 1,
-      anchor: "2023年",
-    };
-    const mid2023 = new Date(2023, 6, 1).getTime();
-    expect(matchesTemporalConstraint(mid2023, constraint)).toBe(true);
-  });
-
-  it("rejects timestamp outside range", () => {
-    const constraint: TemporalConstraint = {
-      type: "range",
-      startMs: new Date(2023, 0, 1).getTime(),
-      endMs: new Date(2024, 0, 1).getTime() - 1,
-      anchor: "2023年",
-    };
-    const mid2022 = new Date(2022, 6, 1).getTime();
-    expect(matchesTemporalConstraint(mid2022, constraint)).toBe(false);
-  });
-
-  it("handles 'after' constraint", () => {
-    const constraint: TemporalConstraint = {
-      type: "after",
-      startMs: new Date(2024, 0, 1).getTime(),
-      anchor: "after:2024-01",
-    };
-    expect(matchesTemporalConstraint(new Date(2024, 6, 1).getTime(), constraint)).toBe(true);
-    expect(matchesTemporalConstraint(new Date(2023, 6, 1).getTime(), constraint)).toBe(false);
-  });
-
-  it("handles 'before' constraint", () => {
-    const constraint: TemporalConstraint = {
-      type: "before",
-      endMs: new Date(2024, 0, 1).getTime(),
-      anchor: "before:2024-01",
-    };
-    expect(matchesTemporalConstraint(new Date(2023, 6, 1).getTime(), constraint)).toBe(true);
-    expect(matchesTemporalConstraint(new Date(2025, 0, 1).getTime(), constraint)).toBe(false);
-  });
-});
-
-// ============================================================================
-// temporalWhereClause
-// ============================================================================
-
-describe("temporalWhereClause", () => {
-  it("generates range clause", () => {
-    const clause = temporalWhereClause({
-      type: "range",
-      startMs: 1000,
-      endMs: 2000,
-      anchor: "test",
-    });
-    expect(clause).toBe("timestamp >= 1000 AND timestamp <= 2000");
-  });
-
-  it("generates after-only clause", () => {
-    const clause = temporalWhereClause({
-      type: "after",
-      startMs: 1000,
-      anchor: "test",
-    });
-    expect(clause).toBe("timestamp >= 1000");
-  });
-
-  it("returns null for empty constraint", () => {
-    const clause = temporalWhereClause({
-      type: "range",
-      anchor: "test",
-    });
-    expect(clause).toBeNull();
-  });
-});

package/src/__tests__/temporal-validity.test.ts

@@ -1,160 +0,0 @@
-/**
- * F3: Temporal Validity Windows — tests for eventTime, validUntil,
- * retrieval filtering, and auto-GC decay acceleration.
- */
-
-import { describe, expect, test } from "bun:test";
-import {
-  defaultEvolution,
-  parseEvolution,
-  patchEvolution,
-  type EvolutionMetadata,
-} from "../memory-evolution.js";
-
-// ---------------------------------------------------------------------------
-// Schema: eventTime field
-// ---------------------------------------------------------------------------
-
-describe("F3: eventTime in EvolutionMetadata", () => {
-  test("defaultEvolution includes eventTime: null", () => {
-    const evo = defaultEvolution(1000);
-    expect(evo.eventTime).toBeNull();
-    expect(evo.validFrom).toBe(1000);
-    expect(evo.validUntil).toBeNull();
-  });
-
-  test("parseEvolution extracts eventTime from metadata", () => {
-    const metadata = JSON.stringify({
-      evolution: {
-        status: "active",
-        version: 1,
-        accessCount: 0,
-        lastAccessedAt: null,
-        supersededBy: null,
-        supersedes: null,
-        evolutionNote: null,
-        consolidatedInto: null,
-        contributedToPattern: null,
-        sourceMemories: [],
-        validFrom: 1000,
-        validUntil: null,
-        eventTime: 5000,
-      },
-    });
-    const evo = parseEvolution(metadata);
-    expect(evo.eventTime).toBe(5000);
-  });
-
-  test("parseEvolution defaults eventTime to null when missing", () => {
-    const metadata = JSON.stringify({
-      evolution: {
-        status: "active",
-        version: 1,
-        validFrom: 1000,
-      },
-    });
-    const evo = parseEvolution(metadata);
-    expect(evo.eventTime).toBeNull();
-  });
-
-  test("patchEvolution can set eventTime", () => {
-    const metadata = JSON.stringify({ evolution: defaultEvolution(1000) });
-    const patched = patchEvolution(metadata, { eventTime: 9999 });
-    const evo = parseEvolution(patched);
-    expect(evo.eventTime).toBe(9999);
-  });
-
-  test("patchEvolution can set validUntil", () => {
-    const metadata = JSON.stringify({ evolution: defaultEvolution(1000) });
-    const patched = patchEvolution(metadata, { validUntil: 2000 });
-    const evo = parseEvolution(patched);
-    expect(evo.validUntil).toBe(2000);
-    // Other fields unchanged
-    expect(evo.validFrom).toBe(1000);
-    expect(evo.status).toBe("active");
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Retrieval: filterByValidity (unit-level via import)
-// ---------------------------------------------------------------------------
-
-// We test the filterByValidity logic indirectly through the exported
-// parseEvolution + the contract: expired memories get score * 0.2.
-// Direct integration tested via full retriever in separate test files.
-
-describe("F3: validity window logic", () => {
-  function makeEvo(overrides: Partial<EvolutionMetadata> = {}): EvolutionMetadata {
-    return { ...defaultEvolution(1000), ...overrides };
-  }
-
-  test("memory with validUntil in the future is not expired", () => {
-    const now = 5000;
-    const evo = makeEvo({ validUntil: 10000 });
-    // validUntil > now → not expired
-    expect(evo.validUntil).toBeGreaterThan(now);
-  });
-
-  test("memory with validUntil in the past is expired", () => {
-    const now = 5000;
-    const evo = makeEvo({ validUntil: 3000 });
-    // validUntil < now → expired
-    expect(evo.validUntil).toBeLessThan(now);
-  });
-
-  test("memory without validUntil never expires", () => {
-    const evo = makeEvo({ validUntil: null });
-    expect(evo.validUntil).toBeNull();
-  });
-
-  test("point-in-time query: memory valid in range", () => {
-    const evo = makeEvo({ validFrom: 1000, validUntil: 5000 });
-    const queryTime = 3000;
-    expect(evo.validFrom).toBeLessThanOrEqual(queryTime);
-    expect(evo.validUntil).toBeGreaterThanOrEqual(queryTime);
-  });
-
-  test("point-in-time query: memory not yet valid", () => {
-    const evo = makeEvo({ validFrom: 5000, validUntil: 10000 });
-    const queryTime = 3000;
-    expect(evo.validFrom).toBeGreaterThan(queryTime);
-  });
-
-  test("point-in-time query: memory already expired at query time", () => {
-    const evo = makeEvo({ validFrom: 1000, validUntil: 3000 });
-    const queryTime = 5000;
-    expect(evo.validUntil).toBeLessThan(queryTime);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Auto-GC: decay acceleration for expired memories
-// ---------------------------------------------------------------------------
-
-describe("F3: GC decay acceleration", () => {
-  test("expired memory decay score is halved", () => {
-    // Simulate the GC logic: if validUntil < now, decayScore *= 0.5
-    const baseDecayScore = 0.30;
-    const now = 10000;
-    const validUntil = 5000; // expired
-    const adjusted = validUntil < now ? baseDecayScore * 0.5 : baseDecayScore;
-    expect(adjusted).toBe(0.15);
-  });
-
-  test("non-expired memory decay score unchanged", () => {
-    const baseDecayScore = 0.30;
-    const now = 10000;
-    const validUntil = 20000; // still valid
-    const adjusted = validUntil < now ? baseDecayScore * 0.5 : baseDecayScore;
-    expect(adjusted).toBe(0.30);
-  });
-
-  test("memory without validUntil — decay score unchanged", () => {
-    const baseDecayScore = 0.30;
-    const validUntil = null;
-    const adjusted = (validUntil != null && validUntil < Date.now())
-      ? baseDecayScore * 0.5
-      : baseDecayScore;
-    expect(adjusted).toBe(0.30);
-  });
-});

package/src/__tests__/term-registry-terminal-roster.test.ts

@@ -1,127 +0,0 @@
-import { describe, expect, it } from "bun:test";
-
-import { selectStableResults } from "../context-composer-stable-selection.js";
-import { selectTaskResults } from "../context-composer-task-selection.js";
-import {
-  PREFERENCE_SPECIFICITY_GROUPS,
-  TASK_RESULT_SPECIFICITY_GROUPS,
-} from "../term-registry.js";
-import type { RetrievalResult } from "../retriever.js";
-
-// 端清单在检索术语簇里的落地。守两件事：
-//   ① 补上的端名真的解除了过滤（行为层）
-//   ② **有意的不对称不许被"机械补齐"抹掉**（结构层）——
-//      taskTerms 补端名、resultTerms 不补。这条最容易被后来人当成漏改而"顺手统一"，
-//      所以用测试钉住，并把理由写在断言旁边。
-// 背景同 memory-boundaries.ts:64-70 的 TRANSCRIPT_SOURCES —— 那处是字面 scope 前缀层，
-// 按字面补；这里是检索语义层，两侧方向相反，不能照抄。
-
-function stableCandidate(text: string): RetrievalResult {
-  return {
-    entry: {
-      id: `test-${text.slice(0, 8)}`,
-      text,
-      vector: [],
-      category: "preferences",
-      scope: "memory:pivot",
-      importance: 0.8,
-      timestamp: Date.now(),
-    },
-    score: 1,
-    sources: {},
-  } as RetrievalResult;
-}
-
-function taskCandidate(text: string): RetrievalResult {
-  return {
-    entry: {
-      id: `test-${text.slice(0, 8)}`,
-      text,
-      vector: [],
-      category: "cases",
-      scope: "memory:pivot",
-      importance: 0.8,
-      timestamp: Date.now(),
-    },
-    score: 1,
-    sources: {},
-  } as RetrievalResult;
-}
-
-// 会被 PREFERENCE_SPECIFICITY_GROUPS 认领的偏好（正文含 "codex" + "独立验证"）
-const CODEX_REVIEW_PREF =
-  "用户要求互审时由 Codex 做独立验证，交接材料里客观证据自动抽取，判断性材料必须手写填充。";
-
-describe("端清单 · PREFERENCE_SPECIFICITY_GROUPS", () => {
-  it("问 kimi / agy / antigravity 时不再把 CC·Codex 的验收偏好滤掉", () => {
-    for (const task of [
-      "kimi 互审的时候要注意什么",
-      "agy 那边是谁在做审查",
-      "antigravity 的会话是怎么接进来的",
-    ]) {
-      expect(
-        selectStableResults("preferences", [stableCandidate(CODEX_REVIEW_PREF)], 3, { taskSeed: task }),
-      ).toHaveLength(1);
-    }
-  });
-
-  it("问端拓扑本身（三端 / 四端）时同样解除", () => {
-    for (const task of ["四端的触发规则都装好了吗", "三端现在还一致吗"]) {
-      expect(
-        selectStableResults("preferences", [stableCandidate(CODEX_REVIEW_PREF)], 3, { taskSeed: task }),
-      ).toHaveLength(1);
-    }
-  });
-
-  it("与端无关的任务仍然滤掉 —— 放宽不能变成不过滤", () => {
-    for (const task of ["帮我写一篇公众号文章", "百度网盘上传断链怎么排查"]) {
-      expect(
-        selectStableResults("preferences", [stableCandidate(CODEX_REVIEW_PREF)], 3, { taskSeed: task }),
-      ).toHaveLength(0);
-    }
-  });
-
-  it("resultTerms 有意不含端名 —— 别照着 taskTerms 补齐", () => {
-    // resultTerms 是「谁被这组认领」，加裸端名会把"顺带提了一句 kimi"的无关偏好
-    // 整条变成可滤对象。已知实例：裸词 "codex" 已因 `.codex/AGENTS.md` 这种
-    // 路径片段误认领记忆（shadow 实测 b8731a81）。再加端名 = 把缺陷复制三份。
-    for (const term of ["kimi", "antigravity", "agy", "三端", "四端"]) {
-      expect(PREFERENCE_SPECIFICITY_GROUPS[0]?.resultTerms).not.toContain(term);
-    }
-    expect(PREFERENCE_SPECIFICITY_GROUPS[0]?.taskTerms).toEqual(
-      expect.arrayContaining(["kimi", "antigravity", "agy", "三端", "四端"]),
-    );
-  });
-});
-
-describe("端清单 · 三端历史事件组（TASK_RESULT_SPECIFICITY_GROUPS）", () => {
-  const historyGroup = TASK_RESULT_SPECIFICITY_GROUPS.find((group) =>
-    group.resultTerms.includes("three-terminal continuity trigger validation"),
-  );
-
-  it("resultTerms 是历史专名，不是端清单 —— 不补任何端名", () => {
-    expect(historyGroup).toBeDefined();
-    for (const term of ["kimi", "antigravity", "agy"]) {
-      expect(historyGroup?.resultTerms).not.toContain(term);
-    }
-  });
-
-  it("taskTerms 补她真实的问法（三端 / 四端），但同样不补端名", () => {
-    // "三端" 不是 "三终端" 的子串，补之前真的匹配不上
-    expect(historyGroup?.taskTerms).toEqual(expect.arrayContaining(["三端", "四端"]));
-    for (const term of ["kimi", "antigravity", "agy"]) {
-      expect(historyGroup?.taskTerms).not.toContain(term);
-    }
-  });
-
-  it("只提端名、不问触发/接入的任务，不该把这条三端历史放进来", () => {
-    const history = taskCandidate(
-      "三端连续性触发验证：three-terminal continuity trigger validation 已完成，continue-style prompts triggered recall reliably。",
-    );
-    expect(selectTaskResults("cases", [history], 3, { taskSeed: "kimi 挂了" })).toHaveLength(0);
-    // 对照：真正相关的问法照旧放行
-    expect(
-      selectTaskResults("cases", [history], 3, { taskSeed: "三端的触发验证结论还成立吗" }).length,
-    ).toBeGreaterThan(0);
-  });
-});

package/src/__tests__/term-registry.test.ts

@@ -1,121 +0,0 @@
-import { describe, expect, it } from "bun:test";
-
-import {
-  buildTaskHintTerms,
-  extractTerms,
-  looksLikeContinuityTask,
-  looksLikeRecallOnlyTask,
-  taskCueCoverage,
-} from "../term-registry.js";
-
-describe("term registry", () => {
-  it("extracts compact Chinese and latin cue terms", () => {
-    expect(extractTerms("继续 RecallNest continuity bridge 适配")).toEqual([
-      "继续",
-      "recallnest",
-      "continuity",
-      "bridge",
-      "适配",
-    ]);
-  });
-
-  it("can keep later terms when a wider extraction window is requested", () => {
-    expect(
-      extractTerms(
-        "继续 RecallNest continuity helper boundary audit ranking scoring selection orchestration context composer stable query fallback profile forwarding gap runner isolation",
-        24,
-      ),
-    ).toEqual(expect.arrayContaining([
-      "profile",
-      "forwarding",
-      "runner",
-      "isolation",
-    ]));
-  });
-
-  it("builds task hints for writing prompts across languages", () => {
-    expect(buildTaskHintTerms("continue my AI writing project")).toEqual([
-      "写作",
-      "文章",
-      "语气",
-      "风格",
-      "口语化",
-      "不端着",
-      "ai",
-      "公众号",
-    ]);
-  });
-
-  it("treats recall-only wording differently from writing actions", () => {
-    expect(looksLikeRecallOnlyTask("你还记得我之前的偏好吗")).toBe(true);
-    expect(looksLikeRecallOnlyTask("不要让我重复前情，继续写文章")).toBe(false);
-  });
-
-  it("tracks workflow cue coverage from pattern text", () => {
-    expect(
-      taskCueCoverage(
-        "patterns",
-        "Workflow pattern: Cross-window continuity handoff Tools: resume_context, checkpoint_session, search_memory",
-      ),
-    ).toEqual(["search_memory", "resume_context", "checkpoint"]);
-  });
-
-  it("treats named RecallNest and memory-layer continues as continuity tasks", () => {
-    expect(looksLikeContinuityTask("回到 RecallNest 继续做")).toBe(true);
-    expect(looksLikeContinuityTask("接着弄 RecallNest 那个 memory layer")).toBe(true);
-    expect(looksLikeContinuityTask("把记忆层这条线先续上")).toBe(true);
-    expect(looksLikeContinuityTask("把之前那套 recall 管线先捡起来")).toBe(true);
-    expect(looksLikeContinuityTask("pick up where we left off on RecallNest")).toBe(true);
-    expect(looksLikeContinuityTask("回到 A2A 继续做")).toBe(false);
-    // Status queries are NOT continuation tasks — entity+cases is sufficient
-    expect(looksLikeContinuityTask("RecallNest 现在啥情况")).toBe(false);
-  });
-
-  it("builds RecallNest continuity hints for memory-layer shorthand", () => {
-    expect(buildTaskHintTerms("把刚才那个 memory layer 接回去")).toEqual(expect.arrayContaining([
-      "recallnest",
-      "checkpoint_session",
-      "resume_context",
-      "store_memory",
-    ]));
-  });
-
-  it("builds RecallNest continuity hints for colloquial memory shorthand", () => {
-    expect(buildTaskHintTerms("把那条跨窗口记忆的活接着弄完")).toEqual(expect.arrayContaining([
-      "recallnest",
-      "checkpoint_session",
-      "resume_context",
-    ]));
-    expect(buildTaskHintTerms("把之前那套 recall 管线先捡起来")).toEqual(expect.arrayContaining([
-      "recallnest",
-      "checkpoint_session",
-      "resume_context",
-    ]));
-  });
-
-  it("treats 记忆项目 as continuity task and builds RecallNest hints", () => {
-    expect(looksLikeContinuityTask("那个记忆项目，之前做到哪了")).toBe(true);
-    expect(looksLikeContinuityTask("继续记忆项目")).toBe(true);
-    expect(buildTaskHintTerms("那个记忆项目，之前做到哪了")).toEqual(expect.arrayContaining([
-      "recallnest",
-      "resume_context",
-    ]));
-    expect(buildTaskHintTerms("continue the memory project")).toEqual(expect.arrayContaining([
-      "recallnest",
-    ]));
-  });
-
-  it("treats 跨终端记忆/记忆功能/记忆服务 shorthand as continuity cue", () => {
-    // "还搞吗" is a status question, not a continuation verb — correct to return false
-    expect(looksLikeContinuityTask("那个跨终端记忆还搞吗")).toBe(false);
-    expect(looksLikeContinuityTask("继续那个跨终端记忆")).toBe(true);
-    expect(looksLikeContinuityTask("上次做的那个记忆功能")).toBe(true);
-    expect(looksLikeContinuityTask("之前那个 MCP 记忆服务")).toBe(true);
-    expect(buildTaskHintTerms("那个跨终端记忆还搞吗")).toEqual(expect.arrayContaining([
-      "recallnest",
-    ]));
-    expect(buildTaskHintTerms("上次做的记忆功能")).toEqual(expect.arrayContaining([
-      "recallnest",
-    ]));
-  });
-});