recallnest 2.5.4 → 2.6.0

package/src/__tests__/conflict-store.test.ts

@@ -6,6 +6,7 @@ import { join } from "node:path";
 import { summarizeConflictAdvice } from "../conflict-advisor.js";
 import { buildConflictCandidateRecord, resolveConflictCandidate } from "../conflict-engine.js";
 import { ConflictCandidateStore } from "../conflict-store.js";
+import { parseEvolution } from "../memory-evolution.js";
 
 const tempDirs: string[] = [];
 
@@ -162,9 +163,11 @@ describe("resolveConflictCandidate", () => {
     await conflictStore.save(record);
 
     const updatedPayloads: any[] = [];
+    const archivedRows: any[] = [];
+    const originalExistingText = "User prefers concise, direct replies.";
     const existingMemory = {
       id: "durable-1",
-      text: "User prefers concise, direct replies.",
+      text: originalExistingText,
       vector: [1, 1, 1],
       category: "preferences",
       scope: "memory:agent",
@@ -183,6 +186,14 @@ describe("resolveConflictCandidate", () => {
           Object.assign(existingMemory, updates);
           return existingMemory;
         },
+        async store(entry: any) {
+          archivedRows.push(entry);
+          return entry;
+        },
+        async upsert(entry: any) {
+          archivedRows.push(entry);
+          return entry;
+        },
       },
       embedder: {
         async embedPassage(text: string) {
@@ -200,7 +211,23 @@ describe("resolveConflictCandidate", () => {
     expect(result.updatedMemoryId).toBe("durable-1");
     expect(updatedPayloads).toHaveLength(1);
     expect(updatedPayloads[0]?.updates.text).toBe(record.incoming.text);
-    expect(updatedPayloads[0]?.updates.metadata).toBe(record.incoming.metadata);
+
+    // The incoming metadata is carried through, with an evolution block layered on top
+    // that links the live row back to the archived version (it is no longer passed verbatim).
+    const incomingMeta = JSON.parse(record.incoming.metadata);
+    const writtenMeta = JSON.parse(updatedPayloads[0]?.updates.metadata);
+    for (const [key, value] of Object.entries(incomingMeta)) {
+      if (key === "evolution") continue;
+      expect(writtenMeta[key]).toEqual(value);
+    }
+
+    // Accepting the incoming version must not destroy the belief it replaced.
+    expect(archivedRows).toHaveLength(1);
+    expect(archivedRows[0].text).toBe(originalExistingText);
+    const archivedEvo = parseEvolution(archivedRows[0].metadata);
+    expect(archivedEvo.status).toBe("superseded");
+    expect(archivedEvo.supersededBy).toBe("durable-1");
+    expect(parseEvolution(updatedPayloads[0]?.updates.metadata).supersedes).toBe(archivedRows[0].id);
 
     const resolved = await conflictStore.getById(record.conflictId);
     expect(resolved?.status).toBe("accepted-incoming");
@@ -260,6 +287,8 @@ describe("resolveConflictCandidate", () => {
 
     const mergeSuggestion = summarizeConflictAdvice(record).mergeSuggestion;
     expect(mergeSuggestion).toBeTruthy();
+    const archivedRows: any[] = [];
+    const originalExistingText = existingMemory.text;
 
     const result = await resolveConflictCandidate({
       store: {
@@ -271,6 +300,14 @@ describe("resolveConflictCandidate", () => {
           Object.assign(existingMemory, updates);
           return existingMemory;
         },
+        async store(entry: any) {
+          archivedRows.push(entry);
+          return entry;
+        },
+        async upsert(entry: any) {
+          archivedRows.push(entry);
+          return entry;
+        },
       },
       embedder: {
         async embedPassage(text: string) {
@@ -295,6 +332,13 @@ describe("resolveConflictCandidate", () => {
     expect(mergedMetadata.promotedFrom?.memoryId).toBe("source-1");
     expect(mergedMetadata.mergedFrom?.conflictId).toBe(record.conflictId);
 
+    // A merge still replaces the existing row's text, so the pre-merge belief must survive
+    // as history — otherwise the "before" half of the merge decision is unrecoverable.
+    expect(archivedRows).toHaveLength(1);
+    expect(archivedRows[0].text).toBe(originalExistingText);
+    expect(parseEvolution(archivedRows[0].metadata).status).toBe("superseded");
+    expect(parseEvolution(updatedPayloads[0]?.updates.metadata).supersedes).toBe(archivedRows[0].id);
+
     const resolved = await conflictStore.getById(record.conflictId);
     expect(resolved?.status).toBe("merged");
     expect(resolved?.resolutionNotes).toContain("grounded style");

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

@@ -110,6 +110,45 @@ describe("ConsolidationEngine", () => {
     expect(metaA.version_rank).toBeGreaterThan(metaB.version_rank);
   });
 
+  it("never clusters a live entry with its own superseded belief-history row", async () => {
+    // A rephrased belief sits far above mergeThreshold from its archived version, and
+    // canonicalScore (importance × access count, no recency) ties them exactly — the
+    // history row inherits both. Losing that coin flip would mark the LIVE entry
+    // consolidated, dropping the current belief out of default retrieval while the
+    // abandoned wording stands in as canonical.
+    const live = makeEntry({
+      id: "live",
+      text: "User prefers concise, code-first replies",
+      vector: [1, 0, 0],
+    });
+    // Clustering is skipped outright when a category holds fewer than two ACTIVE entries,
+    // so an unrelated second live entry is what makes this scenario reachable at all.
+    const unrelated = makeEntry({
+      id: "other",
+      text: "Project uses Bun as the runtime",
+      vector: [0, 0, 1],
+    });
+    const history = makeEntry({
+      id: "hist",
+      text: "User prefers concise, direct replies",
+      vector: [0, 1, 0],
+      metadata: JSON.stringify({
+        evolution: { status: "superseded", validUntil: Date.now(), supersededBy: "live" },
+      }),
+    });
+
+    const simMap = new Map([["live", new Map([["hist", 0.98]])]]);
+
+    const { store, updates } = createMockStore([live, unrelated, history], simMap);
+    const engine = new ConsolidationEngine(store, { ...DEFAULT_CONSOLIDATION_CONFIG, mergeThreshold: 0.92 });
+    const result = await engine.run("project:test");
+
+    expect(result.clustersFound).toBe(0);
+    expect(result.mergedCount).toBe(0);
+    // Above all: the live entry must not have been touched.
+    expect(updates.find(u => u.id === "live")).toBeUndefined();
+  });
+
   it("links related entries below mergeThreshold but above clusterThreshold", async () => {
     const entryA = makeEntry({ id: "a", text: "TypeScript config", vector: [1, 0, 0] });
     const entryB = makeEntry({ id: "b", text: "TypeScript setup", vector: [0.9, 0.1, 0] });
@@ -331,3 +370,61 @@ describe("formatConsolidationResult", () => {
     expect(text).toContain("Conflicts:");
   });
 });
+
+// ---------------------------------------------------------------------------
+// computeSynthesisUptake (Artel synthesis_uptake_rate 对应物)
+// ---------------------------------------------------------------------------
+
+import { computeSynthesisUptake } from "../consolidation-engine.js";
+import type { MemoryEntry as UptakeEntry } from "../store.js";
+
+function uptakeEntry(id: string, metadata: Record<string, unknown>): UptakeEntry {
+  return {
+    id,
+    text: `t-${id}`,
+    vector: [],
+    category: "patterns",
+    scope: "project:test",
+    importance: 0.7,
+    timestamp: Date.now(),
+    metadata: JSON.stringify(metadata),
+  } as UptakeEntry;
+}
+
+function pagedStore(all: UptakeEntry[]) {
+  return {
+    async listPage({ limit = 1000, offset = 0 }: { limit?: number; offset?: number; includeVector?: boolean }) {
+      return all.slice(offset, offset + limit);
+    },
+  };
+}
+
+describe("computeSynthesisUptake", () => {
+  it("computes uptake over derived insights only", async () => {
+    const store = pagedStore([
+      uptakeEntry("d1", { cluster_insight: true, accessCount: 2 }),   // derived, read
+      uptakeEntry("d2", { cross_memory_pattern: true }),              // derived, unread
+      uptakeEntry("n1", { accessCount: 5 }),                          // not derived
+    ]);
+    const s = await computeSynthesisUptake(store, 20_000, 2);
+    expect(s.scanned).toBe(3);
+    expect(s.derivedTotal).toBe(2);
+    expect(s.derivedRead).toBe(1);
+    expect(s.uptakeRate).toBeCloseTo(0.5, 5);
+    expect(s.truncated).toBe(false);
+  });
+
+  it("returns null rate when no derived insights exist", async () => {
+    const s = await computeSynthesisUptake(pagedStore([uptakeEntry("n1", {})]));
+    expect(s.derivedTotal).toBe(0);
+    expect(s.uptakeRate).toBeNull();
+  });
+
+  it("respects scan cap and reports truncation", async () => {
+    const all = Array.from({ length: 10 }, (_, i) => uptakeEntry(`e${i}`, { cluster_insight: true, accessCount: 1 }));
+    const s = await computeSynthesisUptake(pagedStore(all), 4, 2);
+    expect(s.scanned).toBe(4);
+    expect(s.truncated).toBe(true);
+    expect(s.derivedTotal).toBe(4);
+  });
+});

package/src/__tests__/contracts.test.ts

@@ -7,6 +7,7 @@ import { resetWriteCount } from "../activity-counter.js";
 import { resetGcTimestamp } from "../auto-gc.js";
 import { runDream } from "../dream-pipeline.js";
 import { MemoryStore } from "../store.js";
+import { PACKAGE_VERSION } from "../version.js";
 
 // Isolate the activity-counter default path away from the repo's data/activity-stats.json.
 let __origDataDir: string | undefined;
@@ -214,3 +215,48 @@ describe("MCP registry contract", () => {
     expect(headerCount("full")).toBe(fullCount);
   });
 });
+
+describe("Release metadata contract", () => {
+  it("keeps every public version surface aligned with package.json", () => {
+    const root = join(import.meta.dir, "..", "..");
+    const packageMetadata = JSON.parse(readFileSync(join(root, "package.json"), "utf8"));
+    const marketplaceMetadata = JSON.parse(
+      readFileSync(join(root, ".claude-plugin", "marketplace.json"), "utf8"),
+    );
+
+    expect(marketplaceMetadata.plugins).toHaveLength(1);
+    expect(PACKAGE_VERSION).toBe(packageMetadata.version);
+    expect(marketplaceMetadata.plugins[0].version).toBe(packageMetadata.version);
+
+    for (const file of ["cli.ts", "mcp-server.ts", "api-server.ts"]) {
+      const source = readFileSync(join(root, "src", file), "utf8");
+      expect(source).toContain("PACKAGE_VERSION");
+      expect(source).not.toMatch(/version:\s*["'](?:1\.0\.0|1\.4\.0)["']/);
+    }
+  });
+
+  it("ships a self-contained Claude Code plugin without project MCP overrides", () => {
+    const root = join(import.meta.dir, "..", "..");
+    const marketplaceMetadata = JSON.parse(
+      readFileSync(join(root, ".claude-plugin", "marketplace.json"), "utf8"),
+    );
+    const plugin = marketplaceMetadata.plugins[0];
+    const projectMcp = JSON.parse(readFileSync(join(root, ".mcp.json"), "utf8"));
+
+    expect(plugin.strict).toBe(false);
+    expect(plugin.skills).toContain("./.claude-plugin/recallnest-skill");
+    expect(plugin.mcpServers.recallnest.args).toContain(
+      "${CLAUDE_PLUGIN_ROOT}/scripts/start-server.sh",
+    );
+    expect(plugin.mcpServers.recallnest.env.LOCAL_MEMORY_CONFIG).toBe(
+      "${CLAUDE_PLUGIN_DATA}/config.json",
+    );
+    expect(plugin.mcpServers.recallnest.env.RECALLNEST_MCP_TIER).toBe("full");
+    expect(plugin.userConfig.jina_api_key).toMatchObject({
+      type: "string",
+      sensitive: true,
+      required: true,
+    });
+    expect(projectMcp.mcpServers).toEqual({});
+  });
+});

package/src/__tests__/decay-exemption.test.ts

@@ -81,4 +81,49 @@ describe("HP-7: Decay exemption rules", () => {
       expect(isDecayExempt(meta, 0.98)).toBe(true);
     });
   });
+
+  describe("Rule 0: procedural category", () => {
+    // A procedural memory's defining trait is low access frequency + long validity.
+    // Rules 1-3 all key off access statistics, so without Rule 0 these entries land
+    // in the fastest-decaying tier forever.
+    const coldPeripheral = JSON.stringify({
+      tier: "peripheral",
+      accessCount: 0,
+      lastAccessedAt: 0,
+      tags: ["workflow"],
+    });
+
+    it("exempts patterns even when cold, peripheral and low-importance", () => {
+      expect(isDecayExempt(coldPeripheral, 0.30, "patterns")).toBe(true);
+    });
+
+    it("exempts patterns with no metadata at all", () => {
+      // Checked before the `!metadata` guard on purpose.
+      expect(isDecayExempt(undefined, 0.30, "patterns")).toBe(true);
+    });
+
+    it("exempts patterns with corrupt metadata", () => {
+      expect(isDecayExempt("not-json", 0.30, "patterns")).toBe(true);
+    });
+
+    it("does NOT exempt cases — they carry an episodic component and should decay", () => {
+      expect(isDecayExempt(coldPeripheral, 0.30, "cases")).toBe(false);
+    });
+
+    it("does NOT exempt declarative categories", () => {
+      for (const category of ["events", "profile", "preferences", "entities"]) {
+        expect(isDecayExempt(coldPeripheral, 0.30, category)).toBe(false);
+      }
+    });
+
+    it("is backward compatible: omitting category preserves Rule 1-3 behaviour", () => {
+      expect(isDecayExempt(coldPeripheral, 0.30)).toBe(false);
+      expect(isDecayExempt(JSON.stringify({ tags: ["pinned"] }), 0.40)).toBe(true);
+    });
+
+    it("does not exempt on unknown category strings", () => {
+      expect(isDecayExempt(coldPeripheral, 0.30, "skills")).toBe(false);
+      expect(isDecayExempt(coldPeripheral, 0.30, "")).toBe(false);
+    });
+  });
 });