pi-mega-compact 0.4.28 → 0.5.0

package/README.md

@@ -151,11 +151,36 @@ building.
 > npm install && npm run build
 > ```
 
+> **No tarballs — ever.** Distribution and updates go through `npm publish` +
+> `pi update --extensions` **only**. Never build or rely on a `.tgz` (`npm pack`):
+> a tarball bypasses pi's package manager and does not propagate to other devices.
+> To validate a real install, bump the version, `npm publish`, then
+> `pi update --extensions` on the device. (`.gitignore` rejects `*.tgz` so one can't
+> be committed by accident.)
+
+### Storage backend (v0.5.0+)
+
+pi-mega-compact uses a dual local backend — **zero network, no native build step**:
+
+- **`node:sqlite`** (`DatabaseSync`, Node ≥22.13 built-in) — the synchronous source of truth for checkpoints, session state, and the dedup index. No dependency, no install script, survives pi's `install-scripts` block.
+- **PGlite + `@electric-sql/pglite-pgvector`** (WASM Postgres + HNSW `vector_cosine_ops`) — an optional, best-effort async vector index for **cross-repo recall** at `~/.pi/mega-compact-vector`. The sync store stays authoritative; the index degrades to the sync per-session scan on any failure.
+
+Kill-switch: `MEGACOMPACT_PGLITE_DISABLED=1` fully disables the PGlite index (falls back to sync scan). Requires Node ≥22.13 (`engines.node`).
+
+### Cross-repo recall (v0.5.0+)
+
+On resume, recall augments from other repos' checkpoints when this repo's store is thin; `/mega-recall --cross-repo` searches all repos via the HNSW index. Cross-repo hits use a stricter cosine floor (`MEGACOMPACT_CROSSREPO_COSINE`, default 0.90) and are labeled with their source repo. A machine-wide injected-set (`~/.mega-compact-index/index.sqlite`) prevents re-injecting the same foreign checkpoint.
+
+### Memory (v0.5.0+)
+
+pi-mega-compact auto-reviews the conversation every 10 turns and writes durable `decision`/`fact`/`preference` memories to SQLite (local, hallucination-guarded). Relevant memories are injected as RAG context on recall (capped, deduped). Manual: `/mega-memory save|list|forget`.
+
 ### Verify
 
 ```bash
-npm test          # all unit/integration tests pass (278 as of v0.4.0)
+npm test          # all unit/integration tests pass (346 as of v0.5.0)
 npm run lint      # tsc --noEmit + guardrails scan clean
+python3 scripts/regression_check.py --all   # spec/plan regression gate
 ```
 
 ### Uninstall
@@ -187,7 +212,8 @@ The commands (slash commands inside pi):
 | `/mega-compact [summary...]` | Manually compact the current session. A summary arg is used verbatim; otherwise the COLLAPSE heuristics build one. Persists a `chkpt_xxx`. |
 | `/mega-compact off` | Disable auto-compaction for this session. |
 | `/mega-status` | Show config + current context usage + store stats (checkpoint count, dedup rate, tokens saved). |
-| `/mega-recall [query]` | Semantic-search the local store, dedupe against the current window, and inline the top-K relevant checkpoints. No query → uses your latest message. |
+| `/mega-recall [query]` | Semantic-search the local store, dedupe against the current window, and inline the top-K relevant checkpoints. No query → uses your latest message. `--cross-repo` searches all repos. |
+| `/mega-memory save <text>` / `save <category> <text>` / `list` / `search <query>` / `forget <text>` / `consolidate` | Manage durable memories (decisions, facts, preferences) written by auto-review and recalled as RAG context. Also `/m` shortform. |
 | `/mega-tier [name]` | Set the compaction tier (`low` / `medium` / `high` / `ultra` / `mega`). Shows current tier with no arg. |
 | `/mega-dashboard` | Start the **localhost-only** live dashboard and open it in a browser (token gauge, store stats, live event stream). |
 | `/mega-dashboard-status` | Report dashboard server status. |
@@ -259,6 +285,25 @@ See `docs/DEDUP_RUNBOOK.md` for incident response (SEV tiers, first-15-min
 checklist, MARK_ONLY degrade) and `docs/RETENTION_POLICY.md` for TTL / soft-delete
 / VACUUM.
 
+#### Continuity + memory knobs (v0.5.0)
+
+| Variable | Default | Meaning |
+|---|---|---|
+| `MEGACOMPACT_LEGACY_DURABLE_TRIM` | `false` | Restore the v0.4.28 auto-trigger (`ctx.compact()` stops the agent). One-release rollback; default uses live context-event trim + pi native auto-compaction (compact-and-continue). |
+| `MEGACOMPACT_CROSSREPO_ENABLED` | `true` | Cross-repo recall on resume + `/mega-recall --cross-repo` (HNSW index over every repo). |
+| `MEGACOMPACT_CROSSREPO_COSINE` | `0.90` | Stricter cosine floor for cross-repo hits (vs `0.85` same-repo). |
+| `MEGACOMPACT_MEMORY_AUTO_REVIEW` | `true` | Auto-review the conversation every `MEGACOMPACT_MEMORY_REVIEW_INTERVAL` turns → durable memories. |
+| `MEGACOMPACT_MEMORY_REVIEW_INTERVAL` | `10` | Turns between auto-review cycles. |
+| `MEGACOMPACT_PGLITE_DISABLED` | `1` | Kill-switch for the PGlite/HNSW cross-repo index (falls back to sync per-session scan). |
+
+#### Dashboard (v0.5.0)
+
+The localhost-only dashboard adds a **Summary** + **All-repos** view over the
+machine-wide `repo_registry`, plus a **cross-repo drift** report (`GET /api/drift`)
+flagging stale repos (>30d idle), compaction lag (an active repo >24h behind the
+most-recently-active repo's last compaction), and recent model churn (within 7d).
+All read-only — the report never writes the index.
+
 ---
 
 ## Reporting for testers (what to capture)

package/dist/extensions/dashboard-server.js

@@ -15,6 +15,7 @@ import { existsSync, mkdirSync, readFileSync, unlinkSync, watch, writeFileSync,
 import { homedir } from "node:os";
 import { join, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
+import { createRequire } from "node:module";
 import { DatabaseSync } from "node:sqlite";
 // ---------------------------------------------------------------------------
 // Local runtime log
@@ -693,6 +694,11 @@ export async function launchDashboardServer(stateDir) {
         }
     }
     catch { /* non-fatal */ }
+    // Lazy-loaded via require so the dashboard stays cheap to boot and we don't
+    // need a top-level await in the handler.
+    const driftReq = createRequire(import.meta.url);
+    const detectCrossRepoDrift = (idxDir) => driftReq("../src/driftDetection.js")
+        .detectCrossRepoDrift(idxDir);
     const portFile = join(stateDir, "port.pid");
     const snapshotPath = join(stateDir, "dashboard.json");
     const eventsPath = join(stateDir, "events.log");
@@ -772,6 +778,51 @@ export async function launchDashboardServer(stateDir) {
             res.end(JSON.stringify(readIndex() ?? { updatedAt: null, summary: null, repos: [] }));
             return;
         }
+        // /api/repos — registry list. Optional `?active=24h` filters to repos
+        // seen within the last N hours (default: all). The dashboard uses this to
+        // drive its "active vs archived" badge without refetching /api/index.
+        if (req.url?.startsWith("/api/repos")) {
+            const url = new URL(req.url, "http://x");
+            const activeParam = url.searchParams.get("active");
+            const idx = readIndex() ?? { updatedAt: null, summary: null, repos: [] };
+            let repos = (idx.repos ?? []);
+            if (activeParam) {
+                const m = /^(\d+)h$/.exec(activeParam);
+                if (m) {
+                    const cutoffSec = Math.floor(Date.now() / 1000) - Number(m[1]) * 3600;
+                    repos = repos.filter((r) => (r.lastSeen ?? 0) >= cutoffSec);
+                }
+            }
+            res.writeHead(200, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ updatedAt: idx.updatedAt, repos, count: repos.length }));
+            return;
+        }
+        // /api/summary — header tiles without the full repo list (keeps payload
+        // small for embed scenarios). activeRepos mirrors the /api/repos?active=24h
+        // count so the dashboard can render the active badge alongside totals.
+        if (req.url?.startsWith("/api/summary")) {
+            const idx = readIndex() ?? { updatedAt: null, summary: null, repos: [] };
+            const repos = (idx.repos ?? []);
+            const cutoffSec = Math.floor(Date.now() / 1000) - 24 * 3600;
+            const activeRepos = repos.filter((r) => (r.lastSeen ?? 0) >= cutoffSec).length;
+            res.writeHead(200, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({
+                updatedAt: idx.updatedAt,
+                summary: idx.summary,
+                activeRepos,
+                totalRepos: repos.length,
+            }));
+            return;
+        }
+        // /api/drift — R4: cross-repo drift report over repo_registry. Flags stale
+        // repos (>30d idle), compaction lag (active but >24h since last
+        // compaction), and recent model churn. Read-only.
+        if (req.url?.startsWith("/api/drift")) {
+            const report = detectCrossRepoDrift(getIndexDir());
+            res.writeHead(200, { "Content-Type": "application/json" });
+            res.end(JSON.stringify(report));
+            return;
+        }
         if (req.url === "/api/events") {
             res.writeHead(200, {
                 "Content-Type": "text/event-stream",
@@ -838,8 +889,13 @@ export async function launchDashboardServer(stateDir) {
         res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
         res.end(dashboardHtml(tier));
     });
-    const TARGET_PORT = 9320;
-    const PORT_RANGE = 10; // 9320–9329
+    // Bind base + range are env-configurable so tests can use a private,
+    // non-colliding range (parallel runs / leftover servers from killed runs
+    // would otherwise EADDRINUSE on the machine-global 9320 range). Default
+    // MEGACOMPACT_DASHBOARD_PORT=9320 (10-port range 9320–9329) preserves the
+    // production behavior.
+    const TARGET_PORT = Number(process.env.MEGACOMPACT_DASHBOARD_PORT ?? "9320");
+    const PORT_RANGE = 10; // TARGET_PORT..TARGET_PORT+9
     return new Promise((resolve, reject) => {
         function tryPort(port) {
             server.once("error", (err) => {

package/dist/extensions/dashboard-server.test.js

@@ -111,6 +111,91 @@ describe("port.pid file", () => {
     });
 });
 // ---------------------------------------------------------------------------
+// Multi-repo dashboard (S19 / Phase 5b) — launch the real server subprocess,
+// seed the machine-wide repo_registry, and assert /api/index returns every repo
+// plus the aggregate summary the Summary + All-repos tabs render.
+// ---------------------------------------------------------------------------
+describe("multi-repo /api/index (S19)", () => {
+    test("lists all repos from the global index with an aggregate summary", async () => {
+        const dir = mkdtempSync(join(tmpdir(), "dash-index-"));
+        const indexDir = mkdtempSync(join(tmpdir(), "index-"));
+        // The server reads MEGACOMPACT_INDEX_DIR for the machine-wide registry.
+        process.env.MEGACOMPACT_INDEX_DIR = indexDir;
+        process.env.MEGACOMPACT_DASHBOARD_PORT = "19321"; // private base, non-colliding
+        const { upsertRepoRegistry } = await import("../src/store/sqlite.js");
+        upsertRepoRegistry({ repoRoot: "/home/u/repoA", displayName: "repoA", stateDir: dir, checkpointCount: 3, tokensSaved: 1000, compressedOriginalBytes: 0 }, indexDir);
+        upsertRepoRegistry({ repoRoot: "/home/u/repoB", displayName: "repoB", stateDir: dir, checkpointCount: 5, tokensSaved: 2000, compressedOriginalBytes: 0 }, indexDir);
+        const child = spawn(process.execPath, [SERVER_ENTRY, dir], { stdio: "ignore" });
+        try {
+            await waitFor(async () => {
+                try {
+                    const raw = JSON.parse(readFileSync(join(dir, "port.pid"), "utf-8"));
+                    const res = await fetch(`http://localhost:${raw.port}/api/version`);
+                    return res.ok;
+                }
+                catch {
+                    return false;
+                }
+            });
+            const raw = JSON.parse(readFileSync(join(dir, "port.pid"), "utf-8"));
+            const idx = (await fetch(`http://localhost:${raw.port}/api/index`).then((r) => r.json()));
+            const names = idx.repos.map((r) => r.displayName).sort();
+            assert.deepEqual(names, ["repoA", "repoB"], "both repos from the global index");
+            assert.equal(idx.summary.totalRepos, 2, "repo count");
+            assert.equal(idx.summary.totalCheckpoints, 8, "3 + 5 checkpoints");
+            assert.equal(idx.summary.totalTokensSaved, 3000, "1000 + 2000 tokens saved");
+        }
+        finally {
+            child.kill("SIGTERM");
+            delete process.env.MEGACOMPACT_INDEX_DIR;
+            delete process.env.MEGACOMPACT_DASHBOARD_PORT;
+            rmSync(dir, { recursive: true, force: true });
+            rmSync(indexDir, { recursive: true, force: true });
+        }
+    });
+    test("/api/repos filters by ?active=Nh and /api/summary counts activeRepos", async () => {
+        const dir = mkdtempSync(join(tmpdir(), "dash-active-"));
+        const indexDir = mkdtempSync(join(tmpdir(), "index-active-"));
+        process.env.MEGACOMPACT_INDEX_DIR = indexDir;
+        process.env.MEGACOMPACT_DASHBOARD_PORT = "19322";
+        const { upsertRepoRegistry } = await import("../src/store/sqlite.js");
+        // Fresh repo, last_seen = now
+        upsertRepoRegistry({ repoRoot: "/home/u/fresh", displayName: "fresh", stateDir: dir, checkpointCount: 1, tokensSaved: 100, compressedOriginalBytes: 0, lastSeen: Math.floor(Date.now() / 1000) }, indexDir);
+        // Stale repo, last_seen = 90 days ago — must be filtered out by ?active=24h.
+        const longAgo = Math.floor(Date.now() / 1000) - 90 * 86_400;
+        upsertRepoRegistry({ repoRoot: "/home/u/stale", displayName: "stale", stateDir: dir, checkpointCount: 2, tokensSaved: 200, compressedOriginalBytes: 0, lastSeen: longAgo }, indexDir);
+        const child = spawn(process.execPath, [SERVER_ENTRY, dir], { stdio: "ignore" });
+        try {
+            await waitFor(async () => {
+                try {
+                    const raw = JSON.parse(readFileSync(join(dir, "port.pid"), "utf-8"));
+                    const res = await fetch(`http://localhost:${raw.port}/api/version`);
+                    return res.ok;
+                }
+                catch {
+                    return false;
+                }
+            });
+            const raw = JSON.parse(readFileSync(join(dir, "port.pid"), "utf-8"));
+            const allRepos = (await fetch(`http://localhost:${raw.port}/api/repos`).then((r) => r.json()));
+            assert.equal(allRepos.count, 2, "unfiltered list has both repos");
+            const activeRepos = (await fetch(`http://localhost:${raw.port}/api/repos?active=24h`).then((r) => r.json()));
+            assert.equal(activeRepos.count, 1, "active=24h drops the 90-day-old repo");
+            assert.equal(activeRepos.repos[0].displayName, "fresh");
+            const summary = (await fetch(`http://localhost:${raw.port}/api/summary`).then((r) => r.json()));
+            assert.equal(summary.activeRepos, 1, "summary counts only fresh repo as active");
+            assert.equal(summary.totalRepos, 2, "summary counts both repos total");
+        }
+        finally {
+            child.kill("SIGTERM");
+            delete process.env.MEGACOMPACT_INDEX_DIR;
+            delete process.env.MEGACOMPACT_DASHBOARD_PORT;
+            rmSync(dir, { recursive: true, force: true });
+            rmSync(indexDir, { recursive: true, force: true });
+        }
+    });
+});
+// ---------------------------------------------------------------------------
 // Lifecycle integration — launch the compiled server as a real subprocess
 // (the same way the /dashboard command spawns it) and assert the two failure
 // modes that historically produced a silent "failed to start":
@@ -120,6 +205,11 @@ describe("port.pid file", () => {
 //      silent under stdio:"ignore".
 // ---------------------------------------------------------------------------
 const SERVER_ENTRY = new URL("./dashboard-server.js", import.meta.url).pathname;
+// Tests run in parallel across files and a killed run can leave a server bound
+// to 9320. Use a private, non-colliding base so this file never races the
+// mega-compact.test.js dashboard tests (which scan a DIFFERENT base) and never
+// collides with a leftover production server on 9320.
+process.env.MEGACOMPACT_DASHBOARD_PORT = "19320";
 function waitFor(cond, timeoutMs = 6000) {
     const start = Date.now();
     return new Promise((resolve, reject) => {
@@ -136,8 +226,10 @@ function waitFor(cond, timeoutMs = 6000) {
 describe("server lifecycle", () => {
     test("drops a stale port.pid and binds a fresh port", async () => {
         const dir = mkdtempSync(join(tmpdir(), "dash-stale-"));
-        // A marker claiming a port where nothing is listening.
-        writeFileSync(join(dir, "port.pid"), JSON.stringify({ port: 9325, pid: 999999 }));
+        // A marker claiming a port where nothing is listening — use the test's own
+        // private base + 5 so the dead port is inside the server's scan range.
+        const deadPort = 19325;
+        writeFileSync(join(dir, "port.pid"), JSON.stringify({ port: deadPort, pid: 999999 }));
         const child = spawn(process.execPath, [SERVER_ENTRY, dir], { stdio: "ignore" });
         try {
             // Wait for the server to actually be live (not just any port.pid — the
@@ -154,7 +246,7 @@ describe("server lifecycle", () => {
             });
             const raw = JSON.parse(readFileSync(join(dir, "port.pid"), "utf-8"));
             assert.equal(typeof raw.port, "number");
-            assert.notEqual(raw.port, 9325, "should not reuse the dead port from the stale marker");
+            assert.notEqual(raw.port, deadPort, "should not reuse the dead port from the stale marker");
             // And a real server must answer on it.
             const res = await fetch(`http://localhost:${raw.port}/api/version`);
             assert.equal(res.ok, true);

package/dist/extensions/mega-commands.js

@@ -7,11 +7,11 @@
  */
 import { sessionEntryToContextMessages } from "@earendil-works/pi-coding-agent";
 import { normalizeSessionId } from "../src/store.js";
-import { listCheckpoints, latestModelSnapshot } from "../src/store/sqlite.js";
+import { listCheckpoints, latestModelSnapshot, countInjectedGlobal, listRepoRegistry } from "../src/store/sqlite.js";
 import { decompressSmart } from "../src/store/compression.js";
 import { loadMetrics, fpRate, p95 } from "../src/monitoring.js";
 import { C, recentUserQuery } from "./mega-runtime.js";
-import { runCompact, doRecall } from "./mega-pipeline.js";
+import { runCompact, doRecall, doRecallAsync } from "./mega-pipeline.js";
 import { setTier, COMPACT_TIERS } from "./mega-config.js";
 /** Resolve a checkpoint by id (or "recent"/"last") from this session's store. */
 export function findCheckpoint(runtime, sid, ref) {
@@ -42,16 +42,21 @@ export function registerCommands(pi, runtime, config) {
         },
     });
     pi.registerCommand("mega-recall", {
-        description: "Recall relevant compacted context from the vector store and inline it.",
+        description: "Recall relevant compacted context from the vector store and inline it. Use --cross-repo to search all repos.",
         handler: async (args, ctx) => {
-            const query = args.trim() || recentUserQuery(ctx);
+            // S17: --cross-repo (or --cross repo) runs the async path over every repo's
+            // PGlite HNSW index (stricter cosine floor + source labels).
+            const crossRepo = /\-\-cross[\- ]repo\b/.test(args);
+            const query = args.replace(/--cross[\- ]repo\b/, "").trim() || recentUserQuery(ctx);
             if (!query) {
                 ctx.ui.notify("[mega-compact] /mega-recall needs a query or a prior user message.");
                 return;
             }
-            const r = doRecall(runtime, config, ctx, query, "command");
+            const r = crossRepo
+                ? await doRecallAsync(runtime, config, ctx, query, "command", { crossRepo: true })
+                : doRecall(runtime, config, ctx, query, "command");
             if (r.empty) {
-                runtime.logger.info("recall-empty", { query });
+                runtime.logger.info("recall-empty", { query, crossRepo });
                 ctx.ui.notify(`[mega-compact] recall found nothing new for "${query}".`);
                 return;
             }
@@ -59,9 +64,9 @@ export function registerCommands(pi, runtime, config) {
             // injection). Report what was selected now for immediate feedback.
             runtime.pendingRecallBlock = r.block;
             const list = r.report.map((l) => l).join("\n");
-            runtime.logger.info("recall", { query, injected: r.toInject.map((h) => h.checkpoint.checkpointId) });
-            runtime.setStatus(ctx, `mega-compact: recalled ${r.toInject.length} chkpt`);
-            ctx.ui.notify(`[mega-compact] recall staged ${r.toInject.length} checkpoint(s) for "${query}":\n${list}\n` +
+            runtime.logger.info("recall", { query, crossRepo, injected: r.toInject.map((h) => h.checkpoint.checkpointId) });
+            runtime.setStatus(ctx, `mega-compact: recalled ${r.toInject.length} chkpt${crossRepo ? " (cross-repo)" : ""}`);
+            ctx.ui.notify(`[mega-compact] recall staged ${r.toInject.length} checkpoint(s) for "${query}"${crossRepo ? " (cross-repo)" : ""}:\n${list}\n` +
                 `(injected at the next turn via system prompt)`);
         },
     });
@@ -102,6 +107,16 @@ export function registerCommands(pi, runtime, config) {
             const p95L2 = p95(m.latency.L2 ?? []);
             const relPct = (st.dedupHitRate * 100).toFixed(0);
             const qualityStr = `recall ${relPct}% relevant · FP ${(fp * 100).toFixed(1)}% · L2 p95 ${p95L2.toFixed(0)}ms`;
+            // S18: cross-repo stats from the machine-wide index (best-effort; the
+            // index dir may be unset → 0/empty, never throws).
+            let crossRepoInjections = 0;
+            let repoCount = 0;
+            try {
+                crossRepoInjections = countInjectedGlobal(process.env.MEGACOMPACT_INDEX_DIR);
+                repoCount = listRepoRegistry(process.env.MEGACOMPACT_INDEX_DIR).length;
+            }
+            catch { /* non-fatal */ }
+            const crossRepoStr = `${crossRepoInjections} cross-repo injections recorded · ${repoCount} repos indexed`;
             ctx.ui.notify(`[mega-compact] pct=${pct} tokens=${tokens} tier=${config.tier} fastGate=${config.fastGatePct}% ` +
                 `threshold=${config.thresholdTokens} auto=${config.auto} autoInline=${config.autoInline}\n` +
                 `[mega-compact] store: ${st.checkpointCount} chkpt · ` +
@@ -116,6 +131,7 @@ export function registerCommands(pi, runtime, config) {
                 `[mega-compact] 💰 ${costStr}\n` +
                 `[mega-compact] 🤖 model: ${modelStr}\n` +
                 `[mega-compact] 🎯 ${qualityStr}\n` +
+                `[mega-compact] 🌐 ${crossRepoStr}\n` +
                 `[mega-compact] stateDir=${runtime.currentStateDir}`);
         },
     });

package/dist/extensions/mega-compact.test.js

@@ -17,6 +17,7 @@ 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";
 const require = createRequire(import.meta.url);
 const baseTmp = mkdtempSync(join(tmpdir(), "mc-ext-"));
 // Isolate the machine-wide repo index so test runs (which call bindRepo ->
@@ -163,14 +164,18 @@ function harness(opts = {}) {
         session,
     };
 }
-test("auto-trigger: past threshold persists a chkpt and starts a durable trim", async () => {
+test("auto-trigger (legacy): past threshold persists a chkpt and starts a durable trim via ctx.compact", async () => {
     const h = harness();
     const messages = h.session;
     // The mock session is tiny (~100 tokens). piCompactWouldNoop() would skip
     // ctx.compact() for a transcript under pi's keepRecentTokens budget — so
     // lower the floor to 0 to simulate a transcript large enough that pi WOULD
     // compact (the positive path this test exercises).
+    // S16: this is the LEGACY path — the default no longer calls ctx.compact()
+    // (it returns a live-trimmed view instead). Set the legacy flag to exercise
+    // the v0.4.28 ctx.compact durable-trim flow this test asserts.
     process.env.MEGACOMPACT_DURABLE_TRIM_FLOOR = "0";
+    process.env.MEGACOMPACT_LEGACY_DURABLE_TRIM = "true";
     try {
         const ctx = h.ctx({ getContextUsage: () => ({ tokens: 200000, contextWindow: 200000, percent: 100 }) });
         const res = await h.fire("context", { type: "context", messages }, ctx);
@@ -178,34 +183,113 @@ test("auto-trigger: past threshold persists a chkpt and starts a durable trim",
         const { listCheckpoints } = await import("../src/store/sqlite.js");
         assert.ok(listCheckpoints("sess_ext_001", h.stateDir).length > 0, "checkpoint persisted to local vector db");
         assert.equal(h.appended.some((a) => a.t === "mega-compact-marker"), true, "marker sentinel appended");
-        // The context handler no longer drops messages itself (that was ephemeral —
-        // the read-path token-growth bug). It triggers pi's compaction flow, which
-        // calls our session_before_compact handler to supply the DURABLE trim.
-        assert.equal(res, undefined, "context handler returns nothing (no local drop)");
-        assert.equal(h.compactCalls.length, 1, "ctx.compact() called to start durable trim");
+        // The legacy context handler triggers pi's compaction flow (ctx.compact),
+        // which calls our session_before_compact handler to supply the DURABLE trim.
+        assert.equal(res, undefined, "legacy context handler returns nothing (no local drop)");
+        assert.equal(h.compactCalls.length, 1, "ctx.compact() called to start durable trim (legacy path)");
         // The durable trim was supplied (summary + firstKeptEntryId from pi's prep).
         assert.ok(h.compactCalls[0] !== undefined, "compaction flow executed");
     }
     finally {
         delete process.env.MEGACOMPACT_DURABLE_TRIM_FLOOR;
+        delete process.env.MEGACOMPACT_LEGACY_DURABLE_TRIM;
     }
 });
-test("auto-trigger: skips ctx.compact() when pi would no-op (session too small)", async () => {
+test("auto-trigger: skips ctx.compact() when pi would no-op (session too small, legacy path)", async () => {
     const h = harness();
     const messages = h.session;
     // Default floor (20000): the tiny mock transcript is below pi's
     // keepRecentTokens budget, so piCompactWouldNoop() must skip ctx.compact()
     // rather than surface pi's "Nothing to compact (session too small)" throw.
+    // S16: exercised under the legacy flag (the default path never calls ctx.compact).
     delete process.env.MEGACOMPACT_DURABLE_TRIM_FLOOR;
+    process.env.MEGACOMPACT_LEGACY_DURABLE_TRIM = "true";
+    try {
+        const ctx = h.ctx({ getContextUsage: () => ({ tokens: 200000, contextWindow: 200000, percent: 100 }) });
+        const res = await h.fire("context", { type: "context", messages }, ctx);
+        assert.equal(res, undefined, "legacy context handler returns nothing (no local drop)");
+        assert.equal(h.compactCalls.length, 0, "ctx.compact() NOT called — pi would no-op");
+        // Our recall checkpoint still persisted (Path A) — the durable trim is the
+        // only thing skipped; recall is independent of it.
+        const { listCheckpoints } = await import("../src/store/sqlite.js");
+        assert.ok(listCheckpoints("sess_ext_001", h.stateDir).length > 0, "recall checkpoint still persisted");
+        assert.equal(h.appended.some((a) => a.t === "mega-compact-marker"), true, "marker sentinel still appended");
+    }
+    finally {
+        delete process.env.MEGACOMPACT_LEGACY_DURABLE_TRIM;
+    }
+});
+test("auto-trigger (S16): trims the live view and does NOT call ctx.compact()", async () => {
+    const h = harness();
+    const messages = h.session;
+    // S16 default: live context-event trim. No legacy flag. Lower the anchor floor
+    // so the trimmed recent window (4 messages, 2 user) clears the anchor check
+    // and the live trim actually fires — mirrors how the legacy test lowers the
+    // durable floor to exercise its positive path.
+    delete process.env.MEGACOMPACT_LEGACY_DURABLE_TRIM;
+    delete process.env.MEGACOMPACT_DURABLE_TRIM_FLOOR;
+    process.env.MEGACOMPACT_ANCHOR_USER_MESSAGES = "1";
+    try {
+        const ctx = h.ctx({ getContextUsage: () => ({ tokens: 200000, contextWindow: 200000, percent: 100 }) });
+        const res = await h.fire("context", { type: "context", messages }, ctx);
+        // S16: context handler returns a TRIMMED messages array (live trim), not undefined.
+        assert.ok(res && typeof res === "object", "context handler returns a result object (live trim)");
+        assert.ok(Array.isArray(res.messages), "result has a trimmed messages array");
+        // The trimmed view starts with the compacted summary (user-role) + is shorter.
+        assert.ok(res.messages.length < messages.length, "trimmed view is shorter than the full session");
+        // S16: ctx.compact() is NEVER called (it would stop the agent).
+        assert.equal(h.compactCalls.length, 0, "ctx.compact() NOT called — compact-and-continue");
+        // The recall checkpoint is still persisted (the durable value).
+        const { listCheckpoints } = await import("../src/store/sqlite.js");
+        assert.ok(listCheckpoints("sess_ext_001", h.stateDir).length > 0, "recall checkpoint persisted under live trim");
+    }
+    finally {
+        delete process.env.MEGACOMPACT_ANCHOR_USER_MESSAGES;
+    }
+});
+test("auto-trigger (S16): does not trim when below the anchor floor (returns undefined, no ctx.compact)", async () => {
+    const h = harness();
+    // A session so short that buildLiveTrimmedView's anchor floor can't hold — the
+    // live trim skips this call (returns undefined, the next context event retries).
+    delete process.env.MEGACOMPACT_LEGACY_DURABLE_TRIM;
+    delete process.env.MEGACOMPACT_DURABLE_TRIM_FLOOR;
+    const shortSession = [h.session[0], h.session[1]]; // one user + one assistant
     const ctx = h.ctx({ getContextUsage: () => ({ tokens: 200000, contextWindow: 200000, percent: 100 }) });
-    const res = await h.fire("context", { type: "context", messages }, ctx);
-    assert.equal(res, undefined, "context handler returns nothing (no local drop)");
-    assert.equal(h.compactCalls.length, 0, "ctx.compact() NOT called — pi would no-op");
-    // Our recall checkpoint still persisted (Path A) — the durable trim is the
-    // only thing skipped; recall is independent of it.
-    const { listCheckpoints } = await import("../src/store/sqlite.js");
-    assert.ok(listCheckpoints("sess_ext_001", h.stateDir).length > 0, "recall checkpoint still persisted");
-    assert.equal(h.appended.some((a) => a.t === "mega-compact-marker"), true, "marker sentinel still appended");
+    const res = await h.fire("context", { type: "context", messages: shortSession }, ctx);
+    // Either it skipped (undefined) or trimmed safely — but it must never call ctx.compact.
+    assert.equal(h.compactCalls.length, 0, "ctx.compact() NOT called under live trim (short session)");
+    if (res === undefined) {
+        // skipped path is fine
+        assert.ok(true, "below anchor floor → no trim this call (retries next event)");
+    }
+});
+test("auto-trigger (S16): sendUserMessage resume nudge fires only when idle + queued + not already nudged", async () => {
+    const h = harness();
+    // No queued messages → the nudge must NOT fire (the guard prevents busy-loops).
+    // We assert the extension did not throw and did not push a spurious resume.
+    const ctx = h.ctx({ isIdle: () => true, hasPendingMessages: () => false });
+    await h.fire("agent_end", { type: "agent_end", messages: [] }, ctx);
+    // No throw + no spurious nudge side-effect is the contract; appended stays
+    // free of any auto "continue" marker when there is no queued work.
+    assert.equal(h.appended.some((a) => a.t && /continue/i.test(String(a.d ?? ""))), false, "no spurious continue when no queued work");
+});
+test("auto-trigger (S16): durable trim still happens via pi native auto-compaction (session_before_compact)", async () => {
+    const h = harness();
+    // pi's native auto-compaction fires at agent-end with reason "threshold" (the
+    // CONTINUING path). Our session_before_compact handler must still supply the
+    // durable trim summary — independent of the live context-event trim.
+    const prep = {
+        firstKeptEntryId: "e2",
+        messagesToSummarize: h.session.slice(0, 4),
+        tokensBefore: 500,
+    };
+    const res = await h.fire("session_before_compact", {
+        type: "session_before_compact", reason: "threshold", willRetry: false,
+        signal: undefined, preparation: prep,
+    }, h.ctx());
+    assert.ok(res?.compaction, "we supply a durable compaction result to pi's native path");
+    assert.ok(res.compaction.firstKeptEntryId === "e2", "reuses pi's boundary (PREVENT-PI-002)");
+    assert.ok(res.compaction.summary.length > 0, "summary is non-empty");
 });
 test("session_before_compact supplies our durable trim (not pi's summary)", async () => {
     const h = harness();
@@ -323,10 +407,18 @@ test("explicit MEGACOMPACT_THRESHOLD_TOKENS overrides the tier", async () => {
 });
 // ---- /dashboard commands ----------------------------------------------------
 test("/dashboard-status reports no server when pid file missing", async () => {
-    const h = harness();
-    const ctx = h.ctx();
-    await h.commands["mega-dashboard-status"].handler("", ctx);
-    assert.ok(h.notifies.some((n) => n.includes("not running")), "reports no server running");
+    // Private base so this asserts "no server" on a range nothing else uses,
+    // not the machine-global 9320 family (which may hold a leftover/production server).
+    process.env.MEGACOMPACT_DASHBOARD_PORT = "49320";
+    try {
+        const h = harness();
+        const ctx = h.ctx();
+        await h.commands["mega-dashboard-status"].handler("", ctx);
+        assert.ok(h.notifies.some((n) => n.includes("not running")), "reports no server running");
+    }
+    finally {
+        delete process.env.MEGACOMPACT_DASHBOARD_PORT;
+    }
 });
 test("/dashboard-stop reports no server when pid file missing", async () => {
     const h = harness();
@@ -335,20 +427,23 @@ test("/dashboard-stop reports no server when pid file missing", async () => {
     assert.ok(h.notifies.some((n) => n.includes("no dashboard server running")), "reports no server");
 });
 test("/dashboard skips server spawn when already running", async () => {
+    // Use a private dashboard port base for THIS test's harness + fake server so
+    // it never races the (parallel, hard-coded-9320) dashboard-server.test.js or
+    // a leftover production server. Set BEFORE harness() so registerDashboardCommands
+    // reads our base for findLivePort().
+    process.env.MEGACOMPACT_DASHBOARD_PORT = "29320";
     const h = harness();
     const confirms = [];
-    // Set up a fake HTTP server on a port inside the dashboard's scan range
-    // (9320–9329) — isServerRunning() probes those ports, not the port.pid value.
+    const livPort = 29320; // inside the harness's private scan range (29320–29329)
     const { createServer } = await import("node:http");
     const server = createServer((_req, res) => {
         res.writeHead(200, { "Content-Type": "application/json" });
         res.end(JSON.stringify({ updatedAt: new Date().toISOString(), tier: "test", version: 1, config: {}, session: {}, context: {}, trigger: {}, store: {} }));
     });
-    await new Promise((r) => server.listen(9320, "127.0.0.1", r));
-    const addr = server.address();
+    await new Promise((r) => server.listen(livPort, "127.0.0.1", r));
     const { join: j } = await import("node:path");
     const { writeFileSync: wf } = await import("node:fs");
-    wf(j(h.stateDir, "port.pid"), JSON.stringify({ port: addr.port, pid: process.pid }));
+    wf(j(h.stateDir, "port.pid"), JSON.stringify({ port: livPort, pid: process.pid }));
     const ctx = h.ctx({
         ui: {
             setStatus: () => { },
@@ -362,11 +457,14 @@ test("/dashboard skips server spawn when already running", async () => {
     assert.ok(h.notifies.some((n) => n.includes("already running")), "reports already running");
     assert.ok(confirms.length > 0, "confirm dialog was shown");
     await new Promise((r) => server.close(() => r()));
+    delete process.env.MEGACOMPACT_DASHBOARD_PORT;
 });
 test("/dashboard-status reports running after dashboard start", async () => {
+    // Private dashboard port base for this harness — never collides with the
+    // parallel dashboard-server.test.js (9320 family) or a leftover server.
+    process.env.MEGACOMPACT_DASHBOARD_PORT = "39320";
     const h = harness();
-    // Write a fake port.pid; the server must listen inside the scan range
-    // (9320–9329) or isServerRunning() won't detect it.
+    const livPort = 39320;
     const { createServer } = await import("node:http");
     const { join: j } = await import("node:path");
     const { writeFileSync: wf } = await import("node:fs");
@@ -374,13 +472,13 @@ test("/dashboard-status reports running after dashboard start", async () => {
         res.writeHead(200, { "Content-Type": "application/json" });
         res.end(JSON.stringify({ updatedAt: new Date().toISOString(), tier: "test" }));
     });
-    await new Promise((r) => server.listen(9321, "127.0.0.1", r));
-    const addr = server.address();
-    wf(j(h.stateDir, "port.pid"), JSON.stringify({ port: addr.port, pid: process.pid }));
+    await new Promise((r) => server.listen(livPort, "127.0.0.1", r));
+    wf(j(h.stateDir, "port.pid"), JSON.stringify({ port: livPort, pid: process.pid }));
     const ctx = h.ctx();
     await h.commands["mega-dashboard-status"].handler("", ctx);
-    assert.ok(h.notifies.some((n) => n.includes("running") && n.includes(String(addr.port))), "reports running with port");
+    assert.ok(h.notifies.some((n) => n.includes("running") && n.includes(String(livPort))), "reports running with port");
     await new Promise((r) => server.close(() => r()));
+    delete process.env.MEGACOMPACT_DASHBOARD_PORT;
 });
 test("state snapshot writes dashboard.json after compaction", async () => {
     const h = harness();
@@ -422,6 +520,10 @@ test("events.log receives compaction events", async () => {
         assert.ok(ex(j(h.stateDir, "dashboard.json")), "dashboard.json proves post-compact ran");
     }
 });
-test("cleanup", () => {
+test("cleanup", async () => {
+    // Terminate the global PGlite cross-repo index (WASM worker thread) so the
+    // test process can exit. Without this, node --test never returns even though
+    // every test passed — the leaked worker keeps the event loop alive.
+    await closeVectorIndex();
     rmSync(baseTmp, { recursive: true, force: true });
 });

package/dist/extensions/mega-config.js

@@ -70,6 +70,11 @@ export function loadConfig() {
         autoInlineK: envFlag("MEGACOMPACT_AUTO_INLINE_K", 3),
         dedupSim: Number(process.env.MEGACOMPACT_DEDUP_SIM ?? "0.9"),
         raptorEnabled: envBool("MEGACOMPACT_RAPTOR_ENABLED", true),
+        legacyDurableTrim: envBool("MEGACOMPACT_LEGACY_DURABLE_TRIM", false),
+        crossRepoEnabled: envBool("MEGACOMPACT_CROSSREPO_ENABLED", true),
+        crossRepoCosine: Number(process.env.MEGACOMPACT_CROSSREPO_COSINE ?? "0.90"),
+        memoryAutoReview: envBool("MEGACOMPACT_MEMORY_AUTO_REVIEW", true),
+        memoryReviewInterval: envFlag("MEGACOMPACT_MEMORY_REVIEW_INTERVAL", 10),
         recallMaxTokens: envFlag("MEGACOMPACT_RECALL_MAX_TOKENS", 1500),
         windowDedupe: envBool("MEGACOMPACT_WINDOW_DEDUPE", true),
         debug: envBool("MEGACOMPACT_DEBUG", false),