pi-mega-compact 0.11.4 → 0.11.5

package/src/mechanical-fix.test.ts

@@ -1,70 +0,0 @@
-/**
- * mechanical-fix.test.ts — focused unit tests for non-SQLite mechanical fixes:
- * appendCheckpoint session-id normalization (store.ts JSON file path) +
- * preserveRecentForPressure floor of 1 (config.ts).
- */
-import { describe, it } from "node:test";
-import assert from "node:assert/strict";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { mkdtempSync, rmSync } from "node:fs";
-import { appendCheckpoint, listCheckpoints } from "./store.js";
-import type { StoredCheckpoint } from "./store.js";
-import { preserveRecentForPressure } from "./config.js";
-
-// ---------------------------------------------------------------------------
-// appendCheckpoint (store.ts) — normalizeSessionId on the write path
-// ---------------------------------------------------------------------------
-
-describe("mechanical-fix: appendCheckpoint (store.ts)", () => {
-  it("write→read roundtrips with an UNprefixed sessionId", () => {
-    const dir = mkdtempSync(join(tmpdir(), "mc-mech-cp-"));
-    try {
-      const cp: StoredCheckpoint = {
-        checkpointId: "chkpt_001",
-        sessionId: "abc", // UNprefixed → normalizes to sess_abc
-        summary: "test summary",
-        keyDecisions: ["decide"],
-        nextSteps: ["step"],
-        filesModified: ["file.ts"],
-        tokenEstimate: 50,
-        regionHash: "r1",
-        embedding: [],
-        timestamp: 1000,
-      };
-      appendCheckpoint(cp, dir);
-      // listCheckpoints normalizes 'abc' → 'sess_abc' on read; appendCheckpoint
-      // now normalizes on write → both use the same file path.
-      const read = listCheckpoints("abc", dir);
-      assert.equal(read.length, 1);
-      assert.equal(read[0].checkpointId, "chkpt_001");
-      assert.equal(read[0].sessionId, "abc"); // original preserved in the object
-      assert.equal(read[0].summary, "test summary");
-      // Reading via the already-normalized form also works.
-      const read2 = listCheckpoints("sess_abc", dir);
-      assert.equal(read2.length, 1);
-    } finally {
-      rmSync(dir, { recursive: true, force: true });
-    }
-  });
-});
-
-// ---------------------------------------------------------------------------
-// preserveRecentForPressure (config.ts) — floor of 1
-// ---------------------------------------------------------------------------
-
-describe("mechanical-fix: preserveRecentForPressure (config.ts)", () => {
-  it("floors at 1 (never compact ALL messages)", () => {
-    // preserveRecentMin=0 at full pressure → 0 would compact everything; floor=1.
-    assert.equal(preserveRecentForPressure(1.0, 10, 0), 1);
-    // preserveRecentMin=0, preserveRecent=0 at any pressure → still 1.
-    assert.equal(preserveRecentForPressure(1.0, 0, 0), 1);
-  });
-
-  it("respects preserveRecentMin when above the floor", () => {
-    // preserveRecentMin=5 at full pressure → 5 (above the floor, no effect).
-    assert.equal(preserveRecentForPressure(1.0, 10, 5), 5);
-    // Normal case: pressure=0.5, preserveRecent=10, min=2 → round(10 - 8*0.5) = 6.
-    assert.equal(preserveRecentForPressure(0.5, 10, 2), 6);
-  });
-});

package/src/memory.test.ts

@@ -1,92 +0,0 @@
-import { test } from "node:test";
-import assert from "node:assert/strict";
-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 = [
-    { role: "user", text: "we use node:sqlite as the store" },
-    { role: "assistant", text: "got it, node:sqlite is the source of truth" },
-  ] as any;
-  const ops = reviewConversation(msgs);
-  assert.ok(ops.some((o) => o.op === "add" && /sqlite|store/i.test(o.memory.content)), "adds a decision memory");
-});
-
-test("reviewConversation: REPLACE when a later message contradicts an earlier one", () => {
-  const msgs = [
-    { role: "user", text: "the threshold is 50k" },
-    { role: "assistant", text: "ok 50k threshold" },
-    { role: "user", text: "actually raise the threshold to 100k" },
-  ] as any;
-  const ops = reviewConversation(msgs);
-  assert.ok(ops.some((o) => o.op === "replace"), "replaces the superseded value");
-});
-
-test("reviewConversation: no ops on pure smalltalk (no durable fact)", () => {
-  const msgs = [{ role: "user", text: "hi" }, { role: "assistant", text: "hey" }] as any;
-  assert.equal(reviewConversation(msgs).length, 0);
-});
-
-test("reviewConversation: emits REMOVE when a user asks to drop an existing memory", () => {
-  const existing = [{ content: "we use node:sqlite as the store" }];
-  // Plain drop statement — no "switch to …" phrasing so we don't accidentally
-  // match DECISION_PATTERNS and route into the replace branch instead.
-  const msgs = [
-    { role: "user", text: "stop using node:sqlite for the store — drop it from memory" },
-    { role: "assistant", text: "ok dropped" },
-  ] as any;
-  const ops = reviewConversation(msgs, existing);
-  assert.ok(ops.some((o) => o.op === "remove" && /sqlite/i.test(o.content)), "emits a remove op targeting the old memory");
-});
-
-test("reviewConversation: REMOVE requires topic overlap (no accidental drop)", () => {
-  const existing = [{ content: "the timezone is America/Los_Angeles" }];
-  const msgs = [{ role: "user", text: "drop it" }] as any;
-  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/memoryConsolidate.test.ts

@@ -1,47 +0,0 @@
-import { test } from "node:test";
-import assert from "node:assert/strict";
-import { mkdtempSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { consolidateMemories } from "./memory.js";
-import { addMemory, listMemories } from "./store/sqlite.js";
-
-const baseTmp = mkdtempSync(join(tmpdir(), "mc-consolidate-"));
-
-test("consolidateMemories: merges near-duplicate memories (one kept, one removed)", async () => {
-  const dir = join(baseTmp, "merge");
-  // Two near-identical memories — same topic, minor wording drift.
-  addMemory({ content: "we use node:sqlite as the store", category: "decision" }, null, dir);
-  addMemory({ content: "we use node:sqlite for our store", category: "decision" }, null, dir);
-
-  const merged = await consolidateMemories(dir);
-  assert.equal(merged, 1, "one merge was performed");
-
-  const rows = listMemories(null, 50, dir);
-  // Exactly one of the two near-dupes survives.
-  assert.equal(rows.length, 1, "exactly one memory remains after merge");
-  assert.match(rows[0].content, /node:sqlite.*store/i, "survivor mentions node:sqlite + store");
-});
-
-test("consolidateMemories: leaves unrelated memories alone", async () => {
-  const dir = join(baseTmp, "noop");
-  addMemory({ content: "we use node:sqlite as the store", category: "decision" }, null, dir);
-  addMemory({ content: "the gpt-5 release is on hold pending benchmark results", category: "note" }, null, dir);
-
-  const merged = await consolidateMemories(dir);
-  assert.equal(merged, 0, "no merges on unrelated memories");
-
-  const rows = listMemories(null, 50, dir);
-  assert.equal(rows.length, 2, "both memories survive");
-});
-
-test("consolidateMemories: empty store returns 0 and changes nothing", async () => {
-  const dir = join(baseTmp, "empty");
-  const merged = await consolidateMemories(dir);
-  assert.equal(merged, 0, "no merges on empty store");
-  assert.equal(listMemories(null, 50, dir).length, 0, "store still empty");
-});
-
-test("cleanup memops", () => {
-  rmSync(baseTmp, { recursive: true, force: true });
-});

package/src/memoryOps.test.ts

@@ -1,148 +0,0 @@
-// This file exercises the sync node:sqlite memory ops only, but every
-// applyMemoryOps() write also fires indexMemoryWrite() → upsertMemoryEmbedding()
-// at the machine-wide PGlite index, fire-and-forget, keyed by repoKey(stateDir)
-// — which for these tmp state dirs is the tmp path itself. Left alone that lands
-// in the developer's real ~/.pi/mega-compact-vector, where the rows stay
-// eligible for cross-repo recall forever: a live session can be handed
-// "threshold is 50k" and "the threshold is 100k" from this file as if they were
-// another project's memories. scripts/run-tests.mjs sets MEGACOMPACT_INDEX_DIR
-// per child, so the suite was already safe; running the file directly was not.
-//
-// Disabling PGlite is the same guard memoryRoundtrip.test.ts uses for the same
-// reason, and it also keeps the file's exit clean (no WASM handle, and no
-// initdb still running when the first test ends). MEGACOMPACT_INDEX_DIR is set
-// as well so the isolation holds if a later test needs the index re-enabled.
-process.env.MEGACOMPACT_PGLITE_DISABLED = "true";
-import { test } from "node:test";
-import assert from "node:assert/strict";
-import { mkdtempSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { applyMemoryOps } from "./memoryOps.js";
-import {
-  addMemory,
-  listMemories,
-  replaceMemory,
-  referenceMemory,
-  MEMORY_MAX_CHARS,
-} from "./store/sqlite.js";
-
-const baseTmp = mkdtempSync(join(tmpdir(), "mc-memops-"));
-process.env.MEGACOMPACT_INDEX_DIR = join(baseTmp, "index");
-
-test("applyMemoryOps: ADD inserts a new memory", async () => {
-  const dir = join(baseTmp, "add");
-  await applyMemoryOps(
-    [{ op: "add", memory: { content: "we use node:sqlite as the store", category: "decision", sourceTurn: 0 } }],
-    dir,
-  );
-  const rows = listMemories(null, 50, dir);
-  assert.ok(rows.some((m) => /node:sqlite/.test(m.content)), "added memory present");
-  assert.equal(rows[0].category, "decision", "category persisted");
-});
-
-test("applyMemoryOps: ADD is idempotent (no duplicate)", async () => {
-  const dir = join(baseTmp, "dup");
-  const op = { op: "add" as const, memory: { content: "threshold is 50k", category: "decision", sourceTurn: 0 } };
-  await applyMemoryOps([op], dir);
-  await applyMemoryOps([op], dir);
-  const rows = listMemories(null, 50, dir);
-  assert.equal(rows.filter((m) => /threshold is 50k/.test(m.content)).length, 1, "no duplicate");
-});
-
-test("applyMemoryOps: REPLACE updates the matching memory", async () => {
-  const dir = join(baseTmp, "replace");
-  addMemory({ content: "the threshold is 50k", category: "decision" }, null, dir);
-  await applyMemoryOps(
-    [{ op: "replace", targetContent: "the threshold is 50k", memory: { content: "the threshold is 100k", category: "decision", sourceTurn: 2 } }],
-    dir,
-  );
-  const rows = listMemories(null, 50, dir);
-  assert.ok(rows.some((m) => /100k/.test(m.content)), "replaced content present");
-  assert.ok(!rows.some((m) => /50k/.test(m.content)), "old content gone");
-});
-
-test("applyMemoryOps: REMOVE deletes the matching memory", async () => {
-  const dir = join(baseTmp, "remove");
-  addMemory({ content: "obsolete note", category: "note" }, null, dir);
-  await applyMemoryOps([{ op: "remove", content: "obsolete note" }], dir);
-  const rows = listMemories(null, 50, dir);
-  assert.ok(!rows.some((m) => /obsolete note/.test(m.content)), "removed");
-});
-
-test("S24: addMemory truncates content to MEMORY_MAX_CHARS", () => {
-  const dir = join(baseTmp, "cap");
-  const big = "x".repeat(MEMORY_MAX_CHARS + 5000);
-  const id = addMemory({ content: big, category: "note" }, null, dir);
-  const rows = listMemories(null, 50, dir);
-  const row = rows.find((m) => m.id === id);
-  assert.ok(row, "row present");
-  assert.ok(row!.content.length <= MEMORY_MAX_CHARS + 12, "content capped (incl. marker)");
-  assert.ok(row!.content.endsWith("…[truncated]"), "marker appended");
-});
-
-test("S24: replaceMemory also truncates oversized content", () => {
-  const dir = join(baseTmp, "capreplace");
-  const id = addMemory({ content: "short", category: "note" }, null, dir);
-  const big = "y".repeat(MEMORY_MAX_CHARS + 1000);
-  replaceMemory(id, { content: big }, dir);
-  const rows = listMemories(null, 50, dir);
-  const row = rows.find((m) => m.id === id);
-  assert.ok(row, "row present");
-  assert.ok(row!.content.length <= MEMORY_MAX_CHARS + 12, "replaced content capped");
-  assert.ok(row!.content.endsWith("…[truncated]"), "marker appended");
-});
-
-test("S24: addMemory evicts LRU rows past MEMORY_MAX_ROWS per repo", () => {
-  // Use a small env cap for a fast, deterministic LRU check (the production
-  // default is 500; this exercises the same code path).
-  process.env.MEGACOMPACT_MEMORY_MAX_ROWS = "10";
-  try {
-    const dir = join(baseTmp, "lru");
-    const n = 10;
-    const seeds = n - 2;
-    for (let i = 0; i < seeds; i++) addMemory({ content: `seed-${i}`, category: "note" }, null, dir);
-    const keep1 = addMemory({ content: "keep-recent-1", category: "note" }, null, dir);
-    const keep2 = addMemory({ content: "keep-recent-2", category: "note" }, null, dir);
-    // Mark the two as referenced so the LRU eviction spares them (they get a
-    // higher last_referenced than the un-referenced seeds).
-    assert.ok(referenceMemory(keep1, dir), "reference keep1");
-    assert.ok(referenceMemory(keep2, dir), "reference keep2");
-    // Insert 3 more — 3 over the cap across the inserts. The two referenced rows
-    // must survive; only un-referenced (oldest) seeds should be evicted.
-    addMemory({ content: "new-1", category: "note" }, null, dir);
-    addMemory({ content: "new-2", category: "note" }, null, dir);
-    addMemory({ content: "new-3", category: "note" }, null, dir);
-    const rows = listMemories(null, 1000, dir);
-    assert.equal(rows.length, n, "row count clamped to MEMORY_MAX_ROWS");
-    assert.ok(rows.some((m) => /keep-recent-1/.test(m.content)), "referenced row survived");
-    assert.ok(rows.some((m) => /keep-recent-2/.test(m.content)), "referenced row survived");
-    assert.ok(rows.some((m) => /new-3/.test(m.content)), "newest row present");
-    const seedRows = rows.filter((m) => /seed-/.test(m.content));
-    // 3 rows were evicted (the inserts pushed 3 past the cap); all evicted rows
-    // must be un-referenced seeds — the referenced rows survived above.
-    assert.equal(seedRows.length, seeds - 3, "exactly 3 oldest un-referenced seeds evicted");
-    assert.ok(!seedRows.some((m) => /seed-0/.test(m.content)), "oldest un-referenced seed evicted");
-  } finally {
-    delete process.env.MEGACOMPACT_MEMORY_MAX_ROWS;
-  }
-});
-
-test("S24: MEGACOMPACT_MEMORY_MAX_CHARS env override truncates content", () => {
-  process.env.MEGACOMPACT_MEMORY_MAX_CHARS = "50";
-  try {
-    const dir = join(baseTmp, "cap-env");
-    const id = addMemory({ content: "x".repeat(500), category: "note" }, null, dir);
-    const rows = listMemories(null, 50, dir);
-    const row = rows.find((m) => m.id === id);
-    assert.ok(row, "row present");
-    assert.equal(row!.content.length, 50 + "…[truncated]".length, "truncated to env cap + marker");
-    assert.ok(row!.content.endsWith("…[truncated]"), "marker appended");
-  } finally {
-    delete process.env.MEGACOMPACT_MEMORY_MAX_CHARS;
-  }
-});
-
-test("cleanup memops", () => {
-  rmSync(baseTmp, { recursive: true, force: true });
-});

package/src/memoryRecall.test.ts

@@ -1,194 +0,0 @@
-import { test } from "node:test";
-import assert from "node:assert/strict";
-import { mkdtempSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { recallMemories } from "./memoryRecall.js";
-import { addMemory, getMemory } from "./store/sqlite.js";
-
-const baseTmp = mkdtempSync(join(tmpdir(), "mc-memrec-"));
-
-function biGramEmbedder() {
-  // Deterministic test embedder — bigger dim + binary encoding so two semantically
-  // related strings have higher cosine than unrelated ones.
-  const dim = 64;
-  return {
-    dim,
-    embed(text: string): number[] {
-      const v = new Array(dim).fill(0);
-      const norm = text.toLowerCase().replace(/[^a-z0-9 ]/g, "").trim();
-      for (let i = 0; i < norm.length - 1; i++) {
-        const idx = ((norm.charCodeAt(i) * 31 + norm.charCodeAt(i + 1)) >>> 0) % dim;
-        v[idx] = 1;
-      }
-      return v;
-    },
-  };
-}
-
-test("recallMemories: ranks relevant memory above unrelated", async () => {
-  const dir = join(baseTmp, "rank");
-  addMemory({ content: "we use sqlite for the durable store", category: "decision" }, null, dir);
-  addMemory({ content: "the threshold is 100 thousand tokens", category: "decision" }, null, dir);
-  addMemory({ content: "katz says hi", category: "note" }, null, dir);
-  const hits = await recallMemories("what store do we use?", dir, {
-    embedder: biGramEmbedder(),
-    topK: 3,
-    minSimilarity: 0.0,
-  });
-  assert.ok(hits.length >= 2, "finds relevant");
-  assert.ok(/sqlite/.test(hits[0].memory.content), "top hit is sqlite one");
-  assert.ok(!/katz/.test(hits[0].memory.content), "unrelated not on top");
-});
-
-test("recallMemories: marks referenced hits (last_referenced updated)", async () => {
-  const dir = join(baseTmp, "ref");
-  addMemory({ content: "policy is local-only", category: "rule" }, null, dir);
-  const hits = await recallMemories("local-only policy", dir, { embedder: biGramEmbedder() });
-  assert.ok(hits.length >= 1);
-  const fresh = getMemory(hits[0].memory.id, dir);
-  assert.ok(fresh && fresh.lastReferenced && fresh.lastReferenced > 0, "lastReferenced set");
-});
-
-test("recallMemories: empty store returns []", async () => {
-  const dir = join(baseTmp, "empty");
-  const hits = await recallMemories("anything", dir, { embedder: biGramEmbedder() });
-  assert.deepEqual(hits, []);
-});
-
-test("recallMemories: decision category beats fact category at equal similarity", async () => {
-  const dir = join(baseTmp, "category");
-  // Two memories that share many bigrams with the query — both will have very
-  // similar cosine. The decision category should win because of categoryWeight.
-  addMemory({ content: "we use redis for cache" }, null, dir);
-  const aId = addMemory({ content: "we use redis as primary cache key", category: "fact" }, null, dir);
-  const dId = addMemory({ content: "we use redis as primary cache layer", category: "decision" }, null, dir);
-  const hits = await recallMemories("redis cache layer", dir, {
-    embedder: biGramEmbedder(),
-    topK: 3,
-    minSimilarity: 0.0,
-  });
-  assert.ok(hits.length >= 2);
-  assert.equal(hits[0].memory.id, dId, "decision-tagged memory outranks fact-tagged");
-  assert.notEqual(hits[0].memory.id, aId, "top is the decision row, not the unknown-category row");
-});
-
-test("recallMemories: fresher reference beats older at equal similarity", async () => {
-  const dir = join(baseTmp, "recency");
-  const aId = addMemory({ content: "we use redis for cache", category: "fact" }, null, dir);
-  const bId = addMemory({ content: "we use redis for cache layer", category: "fact" }, null, dir);
-  // Backdate aId so its last_referenced is older; bId stays fresh.
-  const { openStore, closeStore } = await import("./store/sqlite.js");
-  const db = openStore(dir);
-  const longAgo = Math.floor(Date.now() / 1000) - 30 * 86_400; // 30d
-  db.prepare("UPDATE memories SET last_referenced = ? WHERE id = ?").run(longAgo, aId);
-  // closeStore evicts the cached handle — calling db.close() directly would
-  // leave a stale closed DB in the openStore cache and break subsequent
-  // callers (the "database is not open" failure under parallel runs).
-  closeStore(dir);
-  const hits = await recallMemories("redis cache layer", dir, {
-    embedder: biGramEmbedder(),
-    topK: 3,
-    minSimilarity: 0.0,
-  });
-  assert.ok(hits.length >= 2);
-  assert.equal(hits[0].memory.id, bId, "freshly-referenced memory outranks 30-day-old one");
-});
-
-test("cleanup memrec", () => {
-  rmSync(baseTmp, { recursive: true, force: true });
-});
-
-// ---- S24: cross-repo memory recall (PGlite mirror) ---------------------------
-test("recallMemoriesAndInline: surfaces a memory saved in ANOTHER repo via cross-repo index", async () => {
-  // Isolate the global PGlite index to a temp dir shared by both "repos".
-  process.env.MEGACOMPACT_INDEX_DIR = join(baseTmp, "xrepo-index");
-  const repoA = join(baseTmp, "repo-a");
-  const repoB = join(baseTmp, "repo-b");
-  try {
-    // repoA owns a decision about the store backend.
-    const { applyMemoryOps } = await import("./memoryOps.js");
-    await applyMemoryOps(
-      [{ op: "add", memory: { content: "we standardized on node:sqlite for the store backend", category: "decision", sourceTurn: 0 } }],
-      repoA,
-    );
-    // repoB is a fresh session with NO local memory about the store backend.
-    const { recallMemoriesAndInline } = await import("./recall.js");
-    const res = await recallMemoriesAndInline({
-      query: "what store backend do we use?",
-      stateDir: repoB,
-      limit: 5,
-      crossRepo: true,
-      crossRepoCosine: 0.3,
-    });
-    assert.ok(!res.empty, "cross-repo recall found the other repo's memory");
-    assert.ok(/node:sqlite/.test(res.block), "the node:sqlite decision was recalled from repo A");
-    assert.ok(res.report.some((r) => /from /.test(r)), "report labels the memory as cross-repo");
-  } finally {
-    const { closeMemoryIndex } = await import("./store/memoryIndex.js");
-    await closeMemoryIndex();
-    delete process.env.MEGACOMPACT_INDEX_DIR;
-  }
-});
-
-// ---- 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";
-  const repoA = join(baseTmp, "repo-a2");
-  const repoB = join(baseTmp, "repo-b2");
-  try {
-    const { applyMemoryOps } = await import("./memoryOps.js");
-    await applyMemoryOps(
-      [{ op: "add", memory: { content: "we standardized on node:sqlite for the store backend", category: "decision", sourceTurn: 0 } }],
-      repoA,
-    );
-    const { recallMemoriesAndInline } = await import("./recall.js");
-    const res = await recallMemoriesAndInline({
-      query: "what store backend do we use?",
-      stateDir: repoB,
-      limit: 5,
-      crossRepo: true,
-    });
-    // Index disabled → no cross-repo hit; repoB has no local memory → empty.
-    assert.equal(res.empty, true, "cross-repo recall degrades to empty when disabled");
-  } finally {
-    delete process.env.MEGACOMPACT_PGLITE_DISABLED;
-    delete process.env.MEGACOMPACT_INDEX_DIR;
-  }
-});