pi-mega-compact 0.4.28 → 0.5.1

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
@@ -118,6 +119,11 @@ function readIndex() {
     }
 }
 // ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+/** Package version of this extension, surfaced in the dashboard header. */
+let dashboardServerVersion = "0.0.0";
+// ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------
 function readSnapshot(snapshotPath) {
@@ -168,6 +174,7 @@ function dashboardHtml(tierName) {
   body { font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Helvetica Neue", Arial, sans-serif; background: #0d1117; color: #c9d1d9; padding: 24px; line-height: 1.5; }
   h1 { font-size: 20px; font-weight: 600; margin-bottom: 20px; display: flex; align-items: center; gap: 10px; color: #f0f6fc; }
   h1 .tier { background: #1f6feb; color: #fff; font-size: 11px; font-weight: 700; padding: 2px 8px; border-radius: 10px; text-transform: uppercase; letter-spacing: .5px; }
+  h1 .version-pill { background: #30363d; color: #8b949e; font-size: 11px; font-weight: 600; padding: 2px 8px; border-radius: 10px; font-family: ui-monospace, SFMono-Regular, Menlo, monospace; }
   .grid { display: grid; grid-template-columns: 1fr 1fr; gap: 16px; margin-bottom: 20px; }
   .card { background: #161b22; border: 1px solid #30363d; border-radius: 8px; padding: 16px; }
   .card.safe { border-color: #238636; }
@@ -254,7 +261,7 @@ function dashboardHtml(tierName) {
 
 <div class="offline-banner" id="offline-banner">Dashboard data unavailable — waiting for a pi session to write snapshot...</div>
 
-<h1><span>mega-compact</span><span class="tier">${tierName}</span><span class="model-pill" id="hdr-model">—</span></h1>
+<h1><span>mega-compact</span><span class="tier">${tierName}</span><span class="version-pill">v${dashboardServerVersion}</span><span class="model-pill" id="hdr-model">—</span></h1>
 
 <nav class="tabs">
   <button class="tab active" data-tab="current">Current repo</button>
@@ -688,11 +695,17 @@ export async function launchDashboardServer(stateDir) {
             const pkg = JSON.parse(readFileSync(p, "utf-8"));
             if (pkg.version) {
                 SERVER_VERSION = pkg.version;
+                dashboardServerVersion = pkg.version;
                 break;
             }
         }
     }
     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 +785,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 +896,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}`);
         },
     });