pi-mega-compact 0.11.4 → 0.11.6

package/dist/src/intent.test.js

@@ -1,78 +0,0 @@
-/**
- * intent.test.ts — S52A rewind-intent queue tests. No network; temp dirs.
- */
-import { test, beforeEach, afterEach } 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 { openTurnStore, closeAllTurnDbs } from "./store/turns/connection.js";
-import { openIntentQueue } from "./intent.js";
-let tmpDir;
-let counter = 0;
-beforeEach(() => {
-    tmpDir = mkdtempSync(join(tmpdir(), "mc-intent-"));
-});
-afterEach(() => {
-    closeAllTurnDbs();
-    rmSync(tmpDir, { recursive: true, force: true });
-});
-function stateDir() {
-    return join(tmpDir, `run-${counter++}`);
-}
-test("postIntent creates a pending intent", () => {
-    const dir = stateDir();
-    const db = openTurnStore(dir);
-    const q = openIntentQueue(db);
-    const intent = q.postIntent({ conversationId: "conv_a", targetTurnIndex: 3 });
-    assert.equal(intent.conversationId, "conv_a");
-    assert.equal(intent.targetTurnIndex, 3);
-    assert.equal(intent.status, "pending");
-    assert.ok(intent.id.length > 0);
-    assert.ok(intent.createdAt > 0);
-});
-test("pendingIntents lists only unconsumed", () => {
-    const dir = stateDir();
-    const db = openTurnStore(dir);
-    const q = openIntentQueue(db);
-    q.postIntent({ conversationId: "c1", targetTurnIndex: 1 });
-    const i2 = q.postIntent({ conversationId: "c2", targetTurnIndex: 2 });
-    assert.equal(q.pendingIntents().length, 2);
-    q.consumeIntent(i2.id);
-    assert.equal(q.pendingIntents().length, 1);
-    assert.equal(q.pendingIntents()[0].conversationId, "c1");
-});
-test("consumeIntent marks status consumed (not deleted)", () => {
-    const dir = stateDir();
-    const db = openTurnStore(dir);
-    const q = openIntentQueue(db);
-    const intent = q.postIntent({ conversationId: "c", targetTurnIndex: 0 });
-    q.consumeIntent(intent.id);
-    assert.equal(q.pendingIntents().length, 0);
-    const all = q.allIntents();
-    assert.equal(all.length, 1);
-    assert.equal(all[0].status, "consumed");
-    assert.equal(all[0].id, intent.id);
-});
-test("abandonIntent deletes the intent", () => {
-    const dir = stateDir();
-    const db = openTurnStore(dir);
-    const q = openIntentQueue(db);
-    const intent = q.postIntent({ conversationId: "c", targetTurnIndex: 0 });
-    q.abandonIntent(intent.id);
-    assert.equal(q.pendingIntents().length, 0);
-    assert.equal(q.allIntents().length, 0);
-});
-test("allIntents returns newest-first + respects limit", () => {
-    const dir = stateDir();
-    const db = openTurnStore(dir);
-    const q = openIntentQueue(db);
-    q.postIntent({ conversationId: "a", targetTurnIndex: 0 });
-    q.postIntent({ conversationId: "b", targetTurnIndex: 0 });
-    q.postIntent({ conversationId: "c", targetTurnIndex: 0 });
-    const all = q.allIntents();
-    assert.equal(all.length, 3);
-    // newest-first: c was posted last
-    assert.equal(all[0].conversationId, "c");
-    assert.equal(q.allIntents(2).length, 2);
-});

package/dist/src/log.test.js

@@ -1,42 +0,0 @@
-import { test } from "node:test";
-import assert from "node:assert/strict";
-import { mkdtempSync, rmSync, readFileSync, existsSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { Logger } from "./log.js";
-const baseTmp = mkdtempSync(join(tmpdir(), "mc-log-"));
-let counter = 0;
-function logPath() {
-    return join(baseTmp, `run-${counter++}`, "mega-compact.log");
-}
-test("logger appends one JSON line per entry", () => {
-    const path = logPath();
-    let clock = 1000;
-    const log = new Logger({ path, now: () => clock++ });
-    log.info("compact", { checkpointId: "chkpt_001" });
-    log.warn("recall-empty", { query: "x" });
-    const lines = readFileSync(path, "utf8").trim().split("\n");
-    assert.equal(lines.length, 2);
-    const first = JSON.parse(lines[0]);
-    assert.equal(first.level, "info");
-    assert.equal(first.event, "compact");
-    assert.equal(first.checkpointId, "chkpt_001");
-    assert.equal(first.ts, 1000);
-    const second = JSON.parse(lines[1]);
-    assert.equal(second.level, "warn");
-    assert.equal(second.ts, 1001);
-});
-test("disabled logger writes nothing", () => {
-    const path = logPath();
-    const log = new Logger({ path, enabled: false });
-    log.info("compact", { a: 1 });
-    assert.equal(existsSync(path), false);
-});
-test("logger never throws on a bad path", () => {
-    // A path whose parent cannot be created (null byte) — must be swallowed.
-    const log = new Logger({ path: "/\0/nope.log" });
-    assert.doesNotThrow(() => log.error("boom", { x: 1 }));
-});
-test("cleanup", () => {
-    rmSync(baseTmp, { recursive: true, force: true });
-});

package/dist/src/mechanical-fix.test.js

@@ -1,65 +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 { 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 = {
-                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/dist/src/memory.test.js

@@ -1,70 +0,0 @@
-import { test } from "node:test";
-import assert from "node:assert/strict";
-import { reviewConversation } from "./memory.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" },
-    ];
-    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" },
-    ];
-    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" }];
-    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" },
-    ];
-    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" }];
-    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 }];
-    const ops = reviewConversation(msgs);
-    const add = ops.find((o) => o.op === "add");
-    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" }];
-    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" }];
-    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/dist/src/memoryConsolidate.test.js

@@ -1,38 +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/dist/src/memoryOps.test.js

@@ -1,129 +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", 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/dist/src/memoryRecall.test.js

@@ -1,171 +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) {
-            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;
-    }
-});