pi-mega-compact 0.8.26 → 0.9.1

package/src/compact.ts

@@ -14,30 +14,31 @@ const INTERESTING_EXT = new Set(["rs", "ts", "tsx", "js", "json", "md"]);
 const PENDING_WORDS = ["todo", "next", "pending", "follow up", "remaining"];
 
 const COMPACT_PREAMBLE =
-  "This session is being continued from a previous conversation that ran out of context. The summary below covers the earlier portion of the conversation.\n\n";
+	"This session is being continued from a previous conversation that ran out of context. The summary below covers the earlier portion of the conversation.\n\n";
 const RECENT_NOTE = "Recent messages are preserved verbatim.";
-const DIRECT_RESUME = "Continue the conversation from where it left off without asking the user any further questions. Resume directly — do not acknowledge the summary, do not recap what was happening, and do not preface with continuation text.";
+const DIRECT_RESUME =
+	"Continue the conversation from where it left off without asking the user any further questions. Resume directly — do not acknowledge the summary, do not recap what was happening, and do not preface with continuation text.";
 
 function truncate(s: string, max: number): string {
-  return s.length <= max ? s : `${s.slice(0, max)}…`;
+	return s.length <= max ? s : `${s.slice(0, max)}…`;
 }
 
 function firstText(m: EngineMessage): string | undefined {
-  // PREVENT crash: pi can hand us a message with text: undefined (pure
-  // tool-call/tool-result). Guard the trim so the legacy summarizeMessages
-  // path can't throw the same undefined-text crash the extractive path did.
-  const raw = m.text ?? "";
-  const t = raw.trim();
-  return t.length > 0 ? t : undefined;
+	// PREVENT crash: pi can hand us a message with text: undefined (pure
+	// tool-call/tool-result). Guard the trim so the legacy summarizeMessages
+	// path can't throw the same undefined-text crash the extractive path did.
+	const raw = m.text ?? "";
+	const t = raw.trim();
+	return t.length > 0 ? t : undefined;
 }
 
 /** Heuristic: does this text look like chatty filler we can collapse? */
 export function isChatty(text: string): boolean {
-  const low = text.toLowerCase();
-  if (low.includes("hello") || low.includes("thanks") || low.includes("great") || low.includes("ok")) {
-    return true;
-  }
-  return text.length < 40 && !/(\/|\.|\{|import |def |function )/.test(text);
+	const low = text.toLowerCase();
+	if (/\b(hello|thanks|great|ok)\b/i.test(low)) {
+		return true;
+	}
+	return text.length < 40 && !/(\/|\.|\{|import |def |function )/.test(text);
 }
 
 /** Extract plausible file paths (contain '/' + an interesting extension).
@@ -45,101 +46,110 @@ export function isChatty(text: string): boolean {
  * a message whose `text`/`input`/`output` is undefined (e.g. a pure tool-call
  * or tool-result message), and `.split` on undefined throws and takes down the
  * whole compaction. Guard once at the source so every caller is safe. */
-export function extractFileCandidates(content: string | undefined | null): string[] {
-  if (!content) return [];
-  const out: string[] = [];
-  for (const raw of content.split(/\s+/)) {
-    // Trim surrounding punctuation only — do NOT strip internal dots, or we
-    // would erase the extension separator (src/server.ts -> src/server/ts).
-    const token = raw.replace(/^[^A-Za-z0-9/]+|[^A-Za-z0-9/]+$/g, "");
-    if (!token.includes("/") || !token.includes(".")) continue;
-    const ext = token.split(".").pop()?.toLowerCase() ?? "";
-    if (INTERESTING_EXT.has(ext)) out.push(token);
-  }
-  return out;
+export function extractFileCandidates(
+	content: string | undefined | null,
+): string[] {
+	if (!content) return [];
+	const out: string[] = [];
+	for (const raw of content.split(/\s+/)) {
+		// Trim surrounding punctuation only — do NOT strip internal dots, or we
+		// would erase the extension separator (src/server.ts -> src/server/ts).
+		const token = raw.replace(/^[^A-Za-z0-9/]+|[^A-Za-z0-9/]+$/g, "");
+		if (!token.includes("/") || !token.includes(".")) continue;
+		const ext = token.split(".").pop()?.toLowerCase() ?? "";
+		if (INTERESTING_EXT.has(ext)) out.push(token);
+	}
+	return out;
 }
 
 /** Collect unique key files referenced across a set of messages. */
 export function collectKeyFiles(messages: EngineMessage[]): string[] {
-  const files = new Set<string>();
-  for (const m of messages) {
-    for (const c of [m.text, m.input, m.output]) {
-      if (!c) continue;
-      for (const f of extractFileCandidates(c)) files.add(f);
-    }
-  }
-  return [...files].slice(0, 8);
+	const files = new Set<string>();
+	for (const m of messages) {
+		for (const c of [m.text, m.input, m.output]) {
+			if (!c) continue;
+			for (const f of extractFileCandidates(c)) files.add(f);
+		}
+	}
+	return [...files].slice(0, 8);
 }
 
 /** Infer pending work from recent messages via keyword scan. */
 export function inferPendingWork(messages: EngineMessage[]): string[] {
-  const out: string[] = [];
-  for (const m of [...messages].reverse()) {
-    const t = firstText(m);
-    if (!t) continue;
-    const low = t.toLowerCase();
-    if (PENDING_WORDS.some((w) => low.includes(w))) {
-      out.push(truncate(t, 160));
-      if (out.length >= 3) break;
-    }
-  }
-  return out.reverse();
+	const out: string[] = [];
+	for (const m of [...messages].reverse()) {
+		const t = firstText(m);
+		if (!t) continue;
+		const low = t.toLowerCase();
+		if (PENDING_WORDS.some((w) => low.includes(w))) {
+			out.push(truncate(t, 160));
+			if (out.length >= 3) break;
+		}
+	}
+	return out.reverse();
 }
 
 /** Latest user request (for "current work" line). */
-export function inferCurrentWork(messages: EngineMessage[]): string | undefined {
-  for (const m of [...messages].reverse()) {
-    const t = firstText(m);
-    if (t && m.role === "user") return truncate(t, 200);
-  }
-  return undefined;
+export function inferCurrentWork(
+	messages: EngineMessage[],
+): string | undefined {
+	for (const m of [...messages].reverse()) {
+		const t = firstText(m);
+		if (t && m.role === "user") return truncate(t, 200);
+	}
+	return undefined;
 }
 
 /** Last N user requests, in original order. */
-export function collectRecentUserRequests(messages: EngineMessage[], limit: number): string[] {
-  const reqs = messages
-    .filter((m) => m.role === "user")
-    .map((m) => firstText(m))
-    .filter((t): t is string => Boolean(t))
-    .map((t) => truncate(t, 160));
-  return reqs.slice(-limit);
+export function collectRecentUserRequests(
+	messages: EngineMessage[],
+	limit: number,
+): string[] {
+	const reqs = messages
+		.filter((m) => m.role === "user")
+		.map((m) => firstText(m))
+		.filter((t): t is string => Boolean(t))
+		.map((t) => truncate(t, 160));
+	return reqs.slice(-limit);
 }
 
 /** Summarize a block to a one-line description. */
 function summarizeBlock(m: EngineMessage): string {
-  if (m.role === "tool") return `tool_result ${m.toolName ?? "?"}: ${truncate(m.output ?? m.text, 160)}`;
-  if (m.toolName) return `tool_use ${m.toolName}(${truncate(m.input ?? "", 160)})`;
-  return truncate(m.text, 160);
+	if (m.role === "tool")
+		return `tool_result ${m.toolName ?? "?"}: ${truncate(m.output ?? m.text, 160)}`;
+	if (m.toolName)
+		return `tool_use ${m.toolName}(${truncate(m.input ?? "", 160)})`;
+	return truncate(m.text, 160);
 }
 
 function stripTag(block: string, tag: string): string {
-  const start = `<${tag}>`;
-  const end = `</${tag}>`;
-  const s = block.indexOf(start);
-  const e = block.indexOf(end);
-  if (s === -1 || e === -1) return block;
-  return block.slice(0, s) + block.slice(e + end.length);
+	const start = `<${tag}>`;
+	const end = `</${tag}>`;
+	const s = block.indexOf(start);
+	const e = block.indexOf(end);
+	if (s === -1 || e === -1) return block;
+	return block.slice(0, s) + block.slice(e + end.length);
 }
 
 function extractTag(block: string, tag: string): string | undefined {
-  const s = block.indexOf(`<${tag}>`);
-  const e = block.indexOf(`</${tag}>`);
-  if (s === -1 || e === -1) return undefined;
-  return block.slice(s + `<${tag}>`.length, e);
+	const s = block.indexOf(`<${tag}>`);
+	const e = block.indexOf(`</${tag}>`);
+	if (s === -1 || e === -1) return undefined;
+	return block.slice(s + `<${tag}>`.length, e);
 }
 
 /** Normalize a raw summary into user-facing "Summary: ..." text. */
 export function formatCompactSummary(summary: string): string {
-  const withoutAnalysis = stripTag(summary, "analysis");
-  let formatted = withoutAnalysis;
-  const content = extractTag(withoutAnalysis, "summary");
-  if (content !== undefined) {
-    formatted = withoutAnalysis.replace(
-      `<summary>${content}</summary>`,
-      `Summary:\n${content.trim()}`,
-    );
-  }
-  return formatted.replace(/\n{3,}/g, "\n\n").trim();
+	const withoutAnalysis = stripTag(summary, "analysis");
+	let formatted = withoutAnalysis;
+	const content = extractTag(withoutAnalysis, "summary");
+	if (content !== undefined) {
+		formatted = withoutAnalysis.replace(
+			`<summary>${content}</summary>`,
+			`Summary:\n${content.trim()}`,
+		);
+	}
+	return formatted.replace(/\n{3,}/g, "\n\n").trim();
 }
 
 /**
@@ -147,125 +157,150 @@ export function formatCompactSummary(summary: string): string {
  * Mirrors claw-code summarize_messages.
  */
 export function summarizeMessages(messages: EngineMessage[]): string {
-  const users = messages.filter((m) => m.role === "user").length;
-  const assistants = messages.filter((m) => m.role === "assistant").length;
-  const tools = messages.filter((m) => m.role === "tool").length;
+	const users = messages.filter((m) => m.role === "user").length;
+	const assistants = messages.filter((m) => m.role === "assistant").length;
+	const tools = messages.filter((m) => m.role === "tool").length;
 
-  const toolNames = [...new Set(messages.flatMap((m) => (m.toolName ? [m.toolName] : [])))].sort();
+	const toolNames = [
+		...new Set(messages.flatMap((m) => (m.toolName ? [m.toolName] : []))),
+	].sort();
 
-  const lines: string[] = [
-    "<summary>",
-    "Conversation summary:",
-    `- Scope: ${messages.length} earlier messages compacted (user=${users}, assistant=${assistants}, tool=${tools}).`,
-  ];
-  if (toolNames.length) lines.push(`- Tools mentioned: ${toolNames.join(", ")}.`);
+	const lines: string[] = [
+		"<summary>",
+		"Conversation summary:",
+		`- Scope: ${messages.length} earlier messages compacted (user=${users}, assistant=${assistants}, tool=${tools}).`,
+	];
+	if (toolNames.length)
+		lines.push(`- Tools mentioned: ${toolNames.join(", ")}.`);
 
-  const recent = collectRecentUserRequests(messages, 3);
-  if (recent.length) {
-    lines.push("- Recent user requests:");
-    recent.forEach((r) => lines.push(`  - ${r}`));
-  }
+	const recent = collectRecentUserRequests(messages, 3);
+	if (recent.length) {
+		lines.push("- Recent user requests:");
+		recent.forEach((r) => lines.push(`  - ${r}`));
+	}
 
-  const pending = inferPendingWork(messages);
-  if (pending.length) {
-    lines.push("- Pending work:");
-    pending.forEach((p) => lines.push(`  - ${p}`));
-  }
+	const pending = inferPendingWork(messages);
+	if (pending.length) {
+		lines.push("- Pending work:");
+		pending.forEach((p) => lines.push(`  - ${p}`));
+	}
 
-  const files = collectKeyFiles(messages);
-  if (files.length) lines.push(`- Key files referenced: ${files.join(", ")}.`);
+	const files = collectKeyFiles(messages);
+	if (files.length) lines.push(`- Key files referenced: ${files.join(", ")}.`);
 
-  const current = inferCurrentWork(messages);
-  if (current) lines.push(`- Current work: ${current}`);
+	const current = inferCurrentWork(messages);
+	if (current) lines.push(`- Current work: ${current}`);
 
-  lines.push("- Key timeline:");
-  for (const m of messages) {
-    const role = m.role;
-    lines.push(`  - ${role}: ${summarizeBlock(m)}`);
-  }
-  lines.push("</summary>");
-  return lines.join("\n");
+	lines.push("- Key timeline:");
+	for (const m of messages) {
+		const role = m.role;
+		lines.push(`  - ${role}: ${summarizeBlock(m)}`);
+	}
+	lines.push("</summary>");
+	return lines.join("\n");
 }
 
 /** Extract the prior "highlights" + "timeline" sections from an existing summary. */
 function extractSummaryHighlights(summary: string): string[] {
-  const lines = formatCompactSummary(summary).split("\n");
-  const out: string[] = [];
-  let inTimeline = false;
-  for (const line of lines) {
-    const t = line.trimEnd();
-    if (!t || t === "Summary:" || t === "Conversation summary:") continue;
-    if (t === "- Key timeline:") { inTimeline = true; continue; }
-    if (inTimeline) continue;
-    out.push(t);
-  }
-  return out;
+	const lines = formatCompactSummary(summary).split("\n");
+	const out: string[] = [];
+	let inTimeline = false;
+	for (const line of lines) {
+		const t = line.trimEnd();
+		if (!t || t === "Summary:" || t === "Conversation summary:") continue;
+		if (t === "- Key timeline:") {
+			inTimeline = true;
+			continue;
+		}
+		if (inTimeline) continue;
+		out.push(t);
+	}
+	return out;
 }
 
 function extractSummaryTimeline(summary: string): string[] {
-  const lines = formatCompactSummary(summary).split("\n");
-  const out: string[] = [];
-  let inTimeline = false;
-  for (const line of lines) {
-    const t = line.trimEnd();
-    if (t === "- Key timeline:") { inTimeline = true; continue; }
-    if (!inTimeline) continue;
-    if (!t) break;
-    out.push(t);
-  }
-  return out;
+	const lines = formatCompactSummary(summary).split("\n");
+	const out: string[] = [];
+	let inTimeline = false;
+	for (const line of lines) {
+		const t = line.trimEnd();
+		if (t === "- Key timeline:") {
+			inTimeline = true;
+			continue;
+		}
+		if (!inTimeline) continue;
+		if (!t) break;
+		out.push(t);
+	}
+	return out;
 }
 
 /** Merge an existing compact summary with a new one (accumulate, don't overwrite). */
-export function mergeCompactSummaries(existing: string | undefined, newSummary: string): string {
-  if (!existing) return newSummary;
-  const prevHighlights = extractSummaryHighlights(existing);
-  const newHighlights = extractSummaryHighlights(formatCompactSummary(newSummary));
-  const newTimeline = extractSummaryTimeline(formatCompactSummary(newSummary));
+export function mergeCompactSummaries(
+	existing: string | undefined,
+	newSummary: string,
+): string {
+	if (!existing) return newSummary;
+	const prevHighlights = extractSummaryHighlights(existing);
+	const newHighlights = extractSummaryHighlights(
+		formatCompactSummary(newSummary),
+	);
+	const newTimeline = extractSummaryTimeline(formatCompactSummary(newSummary));
 
-  const lines = ["<summary>", "Conversation summary:"];
-  if (prevHighlights.length) {
-    lines.push("- Previously compacted context:");
-    prevHighlights.forEach((l) => lines.push(`  ${l}`));
-  }
-  if (newHighlights.length) {
-    lines.push("- Newly compacted context:");
-    newHighlights.forEach((l) => lines.push(`  ${l}`));
-  }
-  if (newTimeline.length) {
-    lines.push("- Key timeline:");
-    newTimeline.forEach((l) => lines.push(`  ${l}`));
-  }
-  lines.push("</summary>");
-  return lines.join("\n");
+	const lines = ["<summary>", "Conversation summary:"];
+	if (prevHighlights.length) {
+		lines.push("- Previously compacted context:");
+		prevHighlights.forEach((l) => lines.push(`  ${l}`));
+	}
+	if (newHighlights.length) {
+		lines.push("- Newly compacted context:");
+		newHighlights.forEach((l) => lines.push(`  ${l}`));
+	}
+	if (newTimeline.length) {
+		lines.push("- Key timeline:");
+		newTimeline.forEach((l) => lines.push(`  ${l}`));
+	}
+	lines.push("</summary>");
+	return lines.join("\n");
 }
 
 /** True when the compactable portion exceeds the budget. */
-export function shouldCompact(messages: EngineMessage[], maxEstimatedTokens: number, preserveRecent: number): boolean {
-  if (messages.length <= preserveRecent) return false;
-  const compactable = messages.slice(0, messages.length - preserveRecent);
-  return estimateSessionTokens(compactable) >= maxEstimatedTokens;
+export function shouldCompact(
+	messages: EngineMessage[],
+	maxEstimatedTokens: number,
+	preserveRecent: number,
+): boolean {
+	if (messages.length <= preserveRecent) return false;
+	const compactable = messages.slice(0, messages.length - preserveRecent);
+	return estimateSessionTokens(compactable) >= maxEstimatedTokens;
 }
 
 /** Local reimplementation of memory-mcp auto_compact_check. */
-export function autoCompactCheck(currentTokens: number, threshold = 50000): {
-  shouldCompact: boolean;
-  currentTokens: number;
-  threshold: number;
-  utilizationPct: number;
+export function autoCompactCheck(
+	currentTokens: number,
+	threshold = 50000,
+): {
+	shouldCompact: boolean;
+	currentTokens: number;
+	threshold: number;
+	utilizationPct: number;
 } {
-  return {
-    shouldCompact: currentTokens >= threshold,
-    currentTokens,
-    threshold,
-    utilizationPct: Math.round((currentTokens / threshold) * 1000) / 10,
-  };
+	return {
+		shouldCompact: currentTokens >= threshold,
+		currentTokens,
+		threshold,
+		utilizationPct: Math.round((currentTokens / threshold) * 1000) / 10,
+	};
 }
 
 /** Build the synthetic continuation message (system-prompt prepend form). */
-export function getContinuationMessage(summary: string, suppressFollowUp: boolean, recentPreserved: boolean): string {
-  let base = COMPACT_PREAMBLE + formatCompactSummary(summary);
-  if (recentPreserved) base += `\n\n${RECENT_NOTE}`;
-  if (suppressFollowUp) base += `\n${DIRECT_RESUME}`;
-  return base;
+export function getContinuationMessage(
+	summary: string,
+	suppressFollowUp: boolean,
+	recentPreserved: boolean,
+): string {
+	let base = COMPACT_PREAMBLE + formatCompactSummary(summary);
+	if (recentPreserved) base += `\n\n${RECENT_NOTE}`;
+	if (suppressFollowUp) base += `\n${DIRECT_RESUME}`;
+	return base;
 }

package/src/dedup/raptor/tree.ts

@@ -230,6 +230,17 @@ export function buildRaptorTree(leaves: Leaf[], opts: BuildOptions): RaptorTree
         qualityMarker,
         tokenEstimate,
       });
+      // Populate parentId for the internal nodes being absorbed into this
+      // parent summary. Group members with ids in `nodes` are internal summary
+      // nodes (level >= 1); raw leaf ids are not in `nodes` (per-leaf wrappers
+      // are intentionally absent) and are correctly skipped — leaf→summary
+      // walks go through the parent's `children` list instead.
+      for (const c of group) {
+        const child = nodes.get(c.id);
+        if (child && child.id !== merged.id) {
+          child.parentId = merged.id;
+        }
+      }
       nextLevel.push(merged);
     }
     currentLevel = nextLevel;

package/src/memory.test.ts

@@ -1,6 +1,7 @@
 import { test } from "node:test";
 import assert from "node:assert/strict";
-import { reviewConversation } from "./memory.js";
+import { reviewConversation, type MemoryOp } from "./memory.js";
+import type { EngineMessage } from "./types.js";
 
 test("reviewConversation: yields an ADD op for a stated decision", () => {
   const msgs = [
@@ -44,3 +45,48 @@ test("reviewConversation: REMOVE requires topic overlap (no accidental drop)", (
   const ops = reviewConversation(msgs, existing);
   assert.equal(ops.filter((o) => o.op === "remove").length, 0, "vague 'drop it' with no topic overlap does not remove anything");
 });
+
+// ---- E5 (docs/specs/s25-memory-db-roundtrip.md): hallucination-guard pins ----
+
+test("E5.3 — truncation pin: long decision truncates to 160 chars and stays message-grounded", () => {
+  // collectRecentUserRequests truncates user text at 160 chars before review.
+  // A long decision is silently clipped — undocumented before S25; this pins
+  // the boundary.
+  const long =
+    "we decided to use node:sqlite for the authoritative store backend after evaluating better-sqlite3, pglite and libsql and rejecting all three";
+  const msgs = [{ role: "user", text: long }] as any;
+  const ops = reviewConversation(msgs);
+  const add = ops.find((o) => o.op === "add") as Extract<MemoryOp, { op: "add" }> | undefined;
+  assert.ok(add, "a decision inside a long user message produces an add");
+  assert.ok(
+    add!.memory.content.length <= 160,
+    "stored content is 160-char truncated",
+  );
+  assert.ok(
+    long.includes(add!.memory.content),
+    "truncated content is still verbatim-grounded in the message",
+  );
+});
+
+test("E5.1 — hallucination guard: every surviving add/replace is verbatim from a real message", () => {
+  const msgs = [{ role: "user", text: "the pipeline uses dagster for orchestration" }] as EngineMessage[];
+  const ops = reviewConversation(msgs, [{ content: "we use better-sqlite3 for the store" }]);
+  for (const o of ops) {
+    if (o.op === "remove") continue; // REMOVE is exempt by design (:70-74)
+    assert.ok(
+      msgs.some((m) => String(m.text ?? "").includes(o.memory.content)),
+      "every add/replace content is verbatim from a real message",
+    );
+  }
+  assert.equal(ops.filter((o) => o.op !== "remove").length, 0, "non-decision text produces no add/replace");
+});
+
+test("E5.4 — REMOVE over-match pin: single-token topic overlap fires REMOVE", () => {
+  const existing = [{ content: "we use redis for the cache" }];
+  const msgs = [{ role: "user", text: "stop using redis" }] as any;
+  const ops = reviewConversation(msgs, existing);
+  assert.ok(
+    ops.some((o) => o.op === "remove" && /redis/i.test(o.content)),
+    "single-token overlap removes the matching memory (current behavior — KNOWN: weak topic match)",
+  );
+});

package/src/memoryOps.ts

@@ -13,23 +13,8 @@ import {
   type MemoryRecord,
 } from "./store/sqlite.js";
 import { defaultEmbedder } from "./embedder.js";
+import { repoKey } from "./store/repoKey.js";
 import { upsertMemoryEmbedding } from "./store/memoryIndex.js";
-import { execSync } from "node:child_process"; // guardrails-allow PREVENT-PI-004: read-only `git rev-parse` to scope the memory index per-repo
-
-/** Resolve the current repo's git root (mirrors extensions/mega-config.ts but
- *  kept local so src/ stays pi-agnostic — no extension-layer import). */
-function resolveRepoRootLocal(cwd: string): string | undefined {
-  try {
-    const out = execSync("git rev-parse --show-toplevel", {
-      cwd,
-      encoding: "utf-8",
-      stdio: ["ignore", "pipe", "ignore"],
-    }).trim();
-    return out || undefined;
-  } catch {
-    return undefined;
-  }
-}
 
 /** Find a memory row whose content exactly matches (case-insensitive). */
 function findByContent(memories: MemoryRecord[], content: string): MemoryRecord | undefined {
@@ -41,11 +26,11 @@ function findByContent(memories: MemoryRecord[], content: string): MemoryRecord
  * Fire-and-forget mirror of a memory write into the cross-repo PGlite index
  * (S24 optional memory-RAG mirror). Best-effort + non-fatal: never blocks the
  * SQLite write and degrades to the same-repo scan if the index is disabled or
- * fails. `repoId` is the resolved git root so the memory is findable from other
- * repos; falls back to the state dir when outside git.
+ * fails. `repoId` is the unified S25 repoKey (git root) so the memory is
+ * findable from other repos; falls back to the state dir outside git.
  */
 function indexMemoryWrite(stateDir: string, memoryId: number, content: string): void {
-  const repoId = resolveRepoRootLocal(stateDir) ?? stateDir;
+  const repoId = repoKey(stateDir);
   try {
     const vec = defaultEmbedder().embed(content);
     void upsertMemoryEmbedding(repoId, memoryId, content, vec);

package/src/memoryRecall.test.ts

@@ -131,6 +131,42 @@ test("recallMemoriesAndInline: surfaces a memory saved in ANOTHER repo via cross
   }
 });
 
+// ---- S25 §3.3: content de-dup in the cross-repo memory path -----------------
+// recallMemoriesCrossRepo (memoryRecall.ts:114) must NOT surface a memory the
+// local repo ALREADY has — same-repo authoritative store wins over the index.
+test("recallMemoriesCrossRepo: dedupes content the local repo already has", async () => {
+  process.env.MEGACOMPACT_INDEX_DIR = join(baseTmp, "xrepo-index-dedup");
+  const repoA = join(baseTmp, "dedup-a");
+  const repoB = join(baseTmp, "dedup-b");
+  try {
+    const { applyMemoryOps } = await import("./memoryOps.js");
+    const shared = "we standardized on node:sqlite for the store backend";
+    await applyMemoryOps(
+      [{ op: "add", memory: { content: shared, category: "decision", sourceTurn: 0 } }],
+      repoA,
+    );
+    await applyMemoryOps(
+      [{ op: "add", memory: { content: shared, category: "decision", sourceTurn: 0 } }],
+      repoB,
+    );
+    // The PGlite index now has repoA's copy; repoB ALSO has it locally. The
+    // cross-repo path for repoB must drop repoA's duplicate.
+    const { recallMemoriesCrossRepo } = await import("./memoryRecall.js");
+    const hits = await recallMemoriesCrossRepo("what store backend do we use?", repoB, {
+      crossRepoCosine: 0.0, // floor at 0: would match everything if dedup fails
+      limit: 5,
+    });
+    assert.ok(
+      hits.every((h) => h.memory.content.trim().toLowerCase() !== shared.toLowerCase()),
+      "cross-repo hit with content the local repo already has is dropped",
+    );
+  } finally {
+    const { closeMemoryIndex } = await import("./store/memoryIndex.js");
+    await closeMemoryIndex();
+    delete process.env.MEGACOMPACT_INDEX_DIR;
+  }
+});
+
 test("recallMemoriesAndInline: cross-repo disabled when MEGACOMPACT_PGLITE_DISABLED", async () => {
   process.env.MEGACOMPACT_INDEX_DIR = join(baseTmp, "xrepo-index-off");
   process.env.MEGACOMPACT_PGLITE_DISABLED = "true";