recallnest 1.4.1

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

@@ -0,0 +1,374 @@
+import { afterEach, describe, expect, it } from "bun:test";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { summarizeConflictAdvice } from "../conflict-advisor.js";
+import { buildConflictCandidateRecord, resolveConflictCandidate } from "../conflict-engine.js";
+import { ConflictCandidateStore } from "../conflict-store.js";
+
+const tempDirs: string[] = [];
+
+function createTempConflictStore(): ConflictCandidateStore {
+  const dir = mkdtempSync(join(tmpdir(), "recallnest-conflicts-"));
+  tempDirs.push(dir);
+  return new ConflictCandidateStore(dir);
+}
+
+afterEach(() => {
+  while (tempDirs.length > 0) {
+    const dir = tempDirs.pop();
+    if (dir) rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+function createConflictRecord() {
+  return buildConflictCandidateRecord({
+    canonicalKey: "user-reply-style",
+    category: "preferences",
+    fingerprint: "user-reply-style--durable-1--source-1--new-text",
+    reason: "promotion_conflicts_with_existing_durable",
+    existing: {
+      memoryId: "durable-1",
+      text: "User prefers concise, direct replies.",
+      category: "preferences",
+      scope: "memory:agent",
+      importance: 0.84,
+      metadata: JSON.stringify({
+        source: "agent",
+        canonicalKey: "user-reply-style",
+        boundary: {
+          layer: "durable",
+          authority: "structured-memory",
+          conflictPolicy: "latest-wins",
+          originalCategory: "preferences",
+        },
+      }),
+      canonicalKey: "user-reply-style",
+    },
+    incoming: {
+      text: "User prefers colloquial writing that stays grounded and non-salesy.",
+      category: "preferences",
+      scope: "memory:agent",
+      importance: 0.78,
+      metadata: JSON.stringify({
+        source: "agent",
+        canonicalKey: "user-reply-style",
+        boundary: {
+          layer: "durable",
+          authority: "structured-memory",
+          conflictPolicy: "latest-wins",
+          originalCategory: "preferences",
+        },
+        promotedFrom: {
+          memoryId: "source-1",
+          scope: "cc:session-1",
+          category: "events",
+        },
+      }),
+      source: "agent",
+      sourceMemoryId: "source-1",
+      sourceCategory: "events",
+    },
+  });
+}
+
+function createMergeableConflictRecord() {
+  return buildConflictCandidateRecord({
+    canonicalKey: "user-reply-style",
+    category: "preferences",
+    fingerprint: "user-reply-style--durable-1--source-1--mergeable",
+    reason: "promotion_conflicts_with_existing_durable",
+    existing: {
+      memoryId: "durable-1",
+      text: "User prefers concise grounded technical replies; avoid sales language.",
+      category: "preferences",
+      scope: "memory:agent",
+      importance: 0.84,
+      metadata: JSON.stringify({
+        source: "agent",
+        canonicalKey: "user-reply-style",
+        boundary: {
+          layer: "durable",
+          authority: "structured-memory",
+          conflictPolicy: "latest-wins",
+          originalCategory: "preferences",
+        },
+      }),
+      canonicalKey: "user-reply-style",
+    },
+    incoming: {
+      text: "User prefers concise grounded technical replies; keep the tone colloquial.",
+      category: "preferences",
+      scope: "memory:agent",
+      importance: 0.78,
+      metadata: JSON.stringify({
+        source: "agent",
+        canonicalKey: "user-reply-style",
+        boundary: {
+          layer: "durable",
+          authority: "structured-memory",
+          conflictPolicy: "latest-wins",
+          originalCategory: "preferences",
+        },
+        promotedFrom: {
+          memoryId: "source-1",
+          scope: "cc:session-1",
+          category: "events",
+        },
+      }),
+      source: "agent",
+      sourceMemoryId: "source-1",
+      sourceCategory: "events",
+    },
+  });
+}
+
+describe("ConflictCandidateStore", () => {
+  it("saves, lists, and fetches open conflicts by fingerprint", async () => {
+    const store = createTempConflictStore();
+    const record = createConflictRecord();
+    await store.save(record);
+
+    const fetched = await store.getById(record.conflictId);
+    expect(fetched?.conflictId).toBe(record.conflictId);
+
+    const byFingerprint = await store.getOpenByFingerprint(record.fingerprint);
+    expect(byFingerprint?.conflictId).toBe(record.conflictId);
+
+    const recent = await store.listRecent({
+      status: "open",
+      canonicalKey: "user-reply-style",
+      limit: 10,
+    });
+    expect(recent).toHaveLength(1);
+    expect(recent[0]?.conflictId).toBe(record.conflictId);
+  });
+
+  it("accepts a unique short conflict ID prefix", async () => {
+    const store = createTempConflictStore();
+    const record = createConflictRecord();
+    await store.save(record);
+
+    const fetched = await store.getById(record.conflictId.slice(0, 8));
+    expect(fetched?.conflictId).toBe(record.conflictId);
+  });
+});
+
+describe("resolveConflictCandidate", () => {
+  it("accepts incoming text and updates the existing durable memory", async () => {
+    const conflictStore = createTempConflictStore();
+    const record = createConflictRecord();
+    await conflictStore.save(record);
+
+    const updatedPayloads: any[] = [];
+    const existingMemory = {
+      id: "durable-1",
+      text: "User prefers concise, direct replies.",
+      vector: [1, 1, 1],
+      category: "preferences",
+      scope: "memory:agent",
+      importance: 0.84,
+      timestamp: 1_700_000_000_001,
+      metadata: record.existing.metadata,
+    };
+
+    const result = await resolveConflictCandidate({
+      store: {
+        async getById(id: string) {
+          return id === existingMemory.id ? existingMemory : null;
+        },
+        async update(id: string, updates: any) {
+          updatedPayloads.push({ id, updates });
+          Object.assign(existingMemory, updates);
+          return existingMemory;
+        },
+      },
+      embedder: {
+        async embedPassage(text: string) {
+          return [text.length, 9, 9];
+        },
+      },
+      conflictStore,
+    }, {
+      conflictId: record.conflictId,
+      resolution: "accept_incoming",
+      notes: "Promoted evidence is cleaner than the original durable wording.",
+    });
+
+    expect(result.status).toBe("accepted-incoming");
+    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);
+
+    const resolved = await conflictStore.getById(record.conflictId);
+    expect(resolved?.status).toBe("accepted-incoming");
+    expect(resolved?.resolutionNotes).toContain("cleaner");
+  });
+
+  it("can keep the existing durable memory without updating it", async () => {
+    const conflictStore = createTempConflictStore();
+    const record = createConflictRecord();
+    await conflictStore.save(record);
+
+    let updated = false;
+    const result = await resolveConflictCandidate({
+      store: {
+        async getById() {
+          return null;
+        },
+        async update() {
+          updated = true;
+          return null;
+        },
+      },
+      embedder: {
+        async embedPassage() {
+          return [0, 0, 0];
+        },
+      },
+      conflictStore,
+    }, {
+      conflictId: record.conflictId,
+      resolution: "keep_existing",
+    });
+
+    expect(result.status).toBe("kept-existing");
+    expect(updated).toBe(false);
+
+    const resolved = await conflictStore.getById(record.conflictId);
+    expect(resolved?.status).toBe("kept-existing");
+  });
+
+  it("merges same-category conflicts using the default merge suggestion", async () => {
+    const conflictStore = createTempConflictStore();
+    const record = createMergeableConflictRecord();
+    await conflictStore.save(record);
+
+    const updatedPayloads: any[] = [];
+    const existingMemory = {
+      id: "durable-1",
+      text: record.existing.text,
+      vector: [1, 1, 1],
+      category: "preferences",
+      scope: "memory:agent",
+      importance: 0.84,
+      timestamp: 1_700_000_000_001,
+      metadata: record.existing.metadata,
+    };
+
+    const mergeSuggestion = summarizeConflictAdvice(record).mergeSuggestion;
+    expect(mergeSuggestion).toBeTruthy();
+
+    const result = await resolveConflictCandidate({
+      store: {
+        async getById(id: string) {
+          return id === existingMemory.id ? existingMemory : null;
+        },
+        async update(id: string, updates: any) {
+          updatedPayloads.push({ id, updates });
+          Object.assign(existingMemory, updates);
+          return existingMemory;
+        },
+      },
+      embedder: {
+        async embedPassage(text: string) {
+          return [text.length, 7, 7];
+        },
+      },
+      conflictStore,
+    }, {
+      conflictId: record.conflictId,
+      resolution: "merge",
+      notes: "Combine the grounded style and tone guidance.",
+    });
+
+    expect(result.status).toBe("merged");
+    expect(result.updatedMemoryId).toBe("durable-1");
+    expect(updatedPayloads).toHaveLength(1);
+    expect(updatedPayloads[0]?.updates.text).toBe(mergeSuggestion);
+    expect(updatedPayloads[0]?.updates.importance).toBe(0.84);
+
+    const mergedMetadata = JSON.parse(updatedPayloads[0]?.updates.metadata || "{}");
+    expect(mergedMetadata.canonicalKey).toBe("user-reply-style");
+    expect(mergedMetadata.promotedFrom?.memoryId).toBe("source-1");
+    expect(mergedMetadata.mergedFrom?.conflictId).toBe(record.conflictId);
+
+    const resolved = await conflictStore.getById(record.conflictId);
+    expect(resolved?.status).toBe("merged");
+    expect(resolved?.resolutionNotes).toContain("grounded style");
+  });
+
+  it("rejects merge for cross-category conflicts", async () => {
+    const conflictStore = createTempConflictStore();
+    const record = buildConflictCandidateRecord({
+      canonicalKey: "project-owner",
+      category: "events",
+      fingerprint: "project-owner--durable-1--source-2--cross-category",
+      reason: "canonical_key_conflicts_with_existing_durable",
+      existing: {
+        memoryId: "durable-1",
+        text: "Project owner: RecallNest",
+        category: "entities",
+        scope: "memory:agent",
+        importance: 0.82,
+        metadata: recordLikeMetadata("project-owner", "entities"),
+        canonicalKey: "project-owner",
+      },
+      incoming: {
+        text: "Project owner observation imported as an event.",
+        category: "events",
+        scope: "memory:agent",
+        importance: 0.74,
+        metadata: recordLikeMetadata("project-owner", "events"),
+        source: "agent",
+        sourceMemoryId: "source-2",
+        sourceCategory: "events",
+      },
+    });
+    await conflictStore.save(record);
+
+    await expect(resolveConflictCandidate({
+      store: {
+        async getById() {
+          return {
+            id: "durable-1",
+            text: "Project owner: RecallNest",
+            vector: [1, 1, 1],
+            category: "entities",
+            scope: "memory:agent",
+            importance: 0.82,
+            timestamp: 1_700_000_000_002,
+            metadata: record.existing.metadata,
+          };
+        },
+        async update() {
+          throw new Error("update should not be called");
+        },
+      },
+      embedder: {
+        async embedPassage() {
+          return [0, 0, 0];
+        },
+      },
+      conflictStore,
+    }, {
+      conflictId: record.conflictId,
+      resolution: "merge",
+    })).rejects.toThrow("same-category durable conflicts");
+  });
+});
+
+function recordLikeMetadata(canonicalKey: string, category: string): string {
+  return JSON.stringify({
+    source: "agent",
+    canonicalKey,
+    boundary: {
+      layer: "durable",
+      authority: "structured-memory",
+      conflictPolicy: "latest-wins",
+      originalCategory: category,
+    },
+  });
+}

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

@@ -0,0 +1,181 @@
+import { describe, expect, it } from "bun:test";
+
+import { ConsolidationEngine, DEFAULT_CONSOLIDATION_CONFIG, formatConsolidationResult, type ConsolidationResult } from "../consolidation-engine.js";
+import type { MemoryEntry, MemorySearchResult } from "../store.js";
+
+function makeEntry(overrides: Partial<MemoryEntry> & { id: string; text: string }): MemoryEntry {
+  return {
+    vector: [1, 0, 0],
+    category: "events",
+    scope: "project:test",
+    importance: 0.7,
+    timestamp: Date.now(),
+    metadata: "{}",
+    ...overrides,
+  };
+}
+
+function createMockStore(entries: MemoryEntry[], similarityMap: Map<string, Map<string, number>> = new Map()) {
+  const data = new Map(entries.map(e => [e.id, { ...e }]));
+  const updates: Array<{ id: string; metadata: string }> = [];
+
+  return {
+    updates,
+    store: {
+      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[]) {
+        // Use the similarity map to compute fake scores
+        const sourceEntry = [...data.values()].find(e =>
+          e.vector.length === vector.length && e.vector.every((v, i) => v === vector[i])
+        );
+        if (!sourceEntry) return [];
+
+        const sourceMap = similarityMap.get(sourceEntry.id);
+        if (!sourceMap) return [];
+
+        const results: MemorySearchResult[] = [];
+        for (const [targetId, score] of sourceMap) {
+          if (score < minScore) continue;
+          const target = data.get(targetId);
+          if (!target) continue;
+          if (scopeFilter && !scopeFilter.some(s => target.scope === s)) continue;
+          results.push({ entry: target, score });
+        }
+        return results.sort((a, b) => b.score - a.score).slice(0, limit);
+      },
+      async update(id: string, upd: { metadata?: string }) {
+        const entry = data.get(id);
+        if (!entry) return null;
+        if (upd.metadata) {
+          entry.metadata = upd.metadata;
+          updates.push({ id, metadata: upd.metadata });
+        }
+        return entry;
+      },
+    },
+  };
+}
+
+describe("ConsolidationEngine", () => {
+  it("returns empty result for empty scope", async () => {
+    const { store } = createMockStore([]);
+    const engine = new ConsolidationEngine(store);
+    const result = await engine.run("project:test");
+    expect(result.originalCount).toBe(0);
+    expect(result.clustersFound).toBe(0);
+  });
+
+  it("skips single-entry categories", async () => {
+    const entries = [makeEntry({ id: "a", text: "only one" })];
+    const { store } = createMockStore(entries);
+    const engine = new ConsolidationEngine(store);
+    const result = await engine.run("project:test");
+    expect(result.originalCount).toBe(1);
+    expect(result.clustersFound).toBe(0);
+  });
+
+  it("merges near-duplicates above mergeThreshold", async () => {
+    const entryA = makeEntry({ id: "a", text: "I prefer TypeScript", vector: [1, 0, 0], importance: 0.9 });
+    const entryB = makeEntry({ id: "b", text: "I prefer TypeScript language", vector: [0.99, 0.1, 0], importance: 0.5 });
+
+    const simMap = new Map([
+      ["a", new Map([["b", 0.95]])],
+      ["b", new Map([["a", 0.95]])],
+    ]);
+
+    const { store, updates } = createMockStore([entryA, entryB], simMap);
+    const engine = new ConsolidationEngine(store, { ...DEFAULT_CONSOLIDATION_CONFIG, mergeThreshold: 0.92 });
+    const result = await engine.run("project:test");
+
+    expect(result.clustersFound).toBe(1);
+    expect(result.mergedCount).toBe(1);
+    // Tier 3.3: Both entries now coexist in a version group instead of archiving.
+    // Both A and B should have version_group metadata.
+    const updateA = updates.find(u => u.id === "a");
+    const updateB = updates.find(u => u.id === "b");
+    expect(updateA).toBeTruthy();
+    expect(updateB).toBeTruthy();
+    const metaA = JSON.parse(updateA!.metadata);
+    const metaB = JSON.parse(updateB!.metadata);
+    expect(metaA.version_group).toBeTruthy();
+    expect(metaB.version_group).toBe(metaA.version_group);
+    // Canonical (A, higher importance) should have higher rank
+    expect(metaA.version_rank).toBeGreaterThan(metaB.version_rank);
+  });
+
+  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] });
+
+    const simMap = new Map([
+      ["a", new Map([["b", 0.85]])],
+      ["b", new Map([["a", 0.85]])],
+    ]);
+
+    const { store, updates } = createMockStore([entryA, entryB], simMap);
+    const engine = new ConsolidationEngine(store, { ...DEFAULT_CONSOLIDATION_CONFIG, clusterThreshold: 0.82, mergeThreshold: 0.92 });
+    const result = await engine.run("project:test");
+
+    expect(result.clustersFound).toBe(1);
+    expect(result.mergedCount).toBe(0);
+    expect(result.relationsAdded).toBe(1);
+    // Both should have clustering metadata
+    const linkUpdate = updates.find(u => u.id === "b");
+    expect(linkUpdate).toBeTruthy();
+    const meta = JSON.parse(linkUpdate!.metadata);
+    expect(meta.clustered_with).toBe("a");
+  });
+
+  it("detects heuristic contradictions", async () => {
+    const entryA = makeEntry({ id: "a", text: "Always use strict mode in TypeScript projects", vector: [1, 0, 0] });
+    const entryB = makeEntry({ id: "b", text: "Never use strict mode in TypeScript projects", vector: [0.98, 0.1, 0] });
+
+    const simMap = new Map([
+      ["a", new Map([["b", 0.95]])],
+      ["b", new Map([["a", 0.95]])],
+    ]);
+
+    const { store } = createMockStore([entryA, entryB], simMap);
+    const engine = new ConsolidationEngine(store, DEFAULT_CONSOLIDATION_CONFIG);
+    const result = await engine.run("project:test");
+
+    expect(result.conflictsDetected.length).toBe(1);
+    expect(result.conflictsDetected[0].type).toBe("heuristic_contradiction");
+  });
+
+  it("skips archived entries", async () => {
+    const entryA = makeEntry({ id: "a", text: "active entry here", vector: [1, 0, 0] });
+    const entryB = makeEntry({ id: "b", text: "archived entry here", vector: [0.95, 0.1, 0], metadata: JSON.stringify({ state: "archived" }) });
+
+    const { store } = createMockStore([entryA, entryB]);
+    const engine = new ConsolidationEngine(store);
+    const result = await engine.run("project:test");
+
+    expect(result.originalCount).toBe(1); // only active
+  });
+});
+
+describe("formatConsolidationResult", () => {
+  it("formats a result with conflicts", () => {
+    const result: ConsolidationResult = {
+      originalCount: 100,
+      clustersFound: 5,
+      mergedCount: 3,
+      relationsAdded: 7,
+      conflictsDetected: [{ memoryA: "aaaa-bbbb", memoryB: "cccc-dddd", type: "heuristic_contradiction" }],
+      scope: "project:test",
+    };
+    const text = formatConsolidationResult(result);
+    expect(text).toContain("Scanned: 100");
+    expect(text).toContain("Clusters found: 5");
+    expect(text).toContain("Merged (versioned): 3");
+    expect(text).toContain("Conflicts:");
+  });
+});

package/src/__tests__/context-composer-pins.test.ts

@@ -0,0 +1,64 @@
+import { describe, expect, it } from "bun:test";
+
+import type { PinAsset } from "../memory-assets.js";
+import { selectPinnedContext } from "../context-composer-pins.js";
+
+function buildPinnedAsset(overrides: Partial<PinAsset> = {}): PinAsset & { path: string } {
+  return {
+    id: overrides.id || "pin-1",
+    type: "pinned-memory",
+    createdAt: overrides.createdAt || "2026-03-20T00:00:00.000Z",
+    updatedAt: overrides.updatedAt || "2026-03-20T00:00:00.000Z",
+    title: overrides.title || "Pinned continuity note",
+    summary: overrides.summary || "Pinned continuity reminder",
+    tags: overrides.tags || [],
+    source: overrides.source || {
+      memoryId: "memory-1",
+      scope: "memory:project:recallnest",
+      timestamp: Date.parse("2026-03-20T00:00:00.000Z"),
+      metadata: {},
+    },
+    retrieval: overrides.retrieval,
+    snippet: overrides.snippet || "",
+    path: "/tmp/pin-1.json",
+  };
+}
+
+describe("context composer pins", () => {
+  it("keeps later task-specific cues from long maintenance prompts", () => {
+    const taskSeed =
+      "继续 RecallNest continuity helper boundary audit ranking scoring selection orchestration context composer stable query fallback profile forwarding gap runner isolation";
+
+    const pinnedContext = selectPinnedContext([
+      buildPinnedAsset({
+        title: "Eval runner isolation note",
+        summary: "Fresh-window replay still needs explicit runner isolation to avoid shared component skew.",
+        tags: ["recallnest", "runner", "isolation"],
+        snippet: "Runner isolation is the key safeguard when continuity previews diverge across fresh-window replay.",
+      }),
+    ], {
+      taskSeed,
+      limit: 1,
+    });
+
+    expect(pinnedContext).toHaveLength(1);
+    expect(pinnedContext[0]).toContain("Pinned: Eval runner isolation note: Fresh-window replay still needs explicit runner isolation to avoid shared component skew.");
+  });
+
+  it("ignores conversational continuation filler for vague memory-layer prompts", () => {
+    const pinnedContext = selectPinnedContext([
+      buildPinnedAsset({
+        id: "pin-visual",
+        title: "用户视觉审美偏好",
+        summary: "用户常用视觉风格是手绘涂鸦风加高对比撞色；在内容包装和配图生成时，应优先沿用这一审美方向。",
+        tags: ["审美偏好", "手绘涂鸦", "高对比撞色", "给刚才写的文章生成配图"],
+        snippet: "给刚才写的文章生成配图，风格：手绘涂鸦风+高对比撞色。",
+      }),
+    ], {
+      taskSeed: "把刚才那个 memory layer 接回去",
+      limit: 1,
+    });
+
+    expect(pinnedContext).toEqual([]);
+  });
+});

package/src/__tests__/context-composer-task-selection.test.ts

@@ -0,0 +1,24 @@
+import { describe, expect, it } from "bun:test";
+
+import { countTaskSpecificTextMatches } from "../context-composer-task-selection.js";
+
+describe("context composer task selection", () => {
+  it("keeps later task-specific cues from long maintenance prompts", () => {
+    const taskSeed =
+      "继续 RecallNest continuity helper boundary audit ranking scoring selection orchestration context composer stable query fallback profile forwarding gap runner isolation";
+
+    expect(
+      countTaskSpecificTextMatches(
+        "Case: Continuity eval profile forwarding gap Problem: sparse writing prompts still failed until the eval profile was forwarded correctly.",
+        taskSeed,
+      ),
+    ).toBeGreaterThan(0);
+
+    expect(
+      countTaskSpecificTextMatches(
+        "Case: Eval runner shared components skewed later continuity previews Problem: runner isolation broke when shared component state leaked across fresh-window replay.",
+        taskSeed,
+      ),
+    ).toBeGreaterThan(0);
+  });
+});