pi-mega-compact 0.8.23 → 0.8.25

package/src/recall.test.ts

@@ -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,
@@ -88,10 +88,12 @@ test("Fix C: recallMaxTokens caps the injected block", () => {
   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.
+  // 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: 100, skipInjected: false },
+    { sessionId: SESS, query: "module wiring config shutdown", limit: 5, source: "command", recallMaxTokens: 50, skipInjected: false },
     s as any,
   );
   assert.ok(r.toInject.length >= 1, "at least one injected under the cap");
@@ -246,6 +248,220 @@ test("S18: a fresh foreign checkpoint is injected AND recorded globally", async
   }
 });
 
+// ---- 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 as any,
+  );
+  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 as any,
+  );
+  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: string[] = [];
+    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/src/recall.ts

@@ -18,6 +18,9 @@ import { recall as searchRecall } from "./engine.js";
 import { vectorWasInjected, vectorMarkInjected, type SearchHit, type VectorStore, 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";
 
 export type RecallSource = "resume" | "command" | "sentinel";
 
@@ -42,6 +45,11 @@ export interface RecallInjectOptions {
    *  recall, a foreign checkpoint already injected (in any session) is skipped
    *  and a fresh injection is recorded globally. */
   globalIndexDir?: string;
+  /** S25 Phase-2: also inject top-level RAPTOR summary nodes (root + level-1
+   *  clusters) as a hierarchical overview HEADER on the recall block. Defaults
+   *  to the `RAPTOR_INJECT_SUMMARIES` config flag. The overview helps the model
+   *  see the session's topical structure before the detailed checkpoint hits. */
+  raptorSummaries?: boolean;
 }
 
 export interface RecallInjectResult {
@@ -64,6 +72,15 @@ export function formatRecallBlock(hits: SearchHit[]): string {
     // 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})` : "";
+    // 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` +
@@ -79,6 +96,33 @@ export function formatRecallBlock(hits: SearchHit[]): string {
   );
 }
 
+/**
+ * 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: { summary: string; level: number; score?: number }[],
+): string {
+  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
@@ -132,58 +176,119 @@ export function recallAndInline(
   const doWindowDedupe = opts.windowDedupe ?? false;
   const dedupSim = opts.dedupSim ?? 0.9;
 
-  const { hits } = searchRecall(
-    { sessionId: opts.sessionId, query: opts.query, limit, skipInjected: false },
+  // 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: number[][] = [];
   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: SearchHit[] = [];
-  const parts: string[] = [];
   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: VectorStore,
+  sessionId: string,
+  query: string,
+): string {
+  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: string; level: number; score: number }[] = [
+      { 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
+  }
+}
+
 // --- S21: memory recall ----------------------------------------------------
 // Durables (decisions, rules, user-saved facts) live in the `memories` table.
 // We mirror the checkpoint recall path: rank by cosine, format a block, respect
@@ -303,17 +408,37 @@ export async function recallAndInlineAsync(
     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: number[][] = [];
   if (doWindowDedupe && opts.liveWindow && opts.liveWindow.length > 0) {
-    const embedder = defaultEmbedder();
     liveEmbeddings = opts.liveWindow.map((m) => embedder.embed(m));
   }
 
   const toInject: SearchHit[] = [];
-  const parts: string[] = [];
   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) {
+    // 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
@@ -326,14 +451,15 @@ export async function recallAndInlineAsync(
         /* 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);
@@ -349,7 +475,10 @@ export async function recallAndInlineAsync(
     }
   }
 
-  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, " ")}…)`,
   );

package/src/store/sqlite/dedup-mirror.ts

@@ -21,6 +21,9 @@ export interface DedupMirrorRowDB {
 /**
  * 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: DatabaseSync,
@@ -29,29 +32,35 @@ export function upsertDedupMirror(
   seq: number,
 ): boolean {
   const now = Date.now();
-  const existing = db
-    .prepare(`SELECT content_hash FROM dedup_mirror WHERE content_hash = @hash`)
-    .get({ "@hash": contentHash }) as { content_hash: string } | undefined;
-  if (existing) {
-    db.prepare(`UPDATE dedup_mirror SET ref_count = ref_count + 1 WHERE content_hash = @hash`).run({
-      "@hash": contentHash,
-    });
-    return false;
-  }
-  db.prepare(
+  // 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)`,
-  ).run({
+     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;
+  }) as { ref_count: number } | undefined;
+  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: DatabaseSync,
@@ -64,12 +73,20 @@ export function getDedupRatio(
        WHERE session_id = @session_id`,
     )
     .get({ "@session_id": sessionId }) as { total: number };
+  // 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`,
+      `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() as { unique_bytes: number };
+    .get({ "@session_id": sessionId }) as { unique_bytes: number };
   const totalBytes = totalRow.total;
   const uniqueBytes = uniqueRow.unique_bytes;
   const ratio = uniqueBytes > 0 ? totalBytes / uniqueBytes : 1;
@@ -111,4 +128,4 @@ export function updateRawTranscriptRef(
     "@sid": sessionId,
     "@seq": seq,
   });
-}
+}

package/src/store/sqlite/maintenance.ts

@@ -36,7 +36,7 @@ const DB_TABLE_NAMES = [
   "checkpoint_epochs",
   "dedup_mirror",
   "memories",
-  "dedup_stats",
+  "meta",
   "daily_log",
 ] as const;
 
@@ -136,7 +136,7 @@ export function pruneOldRows(stateDir: string = getStateDir(), daysOld = 30): Ma
   // 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() as {
+  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() as {
     changes?: number;
   } | undefined;
   const dedupDeleted = delDedup?.changes ?? 0;