recallnest 1.4.1 → 2.2.0

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

@@ -0,0 +1,227 @@
+import { describe, expect, it } from "bun:test";
+
+import {
+  GovernorSession,
+  governResults,
+  resolveGovernorConfig,
+  truncateQuery,
+} from "../recall-governor.js";
+import type { RetrievalResult } from "../retriever.js";
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function makeResult(
+  id: string,
+  text: string,
+  score: number,
+  metadata = "{}",
+): RetrievalResult {
+  return {
+    entry: {
+      id,
+      text,
+      vector: [],
+      category: "events",
+      scope: "project:test",
+      importance: 0.8,
+      timestamp: Date.now(),
+      metadata,
+    },
+    score,
+    sources: { fused: { score } },
+  };
+}
+
+// ---------------------------------------------------------------------------
+// truncateQuery
+// ---------------------------------------------------------------------------
+
+describe("truncateQuery", () => {
+  it("returns query unchanged when within limit", () => {
+    expect(truncateQuery("short", 1000)).toBe("short");
+  });
+
+  it("truncates query exceeding maxQueryChars", () => {
+    const long = "a".repeat(2000);
+    const result = truncateQuery(long, 500);
+    expect(result.length).toBe(500);
+  });
+
+  it("handles exact boundary", () => {
+    const exact = "x".repeat(100);
+    expect(truncateQuery(exact, 100)).toBe(exact);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// resolveGovernorConfig
+// ---------------------------------------------------------------------------
+
+describe("resolveGovernorConfig", () => {
+  it("returns defaults when no overrides", () => {
+    const cfg = resolveGovernorConfig();
+    expect(cfg.maxQueryChars).toBe(1000);
+    expect(cfg.charBudget).toBe(8000);
+    expect(cfg.maxItems).toBe(10);
+  });
+
+  it("merges partial overrides", () => {
+    const cfg = resolveGovernorConfig({ charBudget: 4000 });
+    expect(cfg.charBudget).toBe(4000);
+    expect(cfg.maxItems).toBe(10); // unchanged
+  });
+});
+
+// ---------------------------------------------------------------------------
+// GovernorSession
+// ---------------------------------------------------------------------------
+
+describe("GovernorSession", () => {
+  it("tracks injected IDs", () => {
+    const session = new GovernorSession();
+    expect(session.wasInjected("a")).toBe(false);
+    session.markInjected("a");
+    expect(session.wasInjected("a")).toBe(true);
+    expect(session.size).toBe(1);
+  });
+
+  it("markAll registers all result IDs", () => {
+    const session = new GovernorSession();
+    const results = [makeResult("x", "hi", 0.9), makeResult("y", "hello", 0.8)];
+    session.markAll(results);
+    expect(session.wasInjected("x")).toBe(true);
+    expect(session.wasInjected("y")).toBe(true);
+    expect(session.size).toBe(2);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// governResults — evolution state filter
+// ---------------------------------------------------------------------------
+
+describe("governResults — evolution filter", () => {
+  it("keeps active memories", () => {
+    const results = [makeResult("a1", "active memory", 0.9, '{"evolution":{"status":"active"}}')];
+    const governed = governResults(results);
+    expect(governed).toHaveLength(1);
+  });
+
+  it("keeps pending_review memories", () => {
+    const results = [makeResult("p1", "pending review", 0.9, '{"evolution":{"status":"pending_review"}}')];
+    const governed = governResults(results);
+    expect(governed).toHaveLength(1);
+  });
+
+  it("drops archived memories", () => {
+    const results = [makeResult("ar1", "archived", 0.9, '{"evolution":{"status":"archived"}}')];
+    const governed = governResults(results);
+    expect(governed).toHaveLength(0);
+  });
+
+  it("drops superseded memories", () => {
+    const results = [makeResult("s1", "superseded", 0.9, '{"evolution":{"status":"superseded"}}')];
+    const governed = governResults(results);
+    expect(governed).toHaveLength(0);
+  });
+
+  it("keeps memories with no evolution (defaults to active)", () => {
+    const results = [makeResult("n1", "no status", 0.9, "{}")];
+    const governed = governResults(results);
+    expect(governed).toHaveLength(1);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// governResults — budget control
+// ---------------------------------------------------------------------------
+
+describe("governResults — budget control", () => {
+  it("respects maxItems limit", () => {
+    const results = Array.from({ length: 5 }, (_, i) =>
+      makeResult(`b${i}`, "x".repeat(10), 0.9 - i * 0.01),
+    );
+    const governed = governResults(results, undefined, { maxItems: 3 });
+    expect(governed).toHaveLength(3);
+  });
+
+  it("respects charBudget limit", () => {
+    const results = [
+      makeResult("c1", "a".repeat(3000), 0.95),
+      makeResult("c2", "b".repeat(3000), 0.90),
+      makeResult("c3", "c".repeat(3000), 0.85),
+    ];
+    const governed = governResults(results, undefined, { charBudget: 5000 });
+    // First item (3000) fits, second (6000 total) would exceed 5000 → stops after first
+    expect(governed).toHaveLength(1);
+  });
+
+  it("always allows at least one result even if it exceeds budget", () => {
+    const results = [makeResult("big", "x".repeat(10000), 0.95)];
+    const governed = governResults(results, undefined, { charBudget: 100 });
+    expect(governed).toHaveLength(1);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// governResults — session dedup
+// ---------------------------------------------------------------------------
+
+describe("governResults — session dedup", () => {
+  it("drops already-injected IDs", () => {
+    const session = new GovernorSession();
+    session.markInjected("dup1");
+
+    const results = [
+      makeResult("dup1", "already seen", 0.95),
+      makeResult("new1", "fresh memory", 0.90),
+    ];
+    const governed = governResults(results, session);
+    expect(governed).toHaveLength(1);
+    expect(governed[0].entry.id).toBe("new1");
+  });
+
+  it("marks newly governed results in the session", () => {
+    const session = new GovernorSession();
+    const results = [makeResult("x1", "hello", 0.9)];
+    governResults(results, session);
+    expect(session.wasInjected("x1")).toBe(true);
+  });
+
+  it("skips dedup when no session provided", () => {
+    const results = [makeResult("a", "text", 0.9), makeResult("a", "text", 0.8)];
+    // Without session, same ID can appear (though unusual from retriever)
+    const governed = governResults(results);
+    expect(governed).toHaveLength(2);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// governResults — empty input
+// ---------------------------------------------------------------------------
+
+describe("governResults — edge cases", () => {
+  it("returns empty array for empty input", () => {
+    expect(governResults([])).toHaveLength(0);
+  });
+
+  it("composes all layers correctly", () => {
+    const session = new GovernorSession();
+    session.markInjected("already");
+
+    const results = [
+      makeResult("already", "seen before", 0.99),                                     // dedup
+      makeResult("archived", "old", 0.95, '{"evolution":{"status":"archived"}}'),        // evolution
+      makeResult("keep1", "a".repeat(4000), 0.90),                                    // kept
+      makeResult("keep2", "b".repeat(4000), 0.85),                                    // kept
+      makeResult("over-budget", "c".repeat(4000), 0.80),                              // budget
+    ];
+    const governed = governResults(results, session, { charBudget: 8000 });
+    // archived dropped by evolution, already dropped by dedup,
+    // keep1 (4000) + keep2 (8000) = at budget, over-budget dropped
+    expect(governed.map((r) => r.entry.id)).toEqual(["keep1", "keep2"]);
+    expect(session.wasInjected("keep1")).toBe(true);
+    expect(session.wasInjected("keep2")).toBe(true);
+  });
+});

package/src/__tests__/resume-context.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, it } from "bun:test";
 
-import { composeResumeContext } from "../context-composer.js";
+import { composeLightResumeContext, composeResumeContext } from "../context-composer.js";
 import type { RetrievalContext, RetrievalResult } from "../retriever.js";
 import type { SessionCheckpointRecord } from "../session-schema.js";
 
@@ -4741,3 +4741,158 @@ describe("composeResumeContext", () => {
     expect(response.relevantPatterns.join(" ")).toContain("resume_context");
   });
 });
+
+// ---------------------------------------------------------------------------
+// MP-3: composeLightResumeContext — Ultra-Light Wake-up Mode
+// ---------------------------------------------------------------------------
+
+describe("composeLightResumeContext", () => {
+  const checkpoint: SessionCheckpointRecord = {
+    checkpointId: "cp-light-1",
+    sessionId: "session-light",
+    resolvedScope: "project:recallnest",
+    summary: "Implemented LME-9 circuit breaker for LLM degradation",
+    task: "LME-9 circuit breaker",
+    decisions: ["Three-layer degradation"],
+    openLoops: ["Soak test pending"],
+    nextActions: ["Run full eval"],
+    entities: ["RecallNest"],
+    files: ["src/llm-client.ts"],
+    updatedAt: "2026-04-06T10:00:00.000Z",
+  };
+
+  it("returns checkpoint summary and stable memories under token budget", async () => {
+    const retriever = {
+      async retrieve(): Promise<RetrievalResult[]> {
+        return [
+          buildResult("p1", "profile", "User builds local-first memory systems with RecallNest."),
+          buildResult("pref1", "preferences", "User prefers concise technical replies without fluff."),
+          buildResult("e1", "entities", "RecallNest is a cross-terminal shared memory layer."),
+        ];
+      },
+    };
+
+    const result = await composeLightResumeContext({
+      retriever,
+      checkpointStore: { async getLatest() { return checkpoint; } },
+      listPins: () => [],
+    }, {
+      task: "继续 RecallNest 项目",
+      scope: "project:recallnest",
+      includeLatestCheckpoint: true,
+      limitPerSection: 3,
+    });
+
+    expect(result.text).toContain("session-light");
+    expect(result.text).toContain("LME-9");
+    expect(result.text).toContain("resume_context(mode='full')");
+    expect(result.resolvedScope).toBe("project:recallnest");
+    expect(result.generatedAt).toBeTruthy();
+    // Budget check: <300 tokens ≈ <1200 chars
+    expect(result.text.length).toBeLessThan(1200);
+  });
+
+  it("works without checkpoint", async () => {
+    const retriever = {
+      async retrieve(): Promise<RetrievalResult[]> {
+        return [
+          buildResult("p1", "profile", "Data scientist working on observability."),
+        ];
+      },
+    };
+
+    const result = await composeLightResumeContext({
+      retriever,
+      checkpointStore: { async getLatest() { return null; } },
+      listPins: () => [],
+    }, {
+      includeLatestCheckpoint: true,
+      limitPerSection: 3,
+    });
+
+    expect(result.text).not.toContain("Last session");
+    expect(result.text).toContain("observability");
+    expect(result.text).toContain("resume_context(mode='full')");
+  });
+
+  it("includes pin assets as stable context", async () => {
+    const retriever = {
+      async retrieve(): Promise<RetrievalResult[]> {
+        return [];
+      },
+    };
+
+    const result = await composeLightResumeContext({
+      retriever,
+      checkpointStore: { async getLatest() { return checkpoint; } },
+      listPins: () => [{
+        path: "/tmp/pin1.md",
+        title: "Auth migration decision",
+        summary: "Session tokens must comply with new legal requirements",
+        pinId: "pin-1",
+        memoryId: "mem-1",
+        createdAt: "2026-04-01T00:00:00.000Z",
+      }],
+    }, {
+      scope: "project:recallnest",
+      includeLatestCheckpoint: true,
+      limitPerSection: 3,
+    });
+
+    expect(result.text).toContain("legal requirements");
+  });
+
+  it("deduplicates pin content from stable memories", async () => {
+    const retriever = {
+      async retrieve(): Promise<RetrievalResult[]> {
+        return [
+          buildResult("dup1", "profile", "Session tokens must comply with new legal requirements"),
+        ];
+      },
+    };
+
+    const result = await composeLightResumeContext({
+      retriever,
+      checkpointStore: { async getLatest() { return null; } },
+      listPins: () => [{
+        path: "/tmp/pin1.md",
+        title: "Auth migration",
+        summary: "Session tokens must comply with new legal requirements",
+        pinId: "pin-1",
+        memoryId: "mem-1",
+        createdAt: "2026-04-01T00:00:00.000Z",
+      }],
+    }, {
+      includeLatestCheckpoint: true,
+      limitPerSection: 3,
+    });
+
+    // Should not have duplicate entries
+    const matches = result.text.match(/legal requirements/g);
+    expect(matches?.length).toBeLessThanOrEqual(1);
+  });
+
+  it("respects scope from input over checkpoint", async () => {
+    const calls: RetrievalContext[] = [];
+    const retriever = {
+      async retrieve(ctx: RetrievalContext): Promise<RetrievalResult[]> {
+        calls.push(ctx);
+        return [];
+      },
+    };
+
+    const result = await composeLightResumeContext({
+      retriever,
+      checkpointStore: { async getLatest() { return checkpoint; } },
+      listPins: () => [],
+    }, {
+      scope: "project:custom",
+      includeLatestCheckpoint: true,
+      limitPerSection: 3,
+    });
+
+    expect(result.resolvedScope).toBe("project:custom");
+    // retrieveCandidates fires scoped + global in parallel; at least one must have the scope filter
+    expect(calls.some(c => c.scopeFilter?.includes("project:custom"))).toBe(true);
+  });
+});

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

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