recallnest 2.3.0 → 2.5.4

package/src/__tests__/adaptive-fidelity.test.ts

@@ -0,0 +1,102 @@
+import { describe, expect, it } from "bun:test";
+
+import { formatCollapsedResults } from "../memory-output.js";
+import type { RetrievalResult } from "../retriever.js";
+
+// P-fidelity (点4): adaptive 档 search-native 实现（CC+Codex 共识 C：不复用 resume 的
+// collapseResults）。借鉴 RepoPrompt CE「保真度阶梯」内核——按相关性分配保真度 + token 预算，
+// 但渲染 query-aware（search 结果是"为什么命中"，必须显示匹配证据）。
+
+function makeResult(id: string, text: string, score: number, metadata = "{}"): RetrievalResult {
+  return {
+    entry: {
+      id,
+      text,
+      vector: [],
+      category: "events",
+      scope: "test",
+      importance: 0.5,
+      timestamp: Date.parse("2026-06-29T00:00:00.000Z"),
+      metadata,
+    },
+    score,
+    sources: {},
+  };
+}
+
+const ctx = { query: "QUERYMATCH", profile: "default" as never };
+
+describe("formatCollapsedResults (adaptive, search-native)", () => {
+  it("returns 'No results found' for empty input", () => {
+    expect(formatCollapsedResults([], ctx)).toBe("No results found.");
+  });
+
+  it("renders high-relevance (score ≥ 0.85) as FULL text", () => {
+    const out = formatCollapsedResults([makeResult("aaaaaaaa", "full detailed QUERYMATCH content here", 0.95)], ctx);
+    expect(out).toContain("[FULL] aaaaaaaa");
+    expect(out).toContain("full detailed QUERYMATCH content here");
+  });
+
+  it("renders lower-relevance as SNIP and keeps the matching evidence even when it's late in the text (P2-3)", () => {
+    const text = "Intro sentence. " + "filler ".repeat(20) + "the QUERYMATCH evidence is right here.";
+    const out = formatCollapsedResults([makeResult("bbbbbbbb", text, 0.60)], ctx);
+    expect(out).toContain("[SNIP] bbbbbbbb");
+    // 关键：query-aware snippet 必须保留匹配证据，而不是只截开头（这正是复用 collapse 时的 P2-3）
+    expect(out).toContain("QUERYMATCH");
+  });
+
+  it("does NOT drop low-score hits — adaptive is display, not a filter (P2-1)", () => {
+    const out = formatCollapsedResults([makeResult("cccccccc", "valid low-score QUERYMATCH hit", 0.30)], ctx);
+    expect(out).toContain("[SNIP] cccccccc");
+    expect(out).not.toContain("No results");
+  });
+
+  it("preserves caller order (e.g. highlight reorder), not raw score order (P2-2)", () => {
+    // 模拟 render:highlight — contextual 最相关但 raw score 较低的排在前。
+    const out = formatCollapsedResults([
+      makeResult("term0000", "term-relevant QUERYMATCH but lower score", 0.55),
+      makeResult("high0000", "higher score but less contextual", 0.95),
+    ], ctx);
+    const idxTerm = out.indexOf("term0000");
+    const idxHigh = out.indexOf("high0000");
+    expect(idxTerm).toBeGreaterThan(-1);
+    expect(idxHigh).toBeGreaterThan(-1);
+    expect(idxTerm).toBeLessThan(idxHigh); // term0000 仍在前
+  });
+
+  it("includes locator info (id / score / category)", () => {
+    const out = formatCollapsedResults([makeResult("dddddddd", "QUERYMATCH content", 0.90)], ctx);
+    expect(out).toContain("dddddddd");
+    expect(out).toContain("90%");
+    expect(out).toContain("events"); // category label
+  });
+
+  it("keeps the match visible for a short acronym query (adaptiveSnippet window, P2)", () => {
+    // pickBestSnippet 对短缩写 query 会退回开头；adaptiveSnippet 用 raw query 定位 + 窗口。
+    const text = "Some long intro line without the keyword. ".repeat(5) + "Finally the CI pipeline broke here.";
+    const out = formatCollapsedResults([makeResult("ffffffff", text, 0.50)], { query: "CI", profile: "default" as never });
+    expect(out).toContain("[SNIP] ffffffff");
+    expect(out.toLowerCase()).toContain("ci pipeline"); // 匹配证据可见，而非只截开头
+  });
+
+  it("windows around a match that is late in a long single line (P2)", () => {
+    // 超长无句读的 log 行：整句截断会丢后段匹配；adaptiveSnippet 取匹配词周围窗口。
+    const text = "prefix ".repeat(50) + "ZEBRAWORD is the late match here" + " suffix".repeat(50);
+    const out = formatCollapsedResults([makeResult("11111111", text, 0.50)], { query: "ZEBRAWORD", profile: "default" as never });
+    expect(out).toContain("ZEBRAWORD"); // 后段匹配仍在窗口内
+  });
+
+  it("does not false-match an acronym inside an unrelated earlier word (word boundary, P2)", () => {
+    // "specific" 含子串 "ci"；裸 substring 会 window 到它、漏掉真的 CI。word boundary 跳过。
+    const text = "This is a specific introduction. " + "filler ".repeat(10) + "Then the CI build failed.";
+    const out = formatCollapsedResults([makeResult("22222222", text, 0.50)], { query: "CI", profile: "default" as never });
+    expect(out).toContain("CI build"); // window 到真 CI，不是 specific 里的 ci
+  });
+
+  it("matches CJK fallback queries via substring (ASCII word boundary doesn't apply, P2-1)", () => {
+    // 中文单字 query：JS \b 只认 ASCII，必须走 substring，否则退回开头丢匹配（Alice 的记忆大量中文）。
+    const text = "开头一些无关的内容。" + "填充内容 ".repeat(10) + "这里才提到猫的关键证据。";
+    const out = formatCollapsedResults([makeResult("33333333", text, 0.50)], { query: "猫", profile: "default" as never });
+    expect(out).toContain("猫"); // 中文匹配证据可见
+  });
+});

package/src/__tests__/admission-control.test.ts

@@ -0,0 +1,206 @@
+import { describe, expect, it } from "bun:test";
+
+import {
+  checkAdmission,
+  resolveAdmissionConfig,
+  ScopeRateLimiter,
+} from "../admission-control.js";
+
+// ---------------------------------------------------------------------------
+// resolveAdmissionConfig
+// ---------------------------------------------------------------------------
+
+describe("resolveAdmissionConfig", () => {
+  it("returns defaults when no overrides", () => {
+    const cfg = resolveAdmissionConfig();
+    expect(cfg.minTextLength).toBe(10);
+    expect(cfg.noiseFilterEnabled).toBe(true);
+    expect(cfg.minImportance).toBe(0.2);
+    expect(cfg.maxWritesPerScope).toBe(50);
+    expect(cfg.rateLimitWindowMs).toBe(60_000);
+  });
+
+  it("merges partial overrides", () => {
+    const cfg = resolveAdmissionConfig({ minImportance: 0.5 });
+    expect(cfg.minImportance).toBe(0.5);
+    expect(cfg.minTextLength).toBe(10); // unchanged
+  });
+});
+
+// ---------------------------------------------------------------------------
+// checkAdmission — text length
+// ---------------------------------------------------------------------------
+
+describe("checkAdmission — text length", () => {
+  it("rejects text shorter than minTextLength", () => {
+    const result = checkAdmission("short", 0.8, "project:test");
+    expect(result.verdict).toBe("rejected");
+    expect(result.reason).toBe("text_too_short");
+  });
+
+  it("rejects empty text", () => {
+    const result = checkAdmission("", 0.8, "project:test");
+    expect(result.verdict).toBe("rejected");
+    expect(result.reason).toBe("text_too_short");
+  });
+
+  it("rejects whitespace-only text", () => {
+    const result = checkAdmission("         ", 0.8, "project:test");
+    expect(result.verdict).toBe("rejected");
+    expect(result.reason).toBe("text_too_short");
+  });
+
+  it("accepts text at exactly minTextLength", () => {
+    const result = checkAdmission("abcdefghij", 0.8, "project:test");
+    expect(result.verdict).toBe("accepted");
+  });
+
+  it("respects custom minTextLength", () => {
+    const result = checkAdmission("hello world", 0.8, "project:test", undefined, { minTextLength: 20 });
+    expect(result.verdict).toBe("rejected");
+    expect(result.reason).toBe("text_too_short");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// checkAdmission — noise filter
+// ---------------------------------------------------------------------------
+
+describe("checkAdmission — noise filter", () => {
+  it("rejects denial patterns", () => {
+    const result = checkAdmission("I don't have any information about that topic", 0.8, "project:test");
+    expect(result.verdict).toBe("rejected");
+    expect(result.reason).toBe("noise_detected");
+  });
+
+  it("rejects boilerplate greetings", () => {
+    const result = checkAdmission("hello there!", 0.8, "project:test");
+    expect(result.verdict).toBe("rejected");
+    expect(result.reason).toBe("noise_detected");
+  });
+
+  it("can be disabled via config", () => {
+    const result = checkAdmission(
+      "I don't have any information about that topic",
+      0.8,
+      "project:test",
+      undefined,
+      { noiseFilterEnabled: false },
+    );
+    expect(result.verdict).toBe("accepted");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// checkAdmission — importance floor
+// ---------------------------------------------------------------------------
+
+describe("checkAdmission — importance floor", () => {
+  it("rejects importance below default threshold (0.2)", () => {
+    const result = checkAdmission("This is a valid memory text", 0.1, "project:test");
+    expect(result.verdict).toBe("rejected");
+    expect(result.reason).toBe("importance_too_low");
+  });
+
+  it("accepts importance at exactly the threshold", () => {
+    const result = checkAdmission("This is a valid memory text", 0.2, "project:test");
+    expect(result.verdict).toBe("accepted");
+  });
+
+  it("accepts importance above threshold", () => {
+    const result = checkAdmission("This is a valid memory text", 0.8, "project:test");
+    expect(result.verdict).toBe("accepted");
+  });
+
+  it("respects custom minImportance", () => {
+    const result = checkAdmission("This is a valid memory text", 0.4, "project:test", undefined, { minImportance: 0.5 });
+    expect(result.verdict).toBe("rejected");
+    expect(result.reason).toBe("importance_too_low");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// ScopeRateLimiter
+// ---------------------------------------------------------------------------
+
+describe("ScopeRateLimiter", () => {
+  it("allows writes within limit", () => {
+    const limiter = new ScopeRateLimiter();
+    const cfg = resolveAdmissionConfig({ maxWritesPerScope: 3 });
+    expect(limiter.check("s1", cfg)).toBe(true);
+    expect(limiter.check("s1", cfg)).toBe(true);
+    expect(limiter.check("s1", cfg)).toBe(true);
+  });
+
+  it("blocks writes exceeding limit", () => {
+    const limiter = new ScopeRateLimiter();
+    const cfg = resolveAdmissionConfig({ maxWritesPerScope: 2 });
+    expect(limiter.check("s1", cfg)).toBe(true);
+    expect(limiter.check("s1", cfg)).toBe(true);
+    expect(limiter.check("s1", cfg)).toBe(false); // 3rd blocked
+  });
+
+  it("tracks scopes independently", () => {
+    const limiter = new ScopeRateLimiter();
+    const cfg = resolveAdmissionConfig({ maxWritesPerScope: 1 });
+    expect(limiter.check("s1", cfg)).toBe(true);
+    expect(limiter.check("s2", cfg)).toBe(true);
+    expect(limiter.check("s1", cfg)).toBe(false); // s1 exhausted
+    expect(limiter.check("s2", cfg)).toBe(false); // s2 exhausted
+  });
+
+  it("reports correct size", () => {
+    const limiter = new ScopeRateLimiter();
+    const cfg = resolveAdmissionConfig();
+    limiter.check("a", cfg);
+    limiter.check("b", cfg);
+    expect(limiter.size).toBe(2);
+  });
+
+  it("clears all state", () => {
+    const limiter = new ScopeRateLimiter();
+    const cfg = resolveAdmissionConfig();
+    limiter.check("a", cfg);
+    limiter.clear();
+    expect(limiter.size).toBe(0);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// checkAdmission — rate limiting
+// ---------------------------------------------------------------------------
+
+describe("checkAdmission — rate limiting", () => {
+  it("rejects when rate limit exceeded", () => {
+    const limiter = new ScopeRateLimiter();
+    const cfg = { maxWritesPerScope: 2 } as const;
+    // First two pass
+    checkAdmission("valid memory text here", 0.8, "project:test", limiter, cfg);
+    checkAdmission("another valid memory text", 0.8, "project:test", limiter, cfg);
+    // Third is rate limited
+    const result = checkAdmission("yet another valid text", 0.8, "project:test", limiter, cfg);
+    expect(result.verdict).toBe("rejected");
+    expect(result.reason).toBe("rate_limited");
+  });
+
+  it("skips rate limiting when no limiter provided", () => {
+    const result = checkAdmission("valid memory text here", 0.8, "project:test");
+    expect(result.verdict).toBe("accepted");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// checkAdmission — happy path
+// ---------------------------------------------------------------------------
+
+describe("checkAdmission — happy path", () => {
+  it("accepts valid memory with all checks passing", () => {
+    const result = checkAdmission(
+      "User prefers dark mode in all applications",
+      0.8,
+      "project:test",
+    );
+    expect(result.verdict).toBe("accepted");
+    expect(result.reason).toBeUndefined();
+  });
+});

package/src/__tests__/anchor-generator.test.ts

@@ -0,0 +1,67 @@
+import { describe, it, expect } from "bun:test";
+import { generateAnchor } from "../anchor-generator.js";
+
+describe("generateAnchor", () => {
+  it("returns undefined for short text (≤80 chars)", () => {
+    expect(generateAnchor("轮巡仓库每日检查")).toBeUndefined();
+    expect(generateAnchor("Short text that fits in 80 chars easily")).toBeUndefined();
+  });
+
+  it("extracts first sentence from long text", () => {
+    const text = "每天轮巡4个win4r仓库，检查Issue和PR。" +
+      "包括 ClawTeam-OpenClaw、openclaw-a2a-gateway、memory-lancedb-pro、UltraMemory。" +
+      "Issue 用中文回复，PR 用英文 review。不要重复回复已处理的。";
+    const anchor = generateAnchor(text);
+    expect(anchor).toBeDefined();
+    expect(anchor!.length).toBeLessThanOrEqual(80);
+    expect(anchor).toBe("每天轮巡4个win4r仓库，检查Issue和PR");
+  });
+
+  it("uses workflow pattern title from metadata", () => {
+    const text = "A very long workflow pattern description that spans multiple lines and paragraphs explaining the full procedure";
+    const metadata = {
+      workflowPattern: {
+        title: "Daily repo patrol",
+        trigger: "Every morning",
+      },
+    };
+    const anchor = generateAnchor(text, metadata);
+    expect(anchor).toBe("Daily repo patrol");
+  });
+
+  it("uses case memory title from metadata", () => {
+    const text = "A very long case description that spans multiple lines and paragraphs explaining the full case and its resolution";
+    const metadata = {
+      caseMemory: {
+        title: "Fix dedup over-kill in ingest",
+        problem: "72% of chunks were being dropped",
+      },
+    };
+    const anchor = generateAnchor(text, metadata);
+    expect(anchor).toBe("Fix dedup over-kill in ingest");
+  });
+
+  it("truncates long first sentences at CJK char boundary", () => {
+    const text = "这是一个非常非常非常非常非常非常非常非常非常非常非常非常非常非常长的第一句话，" +
+      "超过了八十个字符的限制需要被截断到合适的长度。" +
+      "第二句话在这里提供更多上下文信息用于测试截断功能是否正常工作。";
+    const anchor = generateAnchor(text);
+    expect(anchor).toBeDefined();
+    expect(anchor!.length).toBeLessThanOrEqual(80);
+  });
+
+  it("truncates long English sentences at word boundary", () => {
+    const text = "This is a very long first sentence that definitely exceeds the eighty character limit by quite a significant margin. Second sentence here.";
+    const anchor = generateAnchor(text);
+    expect(anchor).toBeDefined();
+    expect(anchor!.length).toBeLessThanOrEqual(80);
+    // Should not end mid-word
+    expect(anchor!).not.toMatch(/\s$/);
+  });
+
+  it("handles text with only newline separators", () => {
+    const text = "First line of important information that is a reasonable sentence\nSecond line with more details and context that expands on the first point";
+    const anchor = generateAnchor(text);
+    expect(anchor).toBe("First line of important information that is a reasonable sentence");
+  });
+});

package/src/__tests__/auto-consolidation.test.ts

@@ -0,0 +1,168 @@
+import { describe, expect, it, beforeEach } from "bun:test";
+
+import {
+  maybeConsolidate,
+  resetConsolidationState,
+  DEFAULT_AUTO_CONSOLIDATION_CONFIG,
+  type AutoConsolidationConfig,
+} from "../auto-consolidation.js";
+import type { MemoryEntry, MemorySearchResult } from "../store.js";
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function makeEntry(id: string, text: string, overrides: Partial<MemoryEntry> = {}): MemoryEntry {
+  return {
+    id,
+    text,
+    vector: [1, 0, 0],
+    category: "events",
+    scope: "project:test",
+    importance: 0.7,
+    timestamp: Date.now(),
+    metadata: "{}",
+    ...overrides,
+  };
+}
+
+function createMockStore(entries: MemoryEntry[]) {
+  const data = new Map(entries.map(e => [e.id, { ...e }]));
+  return {
+    async list(scopeFilter?: string[], _category?: string, limit = 500, _offset = 0) {
+      return [...data.values()]
+        .filter(e => !scopeFilter || scopeFilter.some(s => e.scope === s))
+        .slice(0, limit);
+    },
+    async getById(id: string) {
+      return data.get(id) ?? null;
+    },
+    async vectorSearch(_vector: number[], _limit = 5, _minScore = 0.3, _scopeFilter?: string[]) {
+      return [] as MemorySearchResult[];
+    },
+    async update(id: string, updates: any, _scopeFilter?: string[]) {
+      const entry = data.get(id);
+      if (!entry) return null;
+      Object.assign(entry, updates);
+      return entry;
+    },
+    async stats(scopeFilter?: string[]) {
+      const filtered = [...data.values()].filter(
+        e => !scopeFilter || scopeFilter.some(s => e.scope === s),
+      );
+      return { totalCount: filtered.length, scopeCounts: {}, categoryCounts: {} };
+    },
+    hasFtsSupport: false,
+  } as any;
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe("auto-consolidation", () => {
+  beforeEach(() => {
+    resetConsolidationState();
+  });
+
+  it("skips when not enough new memories", async () => {
+    const entries = Array.from({ length: 10 }, (_, i) =>
+      makeEntry(`id-${i}`, `memory ${i}`),
+    );
+    const store = createMockStore(entries);
+
+    const result = await maybeConsolidate(store, "project:test");
+    expect(result.triggered).toBe(false);
+    expect(result.reason).toBe("insufficient_new_memories");
+  });
+
+  it("skips when too soon since last run", async () => {
+    // Start with 60 entries, trigger first run, then grow to 120 so
+    // the memory-count gate passes but the time gate blocks.
+    const data: MemoryEntry[] = Array.from({ length: 60 }, (_, i) =>
+      makeEntry(`id-${i}`, `memory ${i}`),
+    );
+    const store = createMockStore(data);
+
+    const config: AutoConsolidationConfig = {
+      minNewMemories: 50,
+      minHoursSinceLastRun: 12,
+      consolidation: DEFAULT_AUTO_CONSOLIDATION_CONFIG.consolidation,
+    };
+
+    // First run: triggers (never run before, 60 > 50 new memories)
+    const first = await maybeConsolidate(store, "project:test", config);
+    expect(first.triggered).toBe(true);
+
+    // Grow the store so memory-count gate would pass
+    for (let i = 60; i < 120; i++) {
+      data.push(makeEntry(`id-${i}`, `memory ${i}`));
+    }
+    const bigStore = createMockStore(data);
+
+    // Second run immediately: time gate blocks (< 12 hours)
+    const second = await maybeConsolidate(bigStore, "project:test", config);
+    expect(second.triggered).toBe(false);
+    expect(second.reason).toBe("too_soon");
+  });
+
+  it("triggers when both conditions met", async () => {
+    const entries = Array.from({ length: 60 }, (_, i) =>
+      makeEntry(`id-${i}`, `memory ${i}`),
+    );
+    const store = createMockStore(entries);
+
+    const config: AutoConsolidationConfig = {
+      minNewMemories: 50,
+      minHoursSinceLastRun: 0, // disable time gate for test
+      consolidation: {
+        clusterThreshold: 0.82,
+        mergeThreshold: 0.92,
+        maxEntriesPerRun: 500,
+      },
+    };
+
+    const result = await maybeConsolidate(store, "project:test", config);
+    expect(result.triggered).toBe(true);
+    expect(result.consolidation).toBeDefined();
+    expect(result.consolidation!.scope).toBe("project:test");
+  });
+
+  it("returns consolidation result when triggered", async () => {
+    const entries = Array.from({ length: 60 }, (_, i) =>
+      makeEntry(`id-${i}`, `memory ${i}`),
+    );
+    const store = createMockStore(entries);
+
+    const config: AutoConsolidationConfig = {
+      minNewMemories: 50,
+      minHoursSinceLastRun: 0,
+      consolidation: {
+        clusterThreshold: 0.82,
+        mergeThreshold: 0.92,
+        maxEntriesPerRun: 500,
+      },
+    };
+
+    const result = await maybeConsolidate(store, "project:test", config);
+    expect(result.triggered).toBe(true);
+    expect(result.consolidation!.originalCount).toBe(60);
+  });
+
+  it("respects custom thresholds", async () => {
+    const entries = Array.from({ length: 200 }, (_, i) =>
+      makeEntry(`id-${i}`, `memory ${i}`),
+    );
+    const store = createMockStore(entries);
+
+    const config: AutoConsolidationConfig = {
+      minNewMemories: 300, // higher than available
+      minHoursSinceLastRun: 0,
+      consolidation: DEFAULT_AUTO_CONSOLIDATION_CONFIG.consolidation,
+    };
+
+    const result = await maybeConsolidate(store, "project:test", config);
+    expect(result.triggered).toBe(false);
+    expect(result.reason).toBe("insufficient_new_memories");
+  });
+});

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

@@ -0,0 +1,131 @@
+import { describe, expect, it } from "bun:test";
+
+import { runAutoRecall } from "../auto-recall.js";
+import type { RetrievalContext, RetrievalResult } from "../retriever.js";
+import type { SessionCheckpointRecord } from "../session-schema.js";
+
+function buildResult(id: string, category: "profile" | "preferences" | "entities" | "patterns" | "cases" | "events", text: string, scope = "project:test"): RetrievalResult {
+  return {
+    entry: {
+      id,
+      text,
+      vector: [],
+      category,
+      scope,
+      importance: 0.8,
+      timestamp: Date.parse("2026-03-17T00:00:00.000Z"),
+      metadata: "{}",
+    },
+    score: 0.9,
+    sources: {
+      fused: { score: 0.9 },
+    },
+  };
+}
+
+describe("runAutoRecall", () => {
+  it("reuses an explicit scope for focused recall after composing resume context", async () => {
+    const calls: RetrievalContext[] = [];
+    const retriever = {
+      async retrieve(context: RetrievalContext): Promise<RetrievalResult[]> {
+        calls.push(context);
+        if (context.category === "profile") {
+          return [buildResult("profile-1", "profile", "Profile: RecallNest maintainer.", "project:alpha")];
+        }
+        if (!context.category) {
+          return [buildResult("event-1", "events", "RecallNest uses Weibull decay.", "project:alpha")];
+        }
+        return [];
+      },
+    };
+
+    const response = await runAutoRecall({
+      retriever,
+      checkpointStore: { async getLatest() { return null; } },
+      listPins: () => [],
+    }, {
+      message: "那个衰减曲线用的什么公式来着",
+      scope: "project:alpha",
+      limit: 5,
+      profile: "default",
+      operation: "test:auto-recall",
+    });
+
+    expect(response.mode).toBe("resume+search");
+    expect(response.resolvedScope).toBe("project:alpha");
+    expect(response.results[0]?.entry.id).toBe("event-1");
+    const searchCall = calls.find((call) => !call.category);
+    expect(searchCall?.scopeFilter).toEqual(["project:alpha"]);
+    expect(searchCall?.source).toBe("auto-recall");
+  });
+
+  it("uses the checkpoint-resolved scope when the request only carries sessionId", async () => {
+    const calls: RetrievalContext[] = [];
+    const checkpoint: SessionCheckpointRecord = {
+      checkpointId: "checkpoint-1",
+      sessionId: "session-123",
+      resolvedScope: "project:recallnest",
+      summary: "Continue proactive recall work.",
+      task: "Implement auto recall route",
+      decisions: [],
+      openLoops: [],
+      nextActions: [],
+      entities: [],
+      files: [],
+      updatedAt: "2026-03-17T10:00:00.000Z",
+    };
+
+    const retriever = {
+      async retrieve(context: RetrievalContext): Promise<RetrievalResult[]> {
+        calls.push(context);
+        if (!context.category) {
+          return [buildResult("event-1", "events", "Add a true auto recall route.", "project:recallnest")];
+        }
+        return [];
+      },
+    };
+
+    const response = await runAutoRecall({
+      retriever,
+      checkpointStore: {
+        async getLatest(query?: { sessionId?: string }) {
+          return query?.sessionId === "session-123" ? checkpoint : null;
+        },
+      },
+      listPins: () => [],
+    }, {
+      message: "继续做主动 recall",
+      sessionId: "session-123",
+      operation: "test:auto-recall",
+    });
+
+    expect(response.resolvedScope).toBe("project:recallnest");
+    expect(response.resume.latestCheckpoint?.resolvedScope).toBe("project:recallnest");
+    const searchCall = calls.find((call) => !call.category);
+    expect(searchCall?.scopeFilter).toEqual(["project:recallnest"]);
+  });
+
+  it("falls back to resume-only mode when no scope can be inferred for focused search", async () => {
+    const calls: RetrievalContext[] = [];
+    const retriever = {
+      async retrieve(context: RetrievalContext): Promise<RetrievalResult[]> {
+        calls.push(context);
+        return [];
+      },
+    };
+
+    const response = await runAutoRecall({
+      retriever,
+      checkpointStore: { async getLatest() { return null; } },
+      listPins: () => [],
+    }, {
+      message: "what do you remember about this",
+      operation: "test:auto-recall",
+    });
+
+    expect(response.mode).toBe("resume-only");
+    expect(response.results).toHaveLength(0);
+    expect(response.searchSkippedReason).toContain("No explicit or inferred scope");
+    expect(calls.some((call) => !call.category)).toBe(false);
+  });
+});