pi-mega-compact 0.6.1 → 0.6.2

package/extensions/mega-teamrun.test.ts

@@ -0,0 +1,164 @@
+/**
+ * mega-teamrun.test.ts — regression test for the "auto-compact runs but context
+ * never relieves during a team run (sub-agents)" bug.
+ *
+ * Loads the REAL compiled extension (extensions/mega-compact.js) through a
+ * faithful mock pi (mirrors mega-compact.test.ts's harness) and drives the
+ * exact event sequence a long team run produces:
+ *
+ *   agent_start -> context (over threshold) xN -> agent_end   (repeat x3)
+ *
+ * Asserts the TWO fixes:
+ *   1. live trim FIRES per-call (computeLiveTrimCut no longer returns null on
+ *      the anchor floor — was `cutNull`, liveTrimFires===0 before the fix).
+ *   2. the DURABLE trim fires at agent_end while idle + over threshold
+ *      (mid-run durable trigger), not only at parent settle.
+ *
+ * The mock ctx.compact() drives session_before_compact so we observe the
+ * durable truncation. Counters come from MegaRuntime.diag* (set behind the
+ * real handler code, inert in production).
+ *
+ * MEGACOMPACT_PGLITE_DISABLED keeps the run fast (no WASM index init).
+ */
+
+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 { createRequire } from "node:module";
+import { closeVectorIndex } from "../src/store/vectorIndex.js";
+import type { AgentMessage } from "@earendil-works/pi-agent-core";
+
+const require = createRequire(import.meta.url);
+const baseTmp = mkdtempSync(join(tmpdir(), "mc-team-"));
+process.env.MEGACOMPACT_INDEX_DIR = join(baseTmp, "index");
+process.env.MEGACOMPACT_PGLITE_DISABLED = "true"; // fast: skip WASM index
+let counter = 0;
+
+function harness() {
+  const stateDir = join(baseTmp, `run-${counter++}`);
+  process.env.MEGACOMPACT_STATE_DIR = stateDir;
+  process.env.MEGACOMPACT_DEBUG = "true";
+  process.env.MEGACOMPACT_THRESHOLD_TOKENS = "50";
+  process.env.MEGACOMPACT_FAST_GATE_PCT = "1";
+  process.env.MEGACOMPACT_ANCHOR_USER_MESSAGES = "1";
+  process.env.MEGACOMPACT_DURABLE_TRIM_FLOOR = "0"; // piCompactWouldNoop must not skip
+  process.env.MEGACOMPACT_MEMORY_AUTO_REVIEW = "false";
+  process.env.MEGACOMPACT_RAPTOR_ENABLED = "false";
+  delete process.env.MEGACOMPACT_LEGACY_DURABLE_TRIM;
+
+  const handlers: Record<string, Function> = {};
+  const compactCalls: any[] = [];
+
+  function msg(role: string, text: string, toolName?: string): AgentMessage {
+    if (role === "assistant" && toolName) {
+      return { role: "assistant", content: [{ type: "toolCall", name: toolName, id: "c1", arguments: {} }], api: "anthropic-messages", provider: "anthropic", model: "m", usage: { inputTokens: 1, outputTokens: 1, cacheReadTokens: 0, cacheWriteTokens: 0 }, stopReason: "tool_use", timestamp: 0 } as unknown as AgentMessage;
+    }
+    if (role === "toolResult" && toolName) {
+      return { role: "toolResult", content: [{ type: "text", text }], toolCallId: "c1", toolName, isError: false, timestamp: 0 } as unknown as AgentMessage;
+    }
+    return { role: "user", content: text, timestamp: 0 } as unknown as AgentMessage;
+  }
+
+  const session: AgentMessage[] = [];
+  for (let i = 0; i < 14; i++) {
+    session.push(msg("user", `actually we decided to use approach ${i} for module ${i}`));
+    session.push(msg("assistant", `edited module ${i}`, "Edit"));
+    session.push(msg("toolResult", `edited module ${i}`, "Edit"));
+  }
+
+  const toEntry = (m: AgentMessage, i: number): any => ({ type: "message", id: `e${i}`, parentId: null, timestamp: String(i), message: m });
+  const sessionManager = {
+    getSessionId: () => "sess_team_001",
+    getEntries: () => session.map(toEntry),
+    getBranch: () => session.map(toEntry),
+  };
+
+  function makeCtx(over: Partial<any> = {}) {
+    return {
+      ui: { setStatus: () => {}, notify: () => {}, select: () => {}, confirm: async () => true, input: async () => "", setWidget: () => {} },
+      mode: "tui" as any, hasUI: true, cwd: stateDir, sessionManager,
+      modelRegistry: {} as any, model: undefined, isIdle: () => true, isProjectTrusted: () => true,
+      signal: undefined, abort: () => {}, hasPendingMessages: () => false, shutdown: () => {},
+      getContextUsage: () => ({ tokens: 200000, contextWindow: 200000, percent: 100 }),
+      // Mock ctx.compact() runs pi's flow and fires session_before_compact.
+      compact: (opts?: any) => {
+        compactCalls.push(opts);
+        if (handlers["session_before_compact"]) {
+          return handlers["session_before_compact"](
+            { type: "session_before_compact", reason: "threshold", willRetry: false, signal: undefined, preparation: { firstKeptEntryId: "e2", messagesToSummarize: session.slice(0, 2), tokensBefore: 500 } } as any,
+            makeCtx(),
+          );
+        }
+        return undefined;
+      },
+      getSystemPrompt: () => "system base",
+      ...over,
+    } as any;
+  }
+
+  const pi = {
+    on: (ev: string, h: Function) => { handlers[ev] = h; },
+    registerCommand: () => {}, registerTool: () => {}, registerShortcut: () => {},
+    registerFlag: () => {}, getFlag: () => undefined, registerMessageRenderer: () => {},
+    registerEntryRenderer: () => {}, sendMessage: () => {}, sendUserMessage: () => {},
+    appendEntry: () => {}, setSessionName: () => {}, getSessionName: () => undefined,
+    setLabel: () => {}, exec: async () => ({ stdout: "", stderr: "", code: 0 }),
+    getActiveTools: () => [], getAllTools: () => [], setActiveTools: () => {},
+    getCommands: () => [], setModel: async () => false, getThinkingLevel: () => "off" as any,
+    setThinkingLevel: () => {},
+  } as any;
+
+  const mod = require("./mega-compact.js") as { default: (p: any) => void };
+  mod.default(pi);
+  const { lastRuntime } = require("./mega-events.js") as { lastRuntime: any };
+
+  const fire = (ev: string, event: any, ctx: any) => handlers[ev](event, ctx);
+  return {
+    stateDir, handlers, compactCalls, fire, ctx: makeCtx, session,
+    runtime: lastRuntime, // MegaRuntime with diag* counters
+    // Advance the debounce so agent_end (same instant) can trigger durable trim.
+    clearDebounce: () => { if (lastRuntime) lastRuntime.debounceUntil = 0; },
+  };
+}
+
+test("team run: live trim fires AND durable trim fires per sub-agent (relieves context)", async () => {
+  const h = harness();
+  const ctx = h.ctx();
+  for (let a = 0; a < 3; a++) {
+    await h.fire("agent_start", { type: "agent_start", messages: [] }, ctx);
+    for (let i = 0; i < 4; i++) {
+      await h.fire("context", { type: "context", messages: h.session }, ctx);
+    }
+    // Real team runs settle seconds after the last context event; mimic that
+    // so the 2s debounce has elapsed and the durable trigger can fire.
+    await new Promise((r) => setTimeout(r, 2100));
+    h.clearDebounce();
+    await h.fire("agent_end", { type: "agent_end", messages: [] }, ctx);
+  }
+  const rt = h.runtime;
+  // FIX 1: live trim must actually fire (was 0 — computeLiveTrimCut returned null).
+  assert.ok(rt.diagLiveTrimFires > 0, "live trim fires during the team run (anchor-floor fix)");
+  assert.equal(rt.diagCtxCutNull, 0, "no live-trim cut skipped on anchor floor");
+  // FIX 2: durable trim must fire at each agent_end (was 0 — only at parent settle).
+  assert.equal(rt.diagAgentEndDurable, 3, "mid-run durable trigger fired at each agent_end");
+  assert.equal(rt.diagBeforeCompactSupplied, 3, "our durable trim supplied 3x (context relieved)");
+  assert.ok(h.compactCalls.length >= 3, "ctx.compact() invoked for durable trim between sub-agents");
+});
+
+test("control: session_before_compact supplies a durable compaction (parent settles)", async () => {
+  const h = harness();
+  const res = await h.fire(
+    "session_before_compact",
+    { type: "session_before_compact", reason: "threshold", willRetry: false, signal: undefined, preparation: { firstKeptEntryId: "e2", messagesToSummarize: h.session.slice(0, 4), tokensBefore: 500 } } as any,
+    h.ctx(),
+  );
+  assert.ok(res?.compaction, "compaction result returned to pi");
+  assert.equal(res.compaction.firstKeptEntryId, "e2", "reuses pi's boundary (PREVENT-PI-002)");
+});
+
+test("cleanup", async () => {
+  await closeVectorIndex();
+  rmSync(baseTmp, { recursive: true, force: true });
+});

package/extensions/mega-trim.ts

@@ -46,7 +46,34 @@ export function computeLiveTrimCut(view: EngineMessage[], opts: BuildLiveTrimVie
   if (cut <= 0) return null; // nothing safe to cut — keep everything this call
   const recent = view.slice(cut);
   const userCount = recent.filter((m) => m.role === "user").length;
-  if (userCount < opts.anchorUserMessages) return null;
+  // ANCHOR FLOOR (PREVENT-PI-001): the recent window must keep at least
+  // `anchorUserMessages` user messages. The original compactedFrom can land on a
+  // run that starts with fewer than that (e.g. the preserved region begins on a
+  // tool pair, or the session's tail is tool-heavy). Instead of bailing out and
+  // skipping the live trim entirely this call (which left the model fed a
+  // 150k-context window during long team runs), walk `cut` backward until the
+  // preserved run contains enough user messages — bounded by the boundary-safe
+  // constraint so we never split a tool pair. Falls back to null only when the
+  // whole view can't satisfy the floor (tiny sessions) — the next context event
+  // retries.
+  if (userCount < opts.anchorUserMessages) {
+    let c = cut;
+    while (c > 1) {
+      c--;
+      if (!isBoundarySafe(view, c)) continue;
+      const recentNow = view.slice(c);
+      const usersNow = recentNow.filter((m) => m.role === "user").length;
+      if (usersNow >= opts.anchorUserMessages) { cut = c; break; }
+    }
+    if (cut > 1) {
+      const finalRecent = view.slice(cut);
+      if (finalRecent.filter((m) => m.role === "user").length < opts.anchorUserMessages) {
+        return null; // cannot satisfy the floor without dropping too much — retry next call
+      }
+    } else {
+      return null;
+    }
+  }
   return cut;
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-mega-compact",
-  "version": "0.6.1",
+  "version": "0.6.2",
   "description": "Layered, local, vector-backed context compressor for pi — supersede/collapse/cluster compaction with deduped inline recall.",
   "type": "module",
   "license": "BSD-2-Clause",

package/src/memoryOps.ts

@@ -12,6 +12,24 @@ import {
   removeMemory,
   type MemoryRecord,
 } from "./store/sqlite.js";
+import { defaultEmbedder } from "./embedder.js";
+import { upsertMemoryEmbedding } from "./store/memoryIndex.js";
+import { execSync } from "node:child_process"; // guardrails-allow PREVENT-PI-004: read-only `git rev-parse` to scope the memory index per-repo
+
+/** Resolve the current repo's git root (mirrors extensions/mega-config.ts but
+ *  kept local so src/ stays pi-agnostic — no extension-layer import). */
+function resolveRepoRootLocal(cwd: string): string | undefined {
+  try {
+    const out = execSync("git rev-parse --show-toplevel", {
+      cwd,
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "ignore"],
+    }).trim();
+    return out || undefined;
+  } catch {
+    return undefined;
+  }
+}
 
 /** Find a memory row whose content exactly matches (case-insensitive). */
 function findByContent(memories: MemoryRecord[], content: string): MemoryRecord | undefined {
@@ -19,6 +37,23 @@ function findByContent(memories: MemoryRecord[], content: string): MemoryRecord
   return memories.find((m) => m.content.trim().toLowerCase() === norm);
 }
 
+/**
+ * Fire-and-forget mirror of a memory write into the cross-repo PGlite index
+ * (S24 optional memory-RAG mirror). Best-effort + non-fatal: never blocks the
+ * SQLite write and degrades to the same-repo scan if the index is disabled or
+ * fails. `repoId` is the resolved git root so the memory is findable from other
+ * repos; falls back to the state dir when outside git.
+ */
+function indexMemoryWrite(stateDir: string, memoryId: number, content: string): void {
+  const repoId = resolveRepoRootLocal(stateDir) ?? stateDir;
+  try {
+    const vec = defaultEmbedder().embed(content);
+    void upsertMemoryEmbedding(repoId, memoryId, content, vec);
+  } catch {
+    /* non-fatal — embedding/index failure must never break the SQLite write */
+  }
+}
+
 /**
  * Apply add/replace/remove ops to the memories table. Replaces are matched by
  * existing content; removes by content. Idempotent: an add that already exists
@@ -32,7 +67,7 @@ export async function applyMemoryOps(ops: MemoryOp[], stateDir: string): Promise
     if (op.op === "add") {
       // Skip if an identical memory already exists.
       if (findByContent(existing, op.memory.content)) continue;
-      addMemory(
+      const id = addMemory(
         {
           kind: op.memory.category,
           content: op.memory.content,
@@ -44,6 +79,8 @@ export async function applyMemoryOps(ops: MemoryOp[], stateDir: string): Promise
         repo,
         stateDir,
       );
+      // S24: mirror into the cross-repo index (fire-and-forget; non-fatal).
+      indexMemoryWrite(stateDir, id, op.memory.content);
     } else if (op.op === "replace") {
       const match = findByContent(existing, op.targetContent);
       if (match) {
@@ -53,9 +90,11 @@ export async function applyMemoryOps(ops: MemoryOp[], stateDir: string): Promise
           category: op.memory.category,
           sourceTurn: op.memory.sourceTurn,
         }, stateDir);
+        // S24: re-mirror under the same memory id (fire-and-forget; non-fatal).
+        indexMemoryWrite(stateDir, match.id, op.memory.content);
       } else {
         // Target missing (e.g. earlier in-conversation contradiction) → add.
-        addMemory(
+        const id = addMemory(
           {
             kind: op.memory.category,
             content: op.memory.content,
@@ -66,6 +105,7 @@ export async function applyMemoryOps(ops: MemoryOp[], stateDir: string): Promise
           repo,
           stateDir,
         );
+        indexMemoryWrite(stateDir, id, op.memory.content);
       }
     } else {
       const match = findByContent(existing, op.content);

package/src/memoryRecall.test.ts

@@ -98,3 +98,61 @@ test("recallMemories: fresher reference beats older at equal similarity", async
 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;
+  }
+});
+
+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;
+  }
+});

package/src/memoryRecall.ts

@@ -81,3 +81,55 @@ export async function recallMemories(
   }
   return top;
 }
+
+/**
+ * Cross-repo memory recall (S24): augments the same-repo `recallMemories` with
+ * HNSW NN over the global PGlite `memory_index` (other repos' memories). Content
+ * is read inline from the index hit (the recall process can't open other repos'
+ * SQLite dirs), so no other-repo db access is required. Returns hits sorted by
+ * descending cosine, above `crossRepoCosine`. De-duped by content against
+ * `sameRepoContent` so we never surface a memory the same-repo scan already has.
+ * Non-fatal: any index failure returns []. Best-effort + PREVENT-PI-004 (local
+ * WASM only).
+ */
+export async function recallMemoriesCrossRepo(
+  query: string,
+  stateDir: string,
+  opts: RecallMemoriesOptions & { crossRepoCosine?: number; limit?: number } = {},
+): Promise<Array<{ memory: MemoryRecord; score: number; repoId: string }>> {
+  const embedder = opts.embedder ?? defaultEmbedder();
+  const queryVec = embedder.embed(query);
+  const { searchMemoriesAsync } = await import("./store/memoryIndex.js");
+  const k = opts.limit ?? 5;
+  const floor = opts.crossRepoCosine ?? 0.3;
+  const hits = await searchMemoriesAsync(queryVec, { k });
+  if (!hits.length) return [];
+  // Mark same-repo content as already-covered so we don't duplicate it.
+  const sameRepo = new Set(
+    listMemories(opts.repo ?? null, 1000, stateDir).map((m) => m.content.trim().toLowerCase()),
+  );
+  const out: Array<{ memory: MemoryRecord; score: number; repoId: string }> = [];
+  for (const h of hits) {
+    if (h.score < floor) continue;
+    if (sameRepo.has(h.content.trim().toLowerCase())) continue;
+    out.push({
+      memory: {
+        id: h.memoryId,
+        repo: h.repoId,
+        kind: "note",
+        content: h.content,
+        tags: [],
+        createdAt: 0,
+        lastRecalledAt: null,
+        category: null,
+        target: null,
+        lastReferenced: null,
+        sourceTurn: null,
+      } as MemoryRecord,
+      score: h.score,
+      repoId: h.repoId,
+    });
+  }
+  out.sort((a, b) => b.score - a.score);
+  return out;
+}

package/src/recall.ts

@@ -159,6 +159,10 @@ export interface MemoryRecallInjectOptions {
   recallMaxTokens?: number;
   /** Cosine threshold; default 0.2. */
   minSimilarity?: number;
+  /** When true, augment same-repo recall with cross-repo PGlite NN (S24). */
+  crossRepo?: boolean;
+  /** Stricter cosine floor for cross-repo memory hits (S24). Default 0.3. */
+  crossRepoCosine?: number;
 }
 
 /** Format one memory hit for the recall block. Category + score for traceability. */
@@ -184,28 +188,49 @@ export async function recallMemoriesAndInline(
 ): Promise<{ empty: boolean; block: string; report: string[] }> {
   const limit = opts.limit ?? 5;
   const maxTokens = opts.recallMaxTokens ?? 0;
-  const { recallMemories } = await import("./memoryRecall.js");
+  const { recallMemories, recallMemoriesCrossRepo } = await import("./memoryRecall.js");
   const hits = await recallMemories(opts.query, opts.stateDir, {
     topK: limit,
     minSimilarity: opts.minSimilarity ?? 0.2,
   });
-  if (hits.length === 0) return { empty: true, block: "", report: [] };
+
+  // S24 cross-repo augmentation: if same-repo recall is thin, pull additional
+  // memories from OTHER repos via the PGlite HNSW index. Non-fatal: a failure
+  // degrades to the same-repo hits only.
+  const crossHits: Array<{ memory: any; score: number; repoId: string }> = [];
+  if (opts.crossRepo && hits.length < limit) {
+    try {
+      const x = await recallMemoriesCrossRepo(opts.query, opts.stateDir, {
+        repo: null,
+        limit: limit - hits.length,
+        crossRepoCosine: opts.crossRepoCosine ?? 0.3,
+      });
+      for (const h of x) crossHits.push(h);
+    } catch {
+      /* non-fatal — cross-repo failure → same-repo only */
+    }
+  }
+  if (hits.length === 0 && crossHits.length === 0) return { empty: true, block: "", report: [] };
 
   // Same incremental token cap pattern as checkpoint recall.
   const parts: string[] = [];
   const report: string[] = [];
   let blockTokens = 0;
-  for (const h of hits) {
-    const part = formatMemoryRecallBlock([
-      { content: h.memory.content, category: h.memory.category, score: h.score },
-    ]);
+  const pushHit = (content: string, category: string | null, score: number, label: string) => {
+    const part = formatMemoryRecallBlock([{ content, category, score }]);
     const partTokens = estimateBlockTokens(part);
-    if (maxTokens > 0 && blockTokens + partTokens > maxTokens) break;
+    if (maxTokens > 0 && blockTokens + partTokens > maxTokens) return false;
     parts.push(part);
-    report.push(
-      `  • memory#${h.memory.id} (${(h.score * 100).toFixed(0)}%): ${h.memory.content.slice(0, 60).replace(/\n/g, " ")}…`,
-    );
+    report.push(`  • ${label} (${(score * 100).toFixed(0)}%): ${content.slice(0, 60).replace(/\n/g, " ")}…`);
     blockTokens += partTokens;
+    return true;
+  };
+  for (const h of hits) {
+    if (!pushHit(h.memory.content, h.memory.category, h.score, `memory#${h.memory.id}`)) break;
+  }
+  for (const h of crossHits) {
+    const repoLabel = h.repoId.split(/[\\/]/).filter(Boolean).pop() ?? h.repoId;
+    if (!pushHit(h.memory.content, h.memory.category, h.score, `memory#${h.memory.id} (from ${repoLabel})`)) break;
   }
   return { empty: parts.length === 0, block: parts.join("\n"), report };
 }

package/src/store/memoryIndex.test.ts

@@ -0,0 +1,61 @@
+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 { defaultEmbedder } from "../embedder.js";
+import {
+  upsertMemoryEmbedding,
+  searchMemoriesAsync,
+  initMemoryIndex,
+  closeMemoryIndex,
+  isMemoryIndexDisabled,
+} from "./memoryIndex.js";
+
+const baseTmp = mkdtempSync(join(tmpdir(), "mc-memidx-"));
+
+test("memoryIndex: disabled when MEGACOMPACT_PGLITE_DISABLED", async () => {
+  process.env.MEGACOMPACT_PGLITE_DISABLED = "true";
+  try {
+    assert.equal(isMemoryIndexDisabled(), true, "kill-switch honored");
+    const hits = await searchMemoriesAsync(defaultEmbedder().embed("anything"), { k: 3 });
+    assert.deepEqual(hits, [], "search returns [] when disabled");
+  } finally {
+    delete process.env.MEGACOMPACT_PGLITE_DISABLED;
+  }
+});
+
+test("memoryIndex: cross-repo upsert + NN search returns the right repo's memory", async () => {
+  // Isolate the global PGlite dir so concurrent test runs don't collide.
+  process.env.MEGACOMPACT_INDEX_DIR = join(baseTmp, "index");
+  const repoA = "/tmp/repo-a";
+  const repoB = "/tmp/repo-b";
+  try {
+    await initMemoryIndex();
+    // Two memories in different repos, with clearly distinct content so their
+    // trigram embeddings separate.
+    const vecA = defaultEmbedder().embed("We standardized on node:sqlite for the store backend");
+    const vecB = defaultEmbedder().embed("The deployment target is a raspberry pi in the closet");
+    await upsertMemoryEmbedding(repoA, 1, "We standardized on node:sqlite for the store backend", vecA);
+    await upsertMemoryEmbedding(repoB, 7, "The deployment target is a raspberry pi in the closet", vecB);
+
+    // Query close to A's content → top hit should be A's memory, not B's.
+    const q = defaultEmbedder().embed("standardized node:sqlite store backend choice");
+    const hits = await searchMemoriesAsync(q, { k: 3 });
+    assert.ok(hits.length >= 1, "at least one hit");
+    assert.equal(hits[0].repoId, repoA, "nearest neighbor is repo A");
+    assert.equal(hits[0].memoryId, 1, "correct memory id");
+    assert.ok(hits[0].score > 0.5, "high cosine for the matching memory");
+
+    // Scope to repoB only → A must not appear.
+    const scoped = await searchMemoriesAsync(q, { k: 3, repoId: repoB });
+    assert.ok(scoped.every((h) => h.repoId === repoB), "scoped search stays within repoB");
+  } finally {
+    await closeMemoryIndex();
+    delete process.env.MEGACOMPACT_INDEX_DIR;
+  }
+});
+
+test("memoryIndex: cleanup", () => {
+  rmSync(baseTmp, { recursive: true, force: true });
+});