pi-mega-compact 0.8.24 → 0.8.26

package/dist/src/recall.js

@@ -14,9 +14,12 @@
  * extension decides where it lands.
  */
 import { recall as searchRecall } from "./engine.js";
-import { vectorWasInjected, vectorMarkInjected, vectorSearchAsync } from "./vectorStore.js";
+import { vectorWasInjected, vectorMarkInjected, vectorSearchAsync, } from "./vectorStore.js";
 import { estimateBlockTokens } from "./tokens.js";
 import { defaultEmbedder, cosineSimilarity } from "./embedder.js";
+import { rehydrateRaptorTree, isShadowMode } from "./dedup/raptor/index.js";
+import { maxCheckpointTimestamp } from "./store/sqlite.js";
+import { normalizeSessionId } from "./store.js";
 /** Wrap a recall block so the model reads it as restored compacted context. */
 export function formatRecallBlock(hits) {
     if (hits.length === 0)
@@ -26,7 +29,16 @@ export function formatRecallBlock(hits) {
         // S17: label a cross-repo hit with its source repo (the repoId doubles as
         // that repo's stateDir, so the last path segment is the repo's display
         // name). Same-repo hits (no repoId) stay unlabeled.
-        const repoName = h.repoId ? ` (from repo ${h.repoId.split("/").filter(Boolean).pop() ?? h.repoId})` : "";
+        const repoName = h.repoId
+            ? ` (from repo ${h.repoId.split("/").filter(Boolean).pop() ?? h.repoId})`
+            : "";
+        // S42B: a RAPTOR cluster node hit (not a stored checkpoint) is labeled as a
+        // hierarchical summary and uses raptorSummary as its body. No Key files line
+        // (cluster nodes carry no file list).
+        if (h.raptorLevel !== undefined) {
+            return (`### Recalled cluster summary [${i + 1}] (level ${h.raptorLevel}, relevance ${score}%)${repoName}\n` +
+                `${(h.raptorSummary ?? h.checkpoint.summary).trim()}\n`);
+        }
         return (`### Recalled context [${i + 1}] (relevance ${score}%)${repoName}\n` +
             `${h.checkpoint.summary.trim()}\n` +
             (h.checkpoint.filesModified.length
@@ -37,6 +49,29 @@ export function formatRecallBlock(hits) {
         "and is relevant to the current request. Treat it as background you already know:\n\n" +
         parts.join("\n"));
 }
+/**
+ * S25 Phase-2: format the RAPTOR tree's top-level summary nodes (root + level-1
+ * clusters) as a hierarchical overview HEADER. Surfacing the high-level topical
+ * structure before the detailed checkpoint hits gives the model a map of what
+ * the session has covered. `nodes` are the RAPTOR summary nodes to surface,
+ * highest level first (root → level-1 clusters). Returns "" when empty.
+ */
+export function formatRaptorBlock(nodes) {
+    if (nodes.length === 0)
+        return "";
+    const parts = nodes.map((n, i) => {
+        const score = n.score !== undefined
+            ? ` (relevance ${(n.score * 100).toFixed(0)}%)`
+            : "";
+        const label = n.level === 0
+            ? `Session overview [${i + 1}]${score}`
+            : `Cluster summary [${i + 1}] (level ${n.level})${score}`;
+        return `### ${label}\n${n.summary.trim()}\n`;
+    });
+    return ("The following hierarchical overview summarizes the structure of this " +
+        "session so far. Use it as a map of what has been covered:\n\n" +
+        parts.join("\n"));
+}
 /**
  * Run the unified recall+dudupe+prepare-inject pipeline. Does NOT touch pi;
  * it records injections via `markInjected` so the next call dedupes. The
@@ -85,47 +120,115 @@ export function recallAndInline(opts, store) {
     const maxTokens = opts.recallMaxTokens ?? 0; // 0 = unbounded (legacy behavior)
     const doWindowDedupe = opts.windowDedupe ?? false;
     const dedupSim = opts.dedupSim ?? 0.9;
-    const { hits } = searchRecall({ sessionId: opts.sessionId, query: opts.query, limit, skipInjected: false }, store);
+    // F4: thread skipInjected through to searchRecall instead of hardcoding false
+    // and re-implementing the filter here. newHits is already deduped when skip
+    // is true (default); equals hits when skip is false (openclaw command path).
+    const { newHits } = searchRecall({ sessionId: opts.sessionId, query: opts.query, limit, skipInjected: skip }, store);
+    // F1: hoist one embedder instance for inline dedupe (matches the async path).
+    // defaultEmbedder() is deterministic but creating it per hit wastes allocations.
+    const embedder = defaultEmbedder();
     // Precompute live-window embeddings once for inline dedupe (Fix C). Trigram
     // embedder is local + cheap; never a network call (PREVENT-PI-004).
     let liveEmbeddings = [];
     if (doWindowDedupe && opts.liveWindow && opts.liveWindow.length > 0) {
-        const embedder = defaultEmbedder();
         liveEmbeddings = opts.liveWindow.map((m) => embedder.embed(m));
     }
-    // Shared dedup + bounded/inline block assembly. We build the block
-    // incrementally so the token cap can stop mid-stream (Fix C).
+    // F3: build the hit list first; format ONCE at the end so the block carries
+    // exactly one preamble and [1..n] numbering, and the token cap counts body
+    // tokens (one preamble at format time, not N). We accumulate summaries and
+    // break mid-stream when the cap would be exceeded.
     const toInject = [];
-    const parts = [];
     let blockTokens = 0;
-    for (const h of hits) {
-        if (skip && vectorWasInjected(store, opts.sessionId, h.checkpoint.checkpointId))
-            continue;
+    for (const h of newHits) {
         // Inline dedupe: skip a hit already resident in the live window (Fix C).
         if (doWindowDedupe && liveEmbeddings.length > 0) {
-            const hitVec = defaultEmbedder().embed(h.checkpoint.summary);
+            const hitVec = embedder.embed(h.checkpoint.summary);
             if (liveEmbeddings.some((v) => cosineSimilarity(v, hitVec) >= dedupSim))
                 continue;
         }
-        const part = formatRecallBlock([h]);
-        const partTokens = estimateBlockTokens(part);
+        const partTokens = estimateBlockTokens(h.checkpoint.summary);
         // Token cap: never push a chunk that would overrun the ceiling.
         if (maxTokens > 0 && blockTokens + partTokens > maxTokens)
             break;
-        parts.push(part);
         toInject.push(h);
         blockTokens += partTokens;
         vectorMarkInjected(store, opts.sessionId, h.checkpoint.checkpointId);
     }
-    const block = parts.join("\n");
+    // F3: format once — one preamble, correct [1..n] numbering.
+    const recallBlock = toInject.length > 0 ? formatRecallBlock(toInject) : "";
     const report = toInject.map((h) => `  • ${h.checkpoint.checkpointId} (${h.checkpoint.summary.slice(0, 60).replace(/\n/g, " ")}…)`);
+    // S25 Phase-2 (RAPTOR_INJECT_SUMMARIES): prepend a hierarchical overview
+    // header built from the tree's top-level summary nodes (root + the
+    // highest-scoring level-1 cluster summaries). This gives the model a topical
+    // map of the session before the detailed checkpoint hits. Default ON via
+    // the store's config; `opts.raptorSummaries` (when explicitly set) overrides.
+    // Skipped when no tree exists, the tree is stale/timedOut, or shadow mode is on.
+    let overview = "";
+    const injectSummaries = opts.raptorSummaries ?? store.cfg.RAPTOR_INJECT_SUMMARIES;
+    if (injectSummaries && recallBlock) {
+        overview = raptorOverviewBlock(store, opts.sessionId, opts.query);
+    }
+    const block = overview && recallBlock
+        ? overview + "\n" + recallBlock
+        : overview || recallBlock;
     return {
         toInject,
         report,
         block,
-        empty: toInject.length === 0,
+        empty: block.length === 0,
     };
 }
+/**
+ * S25 Phase-2: build the hierarchical overview header for a session. Rehydrates
+ * the persisted RAPTOR tree, picks the root + top level-1 cluster nodes by
+ * cosine similarity to the query, and formats them via formatRaptorBlock.
+ * Returns "" when no tree, stale tree, timedOut tree, or shadow mode. Non-fatal
+ * (wrapped in try/catch) — the overview is a bonus; a failure must never block
+ * the detailed recall block.
+ */
+function raptorOverviewBlock(store, sessionId, query) {
+    try {
+        const sid = normalizeSessionId(sessionId);
+        // S25 gate: the overview header is part of the RAPTOR serve surface, so it
+        // must honor the same contract as raptorSearchHits — shadow mode is
+        // logging-only building, not injection.
+        if (isShadowMode())
+            return "";
+        const tree = rehydrateRaptorTree(sid, store.stateDir);
+        if (!tree || !tree.rootId || tree.timedOut)
+            return "";
+        // Freshness: a tree built before the session's latest checkpoint is stale.
+        const maxTs = maxCheckpointTimestamp(sid, store.stateDir);
+        if (tree.builtAt && tree.builtAt < maxTs)
+            return "";
+        const root = tree.nodes.get(tree.rootId);
+        if (!root)
+            return "";
+        const qv = store.embedder.embed(query);
+        // Root (level 0) first, then the top level-1 clusters by cosine to the query.
+        const nodes = [
+            {
+                summary: root.summary,
+                level: root.level,
+                score: cosineSimilarity(qv, root.embedding),
+            },
+        ];
+        const level1 = [...tree.nodes.values()]
+            .filter((n) => n.level === 1 && n.summary)
+            .map((n) => ({
+            summary: n.summary,
+            level: n.level,
+            score: cosineSimilarity(qv, n.embedding),
+        }))
+            .sort((a, b) => b.score - a.score)
+            .slice(0, 3);
+        nodes.push(...level1);
+        return formatRaptorBlock(nodes);
+    }
+    catch {
+        return ""; // non-fatal: overview is a bonus
+    }
+}
 /** Format one memory hit for the recall block. Category + score for traceability. */
 export function formatMemoryRecallBlock(hits) {
     if (hits.length === 0)
@@ -219,16 +322,38 @@ export async function recallAndInlineAsync(opts, store) {
     catch {
         hits = [];
     }
+    // F1: hoist one embedder instance for inline dedupe. defaultEmbedder() is
+    // deterministic but creating it per call wastes allocations on large hit sets.
+    // (recallAndInline already hoisted this; applying the same fix here.)
+    const embedder = defaultEmbedder();
     let liveEmbeddings = [];
     if (doWindowDedupe && opts.liveWindow && opts.liveWindow.length > 0) {
-        const embedder = defaultEmbedder();
         liveEmbeddings = opts.liveWindow.map((m) => embedder.embed(m));
     }
     const toInject = [];
-    const parts = [];
     let blockTokens = 0;
+    // F2: when cross-repo is on but no global index dir could be resolved, skip
+    // foreign hits rather than injecting them undeduped — otherwise a foreign
+    // checkpoint with no machine-wide injected-set to consult would re-inject in
+    // every new session. Same-repo hits (no repoId) are unaffected. Warn once so
+    // the silent degradation is observable. (The extension resolver normally
+    // supplies a default globalIndexDir, so this is belt-and-braces.)
+    const skipCrossRepoHits = !!opts.crossRepo && !opts.globalIndexDir;
+    if (skipCrossRepoHits) {
+        try {
+            console.warn("[mega-compact:recall] cross-repo recall enabled but globalIndexDir is unset — " +
+                "skipping cross-repo injection to avoid re-injecting undeduped foreign checkpoints");
+        }
+        catch {
+            /* ignore */
+        }
+    }
     for (const h of hits) {
-        if (skip && vectorWasInjected(store, opts.sessionId, h.checkpoint.checkpointId))
+        // F2: skip foreign hits when we can't dedup them machine-wide.
+        if (skipCrossRepoHits && h.repoId)
+            continue;
+        if (skip &&
+            vectorWasInjected(store, opts.sessionId, h.checkpoint.checkpointId))
             continue;
         // S18: machine-wide injected-set — a foreign checkpoint already injected
         // (in any session) is never re-injected. Only applies to cross-repo hits
@@ -243,16 +368,17 @@ export async function recallAndInlineAsync(opts, store) {
                 /* non-fatal: degrade to per-session injected-set only */
             }
         }
+        // Inline dedupe: skip a hit already resident in the live window (F1: hoisted embedder).
         if (doWindowDedupe && liveEmbeddings.length > 0) {
-            const hitVec = defaultEmbedder().embed(h.checkpoint.summary);
+            const hitVec = embedder.embed(h.checkpoint.summary);
             if (liveEmbeddings.some((v) => cosineSimilarity(v, hitVec) >= dedupSim))
                 continue;
         }
-        const part = formatRecallBlock([h]);
-        const partTokens = estimateBlockTokens(part);
+        // F3: build the hit list first; format ONCE at the end so the block carries
+        // exactly one preamble and numbering [1..n] rather than one per hit.
+        const partTokens = estimateBlockTokens(h.checkpoint.summary);
         if (maxTokens > 0 && blockTokens + partTokens > maxTokens)
             break;
-        parts.push(part);
         toInject.push(h);
         blockTokens += partTokens;
         vectorMarkInjected(store, opts.sessionId, h.checkpoint.checkpointId);
@@ -268,7 +394,10 @@ export async function recallAndInlineAsync(opts, store) {
             }
         }
     }
-    const block = parts.join("\n");
+    // F3: format once — one preamble, correct [1..n] numbering, token cap counted
+    // against one preamble (not N). Pass the full toInject array so formatRecallBlock
+    // has repoId + score for proper labeling.
+    const block = toInject.length > 0 ? formatRecallBlock(toInject) : "";
     const report = toInject.map((h) => `  • ${h.checkpoint.checkpointId} (${h.checkpoint.summary.slice(0, 60).replace(/\n/g, " ")}…)`);
     return { toInject, report, block, empty: toInject.length === 0 };
 }

package/dist/src/recall.test.js

@@ -6,7 +6,7 @@ import { join } from "node:path";
 import { VectorStore } from "./vectorStore.js";
 import { compactSession } from "./engine.js";
 import { recallAndInline, recallAndInlineAsync, formatRecallBlock } from "./recall.js";
-import { vectorList } from "./vectorStore.js";
+import { vectorList, vectorWasInjected } from "./vectorStore.js";
 import { markInjectedGlobal, wasInjectedGlobal, closeIndexStore } from "./store/sqlite.js";
 import { closeVectorIndex, initVectorIndex, rebuildFromSqlite, } from "./store/vectorIndex.js";
 const baseTmp = mkdtempSync(join(tmpdir(), "mc-recall-"));
@@ -72,9 +72,11 @@ test("Fix C: recallMaxTokens caps the injected block", () => {
     compactSession({ sessionId: SESS, messages: [msg("user", "alpha module wiring and bootstrap sequence"), msg("assistant", "ok", "Edit")], keepFrom: 2, timestamp: 1 }, s);
     compactSession({ sessionId: SESS, messages: [msg("user", "beta module config and env resolution"), msg("assistant", "ok", "Edit")], keepFrom: 2, timestamp: 2 }, s);
     compactSession({ sessionId: SESS, messages: [msg("user", "gamma module shutdown and cleanup hooks"), msg("assistant", "ok", "Edit")], keepFrom: 2, timestamp: 3 }, s);
-    // A ceiling of 100 tokens fits the first checkpoint (~82) but stops before the
-    // second (~163 cumulative) — proving the cap bites mid-stream.
-    const r = recallAndInline({ sessionId: SESS, query: "module wiring config shutdown", limit: 5, source: "command", recallMaxTokens: 100, skipInjected: false }, s);
+    // A ceiling of 50 tokens fits the first checkpoint (~33 body tokens) but
+    // stops before the second (~65 cumulative) — proving the cap bites mid-stream.
+    // (F3: the cap now counts body tokens only — one preamble at format time, not
+    // N — matching the async path. The old per-hit preamble counting needed ~100.)
+    const r = recallAndInline({ sessionId: SESS, query: "module wiring config shutdown", limit: 5, source: "command", recallMaxTokens: 50, skipInjected: false }, s);
     assert.ok(r.toInject.length >= 1, "at least one injected under the cap");
     assert.ok(r.toInject.length < 3, "cap prevented all three from injecting");
     assert.ok(r.block.length > 0, "block non-empty");
@@ -199,6 +201,179 @@ test("S18: a fresh foreign checkpoint is injected AND recorded globally", async
         rmSync(selfStateDir, { recursive: true, force: true });
     }
 });
+// ---- F3: format-once — one preamble, [1..n] numbering, cap respected ----
+//
+// The fix (landed async, extended to sync here) accumulates the hit list and
+// calls formatRecallBlock ONCE at the end, so a multi-hit block carries exactly
+// one preamble and contiguous [1..n] labels instead of one preamble per hit.
+test("F3 (sync): multi-hit injection has exactly one preamble and [1..n] numbering", () => {
+    const s = store();
+    compactSession({ sessionId: SESS, messages: [msg("user", "alpha module wiring and bootstrap sequence"), msg("assistant", "ok", "Edit")], keepFrom: 2, timestamp: 1 }, s);
+    compactSession({ sessionId: SESS, messages: [msg("user", "beta module config and env resolution"), msg("assistant", "ok", "Edit")], keepFrom: 2, timestamp: 2 }, s);
+    compactSession({ sessionId: SESS, messages: [msg("user", "gamma module shutdown and cleanup hooks"), msg("assistant", "ok", "Edit")], keepFrom: 2, timestamp: 3 }, s);
+    const r = recallAndInline({ sessionId: SESS, query: "module wiring config shutdown", limit: 5, source: "command", skipInjected: false }, s);
+    assert.ok(r.toInject.length >= 2, "at least two hits injected (got " + r.toInject.length + ")");
+    // Exactly one preamble (the old per-hit format produced one per hit).
+    const preamble = "The following compacted context was recalled";
+    assert.equal(r.block.split(preamble).length - 1, 1, "exactly one preamble for a multi-hit block");
+    // Contiguous [1..n] numbering.
+    for (let i = 1; i <= r.toInject.length; i++) {
+        assert.ok(r.block.includes(`[${i}]`), `block includes [${i}]`);
+    }
+    // No out-of-range label (e.g. [n+1]) leaks in.
+    assert.ok(!r.block.includes(`[${r.toInject.length + 1}]`), "no extra-numbered label");
+});
+test("F3 (sync): recallMaxTokens caps mid-stream with exactly one preamble", () => {
+    const s = store();
+    compactSession({ sessionId: SESS, messages: [msg("user", "alpha module wiring and bootstrap sequence"), msg("assistant", "ok", "Edit")], keepFrom: 2, timestamp: 1 }, s);
+    compactSession({ sessionId: SESS, messages: [msg("user", "beta module config and env resolution"), msg("assistant", "ok", "Edit")], keepFrom: 2, timestamp: 2 }, s);
+    compactSession({ sessionId: SESS, messages: [msg("user", "gamma module shutdown and cleanup hooks"), msg("assistant", "ok", "Edit")], keepFrom: 2, timestamp: 3 }, s);
+    // A tight ceiling that fits the first checkpoint (~33 body tokens) but stops
+    // before the second (~65 cumulative). F3: body-only counting (one preamble at
+    // format time, not per hit), matching the async path.
+    const r = recallAndInline({ sessionId: SESS, query: "module wiring config shutdown", limit: 5, source: "command", skipInjected: false, recallMaxTokens: 50 }, s);
+    assert.ok(r.toInject.length < 3, "cap stopped before all three injected");
+    assert.ok(r.toInject.length >= 1, "at least one injected under the cap");
+    assert.equal(r.block.split("The following compacted context was recalled").length - 1, 1, "still exactly one preamble under the cap");
+});
+test("F3 (async): multi-hit cross-repo injection has exactly one preamble and [1..n] numbering", async () => {
+    if (process.env.MEGACOMPACT_PGLITE_DISABLED === "true") {
+        return;
+    } // skip when WASM index is off
+    const indexDir = mkdtempSync(join(tmpdir(), "mc-f3a-"));
+    const foreignStateDir = mkdtempSync(join(tmpdir(), "mc-f3a-foreign-"));
+    const selfStateDir = mkdtempSync(join(tmpdir(), "mc-f3a-self-"));
+    process.env.MEGACOMPACT_VECTOR_INDEX_DIR = mkdtempSync(join(tmpdir(), "mc-f3a-vidx-"));
+    try {
+        await closeVectorIndex();
+        // Seed multiple distinct foreign checkpoints so the cross-repo query yields
+        // more than one hit (needed to assert [1..n] numbering).
+        const foreign = new VectorStore({ stateDir: foreignStateDir, dedupSim: 0.9 });
+        const fsess = "sess_foreign_f3";
+        const summaries = [
+            "foreign repo authentication jwt token validation",
+            "foreign repo database connection pooling and retry",
+            "foreign repo logging telemetry and tracing spans",
+        ];
+        const cids = [];
+        for (let i = 0; i < summaries.length; i++) {
+            const res = compactSession({ sessionId: fsess, messages: [msg("user", summaries[i]), msg("assistant", "ok", "Edit")], keepFrom: 2, timestamp: i + 1 }, foreign);
+            if (res.checkpointId)
+                cids.push(res.checkpointId);
+        }
+        await rebuildFromSqlite(() => [{ repoId: foreignStateDir, stateDir: foreignStateDir }], (sd) => {
+            const st = new VectorStore({ stateDir: sd, dedupSim: 0.9 });
+            return vectorList(st, fsess).map((cp) => ({
+                sessionId: fsess, checkpointId: cp.checkpointId, embedding: cp.embedding,
+            }));
+        });
+        const pg = await initVectorIndex();
+        assert.ok(pg, "PGlite index should initialize");
+        const selfStore = new VectorStore({ stateDir: selfStateDir, dedupSim: 0.9 });
+        const r = await recallAndInlineAsync({ sessionId: "sess_f3", query: "foreign repo", limit: 5, source: "command", crossRepo: true, skipInjected: false, globalIndexDir: indexDir }, selfStore);
+        assert.ok(r.toInject.length >= 2, "at least two cross-repo hits (got " + r.toInject.length + ")");
+        assert.equal(r.block.split("The following compacted context was recalled").length - 1, 1, "exactly one preamble for a multi-hit async block");
+        for (let i = 1; i <= r.toInject.length; i++) {
+            assert.ok(r.block.includes(`[${i}]`), `async block includes [${i}]`);
+        }
+        assert.ok(!r.block.includes(`[${r.toInject.length + 1}]`), "no extra-numbered label (async)");
+    }
+    finally {
+        await closeVectorIndex();
+        closeIndexStore();
+        delete process.env.MEGACOMPACT_VECTOR_INDEX_DIR;
+        rmSync(indexDir, { recursive: true, force: true });
+        rmSync(foreignStateDir, { recursive: true, force: true });
+        rmSync(selfStateDir, { recursive: true, force: true });
+    }
+});
+// ---- F2: cross-repo injected-set bypass ----------------------------------
+//
+// When the same session resumes in a DIFFERENT repo, the per-repo session_state
+// has no injection marker for the foreign checkpoint (different stateDir), so
+// only the machine-wide injected-set (shared globalIndexDir) can block a
+// re-inject. The F2 fix ensures globalIndexDir is always resolved (via
+// getIndexDir in the extension), so wasInjectedGlobal is consulted; without
+// the fix, globalIndexDir was undefined and foreign checkpoints re-injected
+// every resume. This test passes globalIndexDir explicitly (simulating the
+// resolver default) and does NOT set MEGACOMPACT_INDEX_DIR.
+test("F2: cross-repo hit is not re-injected when resuming the same session in a different repo (shared index dir)", async () => {
+    if (process.env.MEGACOMPACT_PGLITE_DISABLED === "true") {
+        return;
+    } // skip when WASM index is off
+    const indexDir = mkdtempSync(join(tmpdir(), "mc-f2-"));
+    const foreignStateDir = mkdtempSync(join(tmpdir(), "mc-f2-foreign-"));
+    const selfStateDir1 = mkdtempSync(join(tmpdir(), "mc-f2-self1-"));
+    const selfStateDir2 = mkdtempSync(join(tmpdir(), "mc-f2-self2-"));
+    process.env.MEGACOMPACT_VECTOR_INDEX_DIR = mkdtempSync(join(tmpdir(), "mc-f2-vidx-"));
+    try {
+        await closeVectorIndex();
+        const seed = await seedForeignRepo(foreignStateDir);
+        await rebuildFromSqlite(() => [{ repoId: foreignStateDir, stateDir: foreignStateDir }], (sd) => {
+            const st = new VectorStore({ stateDir: sd, dedupSim: 0.9 });
+            return vectorList(st, seed.sessionId).map((cp) => ({
+                sessionId: seed.sessionId, checkpointId: cp.checkpointId, embedding: cp.embedding,
+            }));
+        });
+        const pg = await initVectorIndex();
+        assert.ok(pg, "PGlite index should initialize");
+        const sess = "sess_resume";
+        // Repo B: first recall — fresh foreign checkpoint is injected AND recorded
+        // in the shared machine-wide index.
+        const storeB = new VectorStore({ stateDir: selfStateDir1, dedupSim: 0.9 });
+        const r1 = await recallAndInlineAsync({ sessionId: sess, query: "foreign repo authentication jwt", limit: 3, source: "command", crossRepo: true, globalIndexDir: indexDir }, storeB);
+        assert.equal(r1.toInject.length, 1, "first recall (repo B) injects the foreign checkpoint");
+        assert.equal(wasInjectedGlobal(seed.checkpointId, sess, indexDir), true, "recorded in the shared index");
+        // Repo C: SAME session resumed in a DIFFERENT repo. The per-session injected
+        // set in repo C's store is empty (different stateDir), so only the shared
+        // global injected-set can block re-injection.
+        const storeC = new VectorStore({ stateDir: selfStateDir2, dedupSim: 0.9 });
+        assert.equal(vectorWasInjected(storeC, sess, seed.checkpointId), false, "repo C per-session set is empty (different stateDir)");
+        const r2 = await recallAndInlineAsync({ sessionId: sess, query: "foreign repo authentication jwt", limit: 3, source: "command", crossRepo: true, globalIndexDir: indexDir }, storeC);
+        assert.equal(r2.toInject.length, 0, "second recall (repo C) does NOT re-inject (machine-wide global dedup)");
+    }
+    finally {
+        await closeVectorIndex();
+        closeIndexStore();
+        delete process.env.MEGACOMPACT_VECTOR_INDEX_DIR;
+        rmSync(indexDir, { recursive: true, force: true });
+        rmSync(foreignStateDir, { recursive: true, force: true });
+        rmSync(selfStateDir1, { recursive: true, force: true });
+        rmSync(selfStateDir2, { recursive: true, force: true });
+    }
+});
+test("F2: without globalIndexDir, cross-repo hits are skipped (not injected undeduped)", async () => {
+    if (process.env.MEGACOMPACT_PGLITE_DISABLED === "true") {
+        return;
+    } // skip when WASM index is off
+    const foreignStateDir = mkdtempSync(join(tmpdir(), "mc-f2b-foreign-"));
+    const selfStateDir = mkdtempSync(join(tmpdir(), "mc-f2b-self-"));
+    process.env.MEGACOMPACT_VECTOR_INDEX_DIR = mkdtempSync(join(tmpdir(), "mc-f2b-vidx-"));
+    try {
+        await closeVectorIndex();
+        const seed = await seedForeignRepo(foreignStateDir);
+        await rebuildFromSqlite(() => [{ repoId: foreignStateDir, stateDir: foreignStateDir }], (sd) => {
+            const st = new VectorStore({ stateDir: sd, dedupSim: 0.9 });
+            return vectorList(st, seed.sessionId).map((cp) => ({
+                sessionId: seed.sessionId, checkpointId: cp.checkpointId, embedding: cp.embedding,
+            }));
+        });
+        const pg = await initVectorIndex();
+        assert.ok(pg, "PGlite index should initialize");
+        // No globalIndexDir → the F2 guard skips foreign hits rather than injecting
+        // them undeduped. Same-repo hits (none here) would still pass.
+        const selfStore = new VectorStore({ stateDir: selfStateDir, dedupSim: 0.9 });
+        const r = await recallAndInlineAsync({ sessionId: "sess_nodir", query: "foreign repo authentication jwt", limit: 3, source: "command", crossRepo: true }, selfStore);
+        assert.equal(r.toInject.length, 0, "foreign hit skipped when globalIndexDir is unset (no undeduped injection)");
+    }
+    finally {
+        await closeVectorIndex();
+        closeIndexStore();
+        delete process.env.MEGACOMPACT_VECTOR_INDEX_DIR;
+        rmSync(foreignStateDir, { recursive: true, force: true });
+        rmSync(selfStateDir, { recursive: true, force: true });
+    }
+});
 test("cleanup", () => {
     rmSync(baseTmp, { recursive: true, force: true });
 });

package/dist/src/store/sqlite/dedup-mirror.js

@@ -1,29 +1,38 @@
 /**
  * Upsert a row into dedup_mirror. If the hash already exists, increment ref_count.
  * Returns true if this was a NEW unique content (first insert), false if it was a duplicate.
+ *
+ * F3 fix: uses INSERT ... ON CONFLICT DO UPDATE (single atomic statement) instead of
+ * a check-then-act race-prone SELECT + UPDATE/INSERT sequence.
  */
 export function upsertDedupMirror(db, contentHash, contentBytes, seq) {
     const now = Date.now();
-    const existing = db
-        .prepare(`SELECT content_hash FROM dedup_mirror WHERE content_hash = @hash`)
-        .get({ "@hash": contentHash });
-    if (existing) {
-        db.prepare(`UPDATE dedup_mirror SET ref_count = ref_count + 1 WHERE content_hash = @hash`).run({
-            "@hash": contentHash,
-        });
-        return false;
-    }
-    db.prepare(`INSERT INTO dedup_mirror (content_hash, content_bytes, ref_count, first_seen_seq, created_at)
-     VALUES (@hash, @bytes, 1, @seq, @now)`).run({
+    // Atomic upsert: on conflict, increment ref_count in-place (no check-then-act
+    // race). RETURNING ref_count distinguishes the two paths in one statement:
+    // inserted rows report ref_count=1, conflict-updated rows report ref_count>1.
+    const row = db.prepare(`INSERT INTO dedup_mirror (content_hash, content_bytes, ref_count, first_seen_seq, created_at)
+     VALUES (@hash, @bytes, 1, @seq, @now)
+     ON CONFLICT(content_hash) DO UPDATE SET
+       ref_count = ref_count + 1,
+       content_bytes = excluded.content_bytes
+     RETURNING ref_count`).get({
         "@hash": contentHash,
         "@bytes": contentBytes,
         "@seq": seq,
         "@now": now,
     });
-    return true;
+    return (row?.ref_count ?? 1) === 1;
 }
 /**
  * Get dedup ratio for a session: total bytes vs unique bytes.
+ *
+ * F2 fix: both total and unique bytes are now scoped to the session, via a JOIN
+ * of raw_transcript.content_ref → dedup_mirror. The ratio is meaningful: how much
+ * smaller the session's storage footprint is compared to naive inline storage.
+ *
+ * NOTE: for sessions with NO dedup pipeline runs yet (all content_ref NULL),
+ * uniqueBytes falls back to the raw_transcript bytes (ratio=1), which is correct
+ * since nothing has been deduplicated yet.
  */
 export function getDedupRatio(db, sessionId) {
     const totalRow = db
@@ -31,10 +40,18 @@ export function getDedupRatio(db, sessionId) {
        FROM raw_transcript
        WHERE session_id = @session_id`)
         .get({ "@session_id": sessionId });
+    // F2 fix: session-scoped unique bytes via JOIN on content_ref.
+    // A row contributes its dedup_mirror bytes exactly once even when content_ref
+    // is NULL (fallback: use the raw_transcript bytes for that row, which is
+    // accurate when dedup hasn't run yet for the session).
     const uniqueRow = db
-        .prepare(`SELECT COALESCE(SUM(LENGTH(content_bytes)), 0) AS unique_bytes
-       FROM dedup_mirror`)
-        .get();
+        .prepare(`SELECT COALESCE(SUM(LENGTH(
+        COALESCE(dm.content_bytes, rt.content_bytes)
+      )), 0) AS unique_bytes
+       FROM raw_transcript rt
+       LEFT JOIN dedup_mirror dm ON rt.content_ref = dm.content_hash
+       WHERE rt.session_id = @session_id`)
+        .get({ "@session_id": sessionId });
     const totalBytes = totalRow.total;
     const uniqueBytes = uniqueRow.unique_bytes;
     const ratio = uniqueBytes > 0 ? totalBytes / uniqueBytes : 1;

package/dist/src/store/sqlite/maintenance.js

@@ -15,7 +15,7 @@ const DB_TABLE_NAMES = [
     "checkpoint_epochs",
     "dedup_mirror",
     "memories",
-    "dedup_stats",
+    "meta",
     "daily_log",
 ];
 function fileSizeIfExists(path) {
@@ -102,7 +102,7 @@ export function pruneOldRows(stateDir = getStateDir(), daysOld = 30) {
     // dedup_mirror: cascade-delete orphan rows whose ref_count has dropped to 0
     // after the raw_transcript deletes. Safe even if FK is off (raw_transcript has
     // no FK to dedup_mirror; ref_count is maintained by the dedup pipeline).
-    const delDedup = db.prepare(`DELETE FROM dedup_mirror WHERE ref_count <= 0`).run();
+    const delDedup = db.prepare(`DELETE FROM dedup_mirror WHERE content_hash NOT IN (SELECT DISTINCT content_ref FROM raw_transcript WHERE content_ref IS NOT NULL)`).run();
     const dedupDeleted = delDedup?.changes ?? 0;
     const afterBytes = fileSizeIfExists(join(stateDir, "sqlite.db"));
     const total = rtDeleted + epDeleted + dedupDeleted;