recallnest 2.6.1 → 3.0.1

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

@@ -1,206 +0,0 @@
-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

@@ -1,67 +0,0 @@
-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__/api-server-security.test.ts

@@ -1,102 +0,0 @@
-import { describe, expect, test } from "bun:test";
-
-import {
-  enforceLocalHttpRequestPolicy,
-  LOCAL_JSON_BODY_LIMIT_BYTES,
-} from "../http-request-policy.js";
-
-function apiRequest({
-  method = "GET",
-  host = "localhost:4318",
-  headers = {},
-  body,
-}: {
-  method?: string;
-  host?: string;
-  headers?: Record<string, string>;
-  body?: string;
-} = {}): Request {
-  return new Request("http://localhost:4318/v1/store", {
-    method,
-    headers: { host, ...headers },
-    body,
-  });
-}
-
-describe("RecallNest API local HTTP policy", () => {
-  test("keeps local CLI JSON requests without Origin usable", async () => {
-    const result = await enforceLocalHttpRequestPolicy(apiRequest({
-      method: "POST",
-      headers: { "content-type": "application/json" },
-      body: JSON.stringify({ text: "local CLI", scope: "test:local" }),
-    }));
-
-    expect(result).toEqual({ allowed: true });
-  });
-
-  test("allows loopback GET requests without browser headers", async () => {
-    const result = await enforceLocalHttpRequestPolicy(apiRequest());
-
-    expect(result).toEqual({ allowed: true });
-  });
-
-  test("rejects malformed or non-local Host headers", async () => {
-    const malformed = await enforceLocalHttpRequestPolicy(apiRequest({ host: "localhost@attacker.example" }));
-    const nonLocal = await enforceLocalHttpRequestPolicy(apiRequest({ host: "192.168.1.10:4318" }));
-
-    expect(malformed).toEqual({ allowed: false, status: 403, message: "Host is not allowed." });
-    expect(nonLocal).toEqual({ allowed: false, status: 403, message: "Host is not allowed." });
-  });
-
-  test("rejects opaque origins and same-site cross-origin requests", async () => {
-    const opaqueOrigin = await enforceLocalHttpRequestPolicy(apiRequest({
-      headers: { origin: "null" },
-    }));
-    const sameSite = await enforceLocalHttpRequestPolicy(apiRequest({
-      headers: { "sec-fetch-site": "same-site" },
-    }));
-
-    expect(opaqueOrigin).toEqual({ allowed: false, status: 403, message: "Origin is not allowed." });
-    expect(sameSite).toEqual({ allowed: false, status: 403, message: "Cross-site requests are not allowed." });
-  });
-
-  test("requires application/json for API POST requests", async () => {
-    const missing = await enforceLocalHttpRequestPolicy(apiRequest({
-      method: "POST",
-      body: "{}",
-    }));
-    const form = await enforceLocalHttpRequestPolicy(apiRequest({
-      method: "POST",
-      headers: { "content-type": "application/x-www-form-urlencoded" },
-      body: "text=example",
-    }));
-
-    expect(missing).toEqual({
-      allowed: false,
-      status: 415,
-      message: "Content-Type must be application/json.",
-    });
-    expect(form).toEqual({
-      allowed: false,
-      status: 415,
-      message: "Content-Type must be application/json.",
-    });
-  });
-
-  test("rejects declared JSON bodies over the limit before route handling", async () => {
-    const result = await enforceLocalHttpRequestPolicy(apiRequest({
-      method: "POST",
-      headers: {
-        "content-type": "application/json",
-        "content-length": String(LOCAL_JSON_BODY_LIMIT_BYTES + 1),
-      },
-      body: "{}",
-    }));
-
-    expect(result).toEqual({
-      allowed: false,
-      status: 413,
-      message: `Request body exceeds ${LOCAL_JSON_BODY_LIMIT_BYTES} bytes.`,
-    });
-  });
-});

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

@@ -1,168 +0,0 @@
-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

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