recallnest 1.4.1

package/src/__tests__/session-gc.test.ts

@@ -0,0 +1,215 @@
+import { describe, expect, it } from "bun:test";
+import { existsSync, mkdirSync, mkdtempSync, readdirSync, rmSync, utimesSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { buildSessionCheckpointRecord } from "../session-engine.js";
+import { SessionCheckpointStore, classifyCheckpointQuality } from "../session-store.js";
+
+const FALLBACK_SUMMARY = "Checkpoint captured current task state without repo-state details.";
+const NOW = new Date("2026-04-01T00:00:00.000Z");
+
+function daysBeforeNow(days: number): string {
+  return new Date(NOW.getTime() - days * 86_400_000).toISOString();
+}
+
+function makeRichCheckpoint(overrides: Record<string, unknown> = {}) {
+  return buildSessionCheckpointRecord({
+    sessionId: overrides.sessionId ?? crypto.randomUUID(),
+    scope: overrides.scope ?? "project:test",
+    summary: overrides.summary ?? "Rich checkpoint with real content about the project status.",
+    decisions: overrides.decisions ?? ["decision-a"],
+    openLoops: overrides.openLoops ?? ["loop-a"],
+    nextActions: overrides.nextActions ?? ["action-a"],
+    entities: [],
+    files: [],
+    updatedAt: overrides.updatedAt ?? daysBeforeNow(1),
+  });
+}
+
+function makeMinimalCheckpoint(overrides: Record<string, unknown> = {}) {
+  return buildSessionCheckpointRecord({
+    sessionId: overrides.sessionId ?? crypto.randomUUID(),
+    scope: overrides.scope ?? "project:test",
+    summary: FALLBACK_SUMMARY,
+    decisions: [],
+    openLoops: [],
+    nextActions: [],
+    entities: [],
+    files: [],
+    updatedAt: overrides.updatedAt ?? daysBeforeNow(1),
+  });
+}
+
+function createTempStore(): { store: SessionCheckpointStore; dir: string; cleanup: () => void } {
+  const dir = mkdtempSync(join(tmpdir(), "rn-gc-test-"));
+  const checkpointDir = join(dir, "session-checkpoints");
+  mkdirSync(checkpointDir, { recursive: true });
+  const store = new SessionCheckpointStore(checkpointDir);
+  return {
+    store,
+    dir,
+    cleanup: () => rmSync(dir, { recursive: true, force: true }),
+  };
+}
+
+describe("checkpoint gc - retention rules", () => {
+  it("keeps latest N rich checkpoints per scope and archives older ones", async () => {
+    const { store, cleanup } = createTempStore();
+    try {
+      // 7 rich checkpoints for same scope, spread across 5-50 days
+      const ages = [5, 10, 15, 25, 35, 42, 50];
+      for (const age of ages) {
+        await store.save(makeRichCheckpoint({ updatedAt: daysBeforeNow(age) }));
+      }
+
+      const result = store.gc({ now: NOW, keepPerScope: 5, archiveAfterDays: 30 });
+      expect(result.kept).toBe(5);
+      expect(result.archived).toBe(2); // 42d and 50d
+      expect(result.deleted).toBe(0);
+      expect(result.errors).toHaveLength(0);
+    } finally {
+      cleanup();
+    }
+  });
+
+  it("keeps latest checkpoint per session if within 48 hours", async () => {
+    const { store, cleanup } = createTempStore();
+    try {
+      const sessionA = crypto.randomUUID();
+      const sessionB = crypto.randomUUID();
+
+      // sessionA: 1 hour old minimal — should be protected by session TTL
+      await store.save(makeMinimalCheckpoint({ sessionId: sessionA, updatedAt: daysBeforeNow(0.04) }));
+      // sessionB: 10 days old minimal — no session TTL protection, >7 days → delete
+      await store.save(makeMinimalCheckpoint({ sessionId: sessionB, updatedAt: daysBeforeNow(10) }));
+
+      const result = store.gc({ now: NOW, sessionTtlHours: 48, minimalTtlDays: 7 });
+      expect(result.kept).toBe(1);  // sessionA protected
+      expect(result.deleted).toBe(1); // sessionB expired minimal
+    } finally {
+      cleanup();
+    }
+  });
+
+  it("deletes minimal checkpoints older than 7 days", async () => {
+    const { store, cleanup } = createTempStore();
+    try {
+      await store.save(makeMinimalCheckpoint({ updatedAt: daysBeforeNow(3) }));
+      await store.save(makeMinimalCheckpoint({ updatedAt: daysBeforeNow(8) }));
+      await store.save(makeMinimalCheckpoint({ updatedAt: daysBeforeNow(15) }));
+
+      const result = store.gc({ now: NOW, minimalTtlDays: 7 });
+      expect(result.kept).toBe(1);   // 3d old
+      expect(result.deleted).toBe(2); // 8d and 15d old
+    } finally {
+      cleanup();
+    }
+  });
+
+  it("archives rich checkpoints older than 30 days not in latest-per-scope", async () => {
+    const { store, dir, cleanup } = createTempStore();
+    try {
+      const ages = [5, 10, 20, 35, 40, 50];
+      for (const age of ages) {
+        await store.save(makeRichCheckpoint({ updatedAt: daysBeforeNow(age) }));
+      }
+
+      const result = store.gc({ now: NOW, keepPerScope: 3, archiveAfterDays: 30 });
+      expect(result.kept).toBe(3);     // 5d, 10d, 20d
+      expect(result.archived).toBe(3); // 35d, 40d, 50d
+
+      // Verify files actually moved to archive
+      const archiveDir = join(dir, "archive", "session-checkpoints");
+      expect(existsSync(archiveDir)).toBe(true);
+      expect(readdirSync(archiveDir).filter((f) => f.endsWith(".json"))).toHaveLength(3);
+    } finally {
+      cleanup();
+    }
+  });
+
+  it("hard-deletes archived files older than 90 days", async () => {
+    const { store, dir, cleanup } = createTempStore();
+    try {
+      // Manually place 2 files in archive directory
+      const archiveDir = join(dir, "archive", "session-checkpoints");
+      mkdirSync(archiveDir, { recursive: true });
+
+      const file60d = join(archiveDir, "old-60d-file.json");
+      const file100d = join(archiveDir, "old-100d-file.json");
+      writeFileSync(file60d, "{}");
+      writeFileSync(file100d, "{}");
+
+      // Backdate mtimes
+      const mtime60 = new Date(NOW.getTime() - 60 * 86_400_000);
+      const mtime100 = new Date(NOW.getTime() - 100 * 86_400_000);
+      utimesSync(file60d, mtime60, mtime60);
+      utimesSync(file100d, mtime100, mtime100);
+
+      const result = store.gc({ now: NOW, archiveTtlDays: 90 });
+      expect(existsSync(file60d)).toBe(true);   // 60d < 90d, survives
+      expect(existsSync(file100d)).toBe(false);  // 100d > 90d, deleted
+      expect(result.deleted).toBe(1);
+    } finally {
+      cleanup();
+    }
+  });
+});
+
+describe("checkpoint gc - priority and edge cases", () => {
+  it("session TTL protection overrides minimal delete rule", async () => {
+    const { store, cleanup } = createTempStore();
+    try {
+      const sessionId = crypto.randomUUID();
+      // 2 hours old minimal — minimalTtlDays=0 would delete, but session TTL protects
+      await store.save(makeMinimalCheckpoint({ sessionId, updatedAt: daysBeforeNow(0.08) }));
+
+      const result = store.gc({ now: NOW, sessionTtlHours: 48, minimalTtlDays: 0 });
+      expect(result.kept).toBe(1);
+      expect(result.deleted).toBe(0);
+
+      const keepAction = result.actions.find((a) => a.action === "keep");
+      expect(keepAction?.reason).toContain("session");
+    } finally {
+      cleanup();
+    }
+  });
+
+  it("dry run does not modify any files", async () => {
+    const { store, dir, cleanup } = createTempStore();
+    try {
+      // 1 to delete (minimal, 10d), 1 to archive (rich, 35d), 1 to keep (rich, 2d)
+      await store.save(makeMinimalCheckpoint({ updatedAt: daysBeforeNow(10) }));
+      await store.save(makeRichCheckpoint({ updatedAt: daysBeforeNow(35) }));
+      await store.save(makeRichCheckpoint({ updatedAt: daysBeforeNow(2) }));
+
+      const checkpointDir = join(dir, "session-checkpoints");
+      const beforeCount = readdirSync(checkpointDir).filter((f) => f.endsWith(".json")).length;
+
+      const result = store.gc({ now: NOW, dryRun: true, keepPerScope: 1, archiveAfterDays: 30, minimalTtlDays: 7 });
+      expect(result.archived).toBeGreaterThan(0);
+      expect(result.deleted).toBeGreaterThan(0);
+
+      // Files are still there
+      const afterCount = readdirSync(checkpointDir).filter((f) => f.endsWith(".json")).length;
+      expect(afterCount).toBe(beforeCount);
+    } finally {
+      cleanup();
+    }
+  });
+});
+
+describe("checkpoint gc - structural", () => {
+  it("handles empty directory gracefully", () => {
+    const { store, cleanup } = createTempStore();
+    try {
+      const result = store.gc({ now: NOW });
+      expect(result.kept).toBe(0);
+      expect(result.archived).toBe(0);
+      expect(result.deleted).toBe(0);
+      expect(result.errors).toHaveLength(0);
+    } finally {
+      cleanup();
+    }
+  });
+});

package/src/__tests__/store-scope-audit.test.ts

@@ -0,0 +1,81 @@
+import { afterEach, describe, expect, it } from "bun:test";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { MemoryStore, classifyLegacyScope } from "../store.js";
+
+const cleanupPaths: string[] = [];
+
+afterEach(() => {
+  while (cleanupPaths.length > 0) {
+    const target = cleanupPaths.pop();
+    if (target) {
+      rmSync(target, { recursive: true, force: true });
+    }
+  }
+});
+
+function createStore(): MemoryStore {
+  const dbPath = mkdtempSync(join(tmpdir(), "recallnest-scope-audit-"));
+  cleanupPaths.push(dbPath);
+  return new MemoryStore({
+    dbPath,
+    vectorDim: 3,
+  });
+}
+
+describe("classifyLegacyScope", () => {
+  it("flags missing, empty, and global scope values", () => {
+    expect(classifyLegacyScope(undefined)).toBe("missing");
+    expect(classifyLegacyScope(null)).toBe("missing");
+    expect(classifyLegacyScope("")).toBe("empty");
+    expect(classifyLegacyScope("   ")).toBe("empty");
+    expect(classifyLegacyScope("global")).toBe("global");
+    expect(classifyLegacyScope(" global ")).toBe("global");
+    expect(classifyLegacyScope("project:recallnest")).toBeUndefined();
+  });
+});
+
+describe("MemoryStore.auditLegacyScopes", () => {
+  it("reports global and empty scope rows without mixing in valid scoped data", async () => {
+    const store = createStore();
+
+    await store.store({
+      text: "Scoped memory should not appear in the audit.",
+      vector: [1, 0, 0],
+      category: "entities",
+      scope: "project:recallnest",
+      importance: 0.8,
+      metadata: "{}",
+    });
+    await store.store({
+      text: "Historical row that used the global fallback.",
+      vector: [0, 1, 0],
+      category: "events",
+      scope: "global",
+      importance: 0.5,
+      metadata: "{}",
+    });
+    await store.store({
+      text: "Historical row that was written without a real scope.",
+      vector: [0, 0, 1],
+      category: "events",
+      scope: "   ",
+      importance: 0.4,
+      metadata: "{}",
+    });
+
+    const audit = await store.auditLegacyScopes(10);
+
+    expect(audit.totalCount).toBe(2);
+    expect(audit.counts).toEqual({
+      missing: 0,
+      empty: 1,
+      global: 1,
+    });
+    expect(audit.samples).toHaveLength(2);
+    expect(audit.samples.map((sample) => sample.kind).sort()).toEqual(["empty", "global"]);
+    expect(audit.samples.every((sample) => sample.scope !== "project:recallnest")).toBe(true);
+  });
+});

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

@@ -0,0 +1,241 @@
+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__/term-registry.test.ts

@@ -0,0 +1,121 @@
+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",
+    ]));
+  });
+});