recallnest 3.0.0 → 3.0.1

package/src/__tests__/retriever-boundary-weight.test.ts

@@ -1,136 +0,0 @@
-import { describe, expect, it } from "bun:test";
-
-import { createRetriever } from "../retriever.js";
-
-function buildEntry(id: string, scoreText: string, scope: string, metadata: Record<string, unknown>) {
-  return {
-    entry: {
-      id,
-      text: scoreText,
-      vector: [1, 0, 0],
-      category: "preferences",
-      scope,
-      importance: 0.8,
-      timestamp: Date.parse("2026-03-16T00:00:00.000Z"),
-      metadata: JSON.stringify(metadata),
-    },
-    score: 0.8,
-  };
-}
-
-describe("retriever provenance weighting", () => {
-  it("prefers durable structured memories over evidence when scores are close", async () => {
-    const retriever = createRetriever({
-      hasFtsSupport: false,
-      async vectorSearch() {
-        return [
-          {
-            ...buildEntry("evidence-1", "Transcript hint", "cc:session1", {
-              source: "cc",
-              boundary: {
-                layer: "evidence",
-                authority: "transcript-ingest",
-                conflictPolicy: "append-only",
-                originalCategory: "preferences",
-              },
-            }),
-            score: 0.8,
-          },
-          {
-            ...buildEntry("durable-1", "Curated durable preference", "memory:agent", {
-              source: "agent",
-              boundary: {
-                layer: "durable",
-                authority: "structured-memory",
-                conflictPolicy: "latest-wins",
-                originalCategory: "preferences",
-              },
-            }),
-            score: 0.79,
-          },
-        ];
-      },
-    } as any, {
-      async embedQuery() {
-        return [1, 0, 0];
-      },
-      async embedPassage() {
-        return [1, 0, 0];
-      },
-    } as any, {
-      mode: "vector",
-      rerank: "none",
-      filterNoise: false,
-      hardMinScore: 0,
-      minScore: 0,
-      recencyWeight: 0,
-      timeDecayHalfLifeDays: 0,
-    });
-
-    const results = await retriever.retrieve({
-      query: "user reply style preference",
-      limit: 5,
-      category: "preferences",
-    });
-
-    expect(results[0]?.entry.id).toBe("durable-1");
-    expect(results[1]?.entry.id).toBe("evidence-1");
-  });
-
-  it("does not override clearly stronger relevance with provenance weighting", async () => {
-    const retriever = createRetriever({
-      hasFtsSupport: false,
-      async vectorSearch() {
-        return [
-          {
-            ...buildEntry("evidence-strong", "Very strong transcript evidence", "cc:session1", {
-              source: "cc",
-              boundary: {
-                layer: "evidence",
-                authority: "transcript-ingest",
-                conflictPolicy: "append-only",
-                originalCategory: "preferences",
-              },
-            }),
-            score: 0.95,
-          },
-          {
-            ...buildEntry("durable-weaker", "Weaker durable preference", "memory:agent", {
-              source: "agent",
-              boundary: {
-                layer: "durable",
-                authority: "structured-memory",
-                conflictPolicy: "latest-wins",
-                originalCategory: "preferences",
-              },
-            }),
-            score: 0.7,
-          },
-        ];
-      },
-    } as any, {
-      async embedQuery() {
-        return [1, 0, 0];
-      },
-      async embedPassage() {
-        return [1, 0, 0];
-      },
-    } as any, {
-      mode: "vector",
-      rerank: "none",
-      filterNoise: false,
-      hardMinScore: 0,
-      minScore: 0,
-      recencyWeight: 0,
-      timeDecayHalfLifeDays: 0,
-    });
-
-    const results = await retriever.retrieve({
-      query: "user reply style preference",
-      limit: 5,
-      category: "preferences",
-    });
-
-    expect(results[0]?.entry.id).toBe("evidence-strong");
-  });
-});

package/src/__tests__/retriever-lazy-init-dispatch.test.ts

@@ -1,123 +0,0 @@
-import { describe, expect, it } from "bun:test";
-
-import { createRetriever } from "../retriever.js";
-
-/**
- * 回归：retrieve() 在分派前必须等 store 完成惰性初始化。
- *
- * 真实 MemoryStore 的 hasFtsSupport 在 ensureInitialized() 跑完前恒为 false
- * （ftsIndexCreated 初值 false，建索引发生在 doInitialize 里）。retriever.ts 的
- * 分派条件是 `mode === "vector" || !this.store.hasFtsSupport`，若不先 await
- * store.ready()，hybrid 模式的**首次**检索会读到初始化前的 false 并静默落回
- * vector 路径——同一实例第二次才正常。
- *
- * 该缺陷自 c10607a（2026-03-03 初始版本）就在，长期未暴露：生产 mode 一直是
- * "vector"，第一个条件短路；而 eval 每 case 新建组件，每个 case 都停在"首次"，
- * 于是 eval 从未测到过 hybrid 路径。
- *
- * 下面的 fake store 用 getter + ready() 精确复现这个时序：不修复则 bm25Search
- * 不会被调用。
- */
-function buildResult(id: string, text: string) {
-  return {
-    entry: {
-      id,
-      text,
-      vector: [1, 0, 0],
-      category: "preferences",
-      scope: "memory:test",
-      importance: 0.8,
-      timestamp: Date.parse("2026-08-07T00:00:00.000Z"),
-      metadata: JSON.stringify({}),
-    },
-    score: 0.8,
-  };
-}
-
-const fakeEmbedder = {
-  async embedQuery() {
-    return [1, 0, 0];
-  },
-  async embedPassage() {
-    return [1, 0, 0];
-  },
-} as any;
-
-function buildLazyStore() {
-  const calls = { bm25: 0, vector: 0, ready: 0 };
-  let initialized = false;
-
-  const store = {
-    // 复现真实时序：初始化完成前恒 false
-    get hasFtsSupport() {
-      return initialized;
-    },
-    async ready() {
-      calls.ready += 1;
-      initialized = true;
-    },
-    async vectorSearch() {
-      calls.vector += 1;
-      return [buildResult("vec-1", "vector hit")];
-    },
-    async bm25Search() {
-      calls.bm25 += 1;
-      return [buildResult("bm25-1", "bm25 hit")];
-    },
-  };
-
-  return { store, calls };
-}
-
-const LOOSE_CONFIG = {
-  rerank: "none" as const,
-  filterNoise: false,
-  hardMinScore: 0,
-  minScore: 0,
-  recencyWeight: 0,
-  timeDecayHalfLifeDays: 0,
-};
-
-describe("retrieve() 分派与 store 惰性初始化的时序", () => {
-  it("hybrid 模式的首次检索不因惰性初始化落回 vector 路径", async () => {
-    const { store, calls } = buildLazyStore();
-    const retriever = createRetriever(store as any, fakeEmbedder, {
-      ...LOOSE_CONFIG,
-      mode: "hybrid",
-    });
-
-    await retriever.retrieve({ query: "双机契约 同步", limit: 5 });
-
-    // 修复前：hasFtsSupport 读到初始化前的 false → 落回 vectorOnly → bm25 为 0。
-    expect(calls.ready).toBeGreaterThan(0);
-    expect(calls.bm25).toBeGreaterThan(0);
-  });
-
-  it("vector 模式不受影响——短路在第一个条件，不走 BM25", async () => {
-    const { store, calls } = buildLazyStore();
-    const retriever = createRetriever(store as any, fakeEmbedder, {
-      ...LOOSE_CONFIG,
-      mode: "vector",
-    });
-
-    await retriever.retrieve({ query: "双机契约 同步", limit: 5 });
-
-    // 这条守的是"修复不得改变生产行为"：生产 mode 就是 vector。
-    expect(calls.bm25).toBe(0);
-    expect(calls.vector).toBeGreaterThan(0);
-  });
-
-  it("琐碎 query 走 skip 分支时不触发初始化", async () => {
-    const { store, calls } = buildLazyStore();
-    const retriever = createRetriever(store as any, fakeEmbedder, {
-      ...LOOSE_CONFIG,
-      mode: "hybrid",
-    });
-
-    // shouldSkipRetrieval 在分派之前提前 return，await ready() 不该被执行到。
-    await retriever.retrieve({ query: "ok", limit: 5 });
-
-    expect(calls.ready).toBe(0);
-    expect(calls.vector).toBe(0);
-  });
-});

package/src/__tests__/retroactive-boost.test.ts

@@ -1,223 +0,0 @@
-import { describe, expect, it } from "bun:test";
-
-import {
-  retroactiveBoost,
-  DEFAULT_RETROACTIVE_BOOST_CONFIG,
-  type RetroactiveBoostConfig,
-} from "../retroactive-boost.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.5,
-    timestamp: Date.now() - 7 * 86_400_000, // 7 days old by default
-    metadata: "{}",
-    ...overrides,
-  };
-}
-
-function createMockStore(
-  entries: MemoryEntry[],
-  searchResults: MemorySearchResult[] = [],
-) {
-  const data = new Map(entries.map(e => [e.id, { ...e }]));
-  const updates: Array<{ id: string; importance?: number; metadata?: string }> = [];
-
-  return {
-    updates,
-    data,
-    async vectorSearch(_vector: number[], limit = 5, minScore = 0.3, _scopeFilter?: string[]) {
-      return searchResults.filter(r => r.score >= minScore).slice(0, limit);
-    },
-    async update(id: string, upd: any, _scopeFilter?: string[]) {
-      const entry = data.get(id);
-      if (!entry) return null;
-      if (upd.importance !== undefined) entry.importance = upd.importance;
-      if (upd.metadata !== undefined) entry.metadata = upd.metadata;
-      updates.push({ id, ...upd });
-      return entry;
-    },
-  } as any;
-}
-
-// ---------------------------------------------------------------------------
-// Tests
-// ---------------------------------------------------------------------------
-
-describe("retroactive-boost (STC)", () => {
-  it("skips when new entry has low importance", async () => {
-    const store = createMockStore([]);
-    const newEntry = makeEntry("new-1", "low importance note", { importance: 0.5 });
-
-    const result = await retroactiveBoost(store, newEntry);
-    expect(result.triggered).toBe(false);
-    expect(result.reason).toBe("below_importance_threshold");
-  });
-
-  it("skips when new entry has no vector", async () => {
-    const store = createMockStore([]);
-    const newEntry = makeEntry("new-1", "important note", {
-      importance: 0.9,
-      vector: [],
-    });
-
-    const result = await retroactiveBoost(store, newEntry);
-    expect(result.triggered).toBe(false);
-    expect(result.reason).toBe("no_vector");
-  });
-
-  it("boosts related low-importance old entries", async () => {
-    const oldEntry = makeEntry("old-1", "Singapore weather info", {
-      importance: 0.3,
-      timestamp: Date.now() - 30 * 86_400_000, // 30 days old
-    });
-    const searchResults: MemorySearchResult[] = [
-      { entry: oldEntry, score: 0.85 },
-    ];
-    const store = createMockStore([oldEntry], searchResults);
-
-    const newEntry = makeEntry("new-1", "I'm moving to Singapore", {
-      importance: 0.9,
-      vector: [1, 0, 0],
-    });
-
-    const result = await retroactiveBoost(store, newEntry);
-    expect(result.triggered).toBe(true);
-    expect(result.boostedCount).toBe(1);
-    expect(result.boostedIds).toContain("old-1");
-
-    // Verify the update was applied
-    expect(store.updates.length).toBe(1);
-    expect(store.updates[0].importance).toBe(0.3 + 0.15); // 0.45
-  });
-
-  it("does not boost entries that are already high importance", async () => {
-    const highEntry = makeEntry("high-1", "already important", {
-      importance: 0.7,
-      timestamp: Date.now() - 30 * 86_400_000,
-    });
-    const searchResults: MemorySearchResult[] = [
-      { entry: highEntry, score: 0.85 },
-    ];
-    const store = createMockStore([highEntry], searchResults);
-
-    const newEntry = makeEntry("new-1", "trigger", { importance: 0.9, vector: [1, 0, 0] });
-
-    const result = await retroactiveBoost(store, newEntry);
-    expect(result.triggered).toBe(true);
-    expect(result.boostedCount).toBe(0); // high-1 was already above threshold
-  });
-
-  it("does not boost very recent entries", async () => {
-    const recentEntry = makeEntry("recent-1", "just stored", {
-      importance: 0.3,
-      timestamp: Date.now() - 3_600_000, // 1 hour old
-    });
-    const searchResults: MemorySearchResult[] = [
-      { entry: recentEntry, score: 0.85 },
-    ];
-    const store = createMockStore([recentEntry], searchResults);
-
-    const newEntry = makeEntry("new-1", "trigger", { importance: 0.9, vector: [1, 0, 0] });
-
-    const result = await retroactiveBoost(store, newEntry);
-    expect(result.triggered).toBe(true);
-    expect(result.boostedCount).toBe(0); // too recent
-  });
-
-  it("caps boosted importance at maxBoostedImportance", async () => {
-    const oldEntry = makeEntry("old-1", "related note", {
-      importance: 0.55,
-      timestamp: Date.now() - 30 * 86_400_000,
-    });
-    const searchResults: MemorySearchResult[] = [
-      { entry: oldEntry, score: 0.85 },
-    ];
-    const store = createMockStore([oldEntry], searchResults);
-
-    const newEntry = makeEntry("new-1", "trigger", { importance: 0.9, vector: [1, 0, 0] });
-
-    const config: RetroactiveBoostConfig = {
-      ...DEFAULT_RETROACTIVE_BOOST_CONFIG,
-      boostAmount: 0.3,           // would push to 0.85
-      maxBoostedImportance: 0.75, // but capped at 0.75
-    };
-
-    const result = await retroactiveBoost(store, newEntry, config);
-    expect(result.boostedCount).toBe(1);
-    expect(store.updates[0].importance).toBe(0.75); // capped
-  });
-
-  it("promotes tier from peripheral to working when boosted above 0.5", async () => {
-    const oldEntry = makeEntry("old-1", "peripheral memory", {
-      importance: 0.3,
-      timestamp: Date.now() - 30 * 86_400_000,
-      metadata: JSON.stringify({ tier: "peripheral" }),
-    });
-    const searchResults: MemorySearchResult[] = [
-      { entry: oldEntry, score: 0.85 },
-    ];
-    const store = createMockStore([oldEntry], searchResults);
-
-    const newEntry = makeEntry("new-1", "important trigger", { importance: 0.9, vector: [1, 0, 0] });
-
-    const config: RetroactiveBoostConfig = {
-      ...DEFAULT_RETROACTIVE_BOOST_CONFIG,
-      boostAmount: 0.25, // 0.3 + 0.25 = 0.55 > 0.5
-    };
-
-    const result = await retroactiveBoost(store, newEntry, config);
-    expect(result.boostedCount).toBe(1);
-
-    // Check metadata for tier promotion
-    const updatedMeta = JSON.parse(store.updates[0].metadata);
-    expect(updatedMeta.tier).toBe("working");
-    expect(updatedMeta.stc_boosts).toHaveLength(1);
-    expect(updatedMeta.stc_boosts[0].triggeredBy).toBe("new-1".slice(0, 8));
-  });
-
-  it("respects maxBoostPerTrigger limit", async () => {
-    const entries: MemoryEntry[] = [];
-    const searchResults: MemorySearchResult[] = [];
-
-    for (let i = 0; i < 10; i++) {
-      const e = makeEntry(`old-${i}`, `entry ${i}`, {
-        importance: 0.3,
-        timestamp: Date.now() - 30 * 86_400_000,
-      });
-      entries.push(e);
-      searchResults.push({ entry: e, score: 0.85 - i * 0.01 });
-    }
-
-    const store = createMockStore(entries, searchResults);
-    const newEntry = makeEntry("new-1", "trigger", { importance: 0.9, vector: [1, 0, 0] });
-
-    const result = await retroactiveBoost(store, newEntry);
-    expect(result.boostedCount).toBe(5); // default maxBoostPerTrigger
-  });
-
-  it("skips self in search results", async () => {
-    const newEntry = makeEntry("new-1", "I'm important", {
-      importance: 0.9,
-      vector: [1, 0, 0],
-    });
-    // Search returns the new entry itself
-    const searchResults: MemorySearchResult[] = [
-      { entry: newEntry, score: 1.0 },
-    ];
-    const store = createMockStore([newEntry], searchResults);
-
-    const result = await retroactiveBoost(store, newEntry);
-    expect(result.triggered).toBe(true);
-    expect(result.boostedCount).toBe(0);
-  });
-});

package/src/__tests__/salience-scoring.test.ts

@@ -1,106 +0,0 @@
-import { describe, it, expect } from "bun:test";
-import type { LLMClient } from "../llm-client.js";
-
-function createMockLLM(response: string): LLMClient {
-  return {
-    async chat() {
-      return response;
-    },
-    async assessImportance(text: string) {
-      const parsed = JSON.parse(response);
-      return parsed.importance ?? null;
-    },
-    async reassessImportanceBatch(
-      entries: Array<{ id: string; text: string; category: string; currentImportance: number }>,
-    ) {
-      const results = new Map<string, number>();
-      try {
-        const parsed = JSON.parse(response);
-        if (Array.isArray(parsed)) {
-          for (const item of parsed) {
-            if (item.idx >= 0 && item.idx < entries.length) {
-              results.set(entries[item.idx].id, item.importance);
-            }
-          }
-        }
-      } catch {
-        // match real implementation: non-fatal
-      }
-      return results;
-    },
-  } as any;
-}
-
-describe("HP-4: Salience scoring anchoring", () => {
-  describe("assessImportance anchored tiers", () => {
-    it("identity/correction → 0.85+", async () => {
-      const llm = createMockLLM(JSON.stringify({ importance: 0.92, reason: "用户明确纠正" }));
-      const result = await llm.assessImportance("不要用 rm 删除文件", "profile");
-      expect(result).toBeGreaterThanOrEqual(0.85);
-    });
-
-    it("decision/case → 0.70-0.84", async () => {
-      const llm = createMockLLM(JSON.stringify({ importance: 0.75, reason: "架构决策" }));
-      const result = await llm.assessImportance("选用 LanceDB 作为向量存储", "cases");
-      expect(result).toBeGreaterThanOrEqual(0.70);
-      expect(result).toBeLessThan(0.85);
-    });
-
-    it("entity/background → 0.55-0.69", async () => {
-      const llm = createMockLLM(JSON.stringify({ importance: 0.60, reason: "项目信息" }));
-      const result = await llm.assessImportance("RecallNest 使用 Bun 运行时", "entities");
-      expect(result).toBeGreaterThanOrEqual(0.55);
-      expect(result).toBeLessThan(0.70);
-    });
-
-    it("event/one-off → 0.40-0.54", async () => {
-      const llm = createMockLLM(JSON.stringify({ importance: 0.45, reason: "一次性操作" }));
-      const result = await llm.assessImportance("今天部署了 v2.1", "events");
-      expect(result).toBeGreaterThanOrEqual(0.40);
-      expect(result).toBeLessThan(0.55);
-    });
-
-    it("chatter/temp → 0.10-0.30", async () => {
-      const llm = createMockLLM(JSON.stringify({ importance: 0.15, reason: "临时上下文" }));
-      const result = await llm.assessImportance("好的，我看一下", "events");
-      expect(result).toBeGreaterThanOrEqual(0.10);
-      expect(result).toBeLessThan(0.40);
-    });
-  });
-
-  describe("reassessImportanceBatch", () => {
-    it("returns adjusted entries with ≥ 0.1 delta", async () => {
-      const batchResponse = JSON.stringify([
-        { idx: 0, importance: 0.90 },
-        { idx: 2, importance: 0.30 },
-      ]);
-      const llm = createMockLLM(batchResponse);
-      const entries = [
-        { id: "a", text: "永远不要用 rm", category: "profile", currentImportance: 0.70 },
-        { id: "b", text: "选用 LanceDB", category: "cases", currentImportance: 0.75 },
-        { id: "c", text: "今天天气不错", category: "events", currentImportance: 0.70 },
-      ];
-      const result = await llm.reassessImportanceBatch(entries);
-      expect(result.size).toBe(2);
-      expect(result.get("a")).toBe(0.90);
-      expect(result.get("c")).toBe(0.30);
-      expect(result.has("b")).toBe(false);
-    });
-
-    it("returns empty map on empty input", async () => {
-      const llm = createMockLLM("[]");
-      const result = await llm.reassessImportanceBatch([]);
-      expect(result.size).toBe(0);
-    });
-
-    it("handles invalid LLM response gracefully", async () => {
-      const llm = createMockLLM("not-json");
-      const entries = [
-        { id: "a", text: "test", category: "events", currentImportance: 0.5 },
-      ];
-      // Should not throw
-      const result = await llm.reassessImportanceBatch(entries);
-      expect(result.size).toBe(0);
-    });
-  });
-});