pi-mega-compact 0.4.28 → 0.5.1

package/dist/src/store/sqlite.js

@@ -53,8 +53,18 @@ const cache = new Map();
 /** Open (or reuse) the SQLite store for a state dir. */
 export function openStore(stateDir = getStateDir()) {
     const existing = cache.get(stateDir);
-    if (existing)
-        return existing;
+    if (existing) {
+        // A closed handle in the cache (e.g. a test calling db.close() directly
+        // instead of closeStore) would surface as "database is not open" on the
+        // next reuse. Detect and evict so callers never see a dead handle.
+        try {
+            existing.prepare("SELECT 1");
+            return existing;
+        }
+        catch {
+            cache.delete(stateDir);
+        }
+    }
     if (!existsSync(stateDir))
         mkdirSync(stateDir, { recursive: true });
     const db = new DatabaseSync(join(stateDir, "sqlite.db"));
@@ -118,6 +128,19 @@ export function openIndexStore(indexDir = getIndexDir()) {
       model_captured_at         INTEGER
     );
     CREATE INDEX IF NOT EXISTS idx_registry_last_seen ON repo_registry(last_seen DESC);
+    -- S18: machine-wide injected-set. A foreign checkpoint injected in repo A is
+    -- recorded here so repo B's recall never re-injects it. Keyed by checkpoint
+    -- + session (a checkpoint may be injected once per session); repo_id is the
+    -- source repo (the foreign repo's stateDir) for tracking/source labels.
+    -- PRAMETERIZED queries (PREVENT-002); local node:sqlite (PREVENT-PI-004).
+    CREATE TABLE IF NOT EXISTS injected_global (
+      checkpoint_id TEXT NOT NULL,
+      repo_id       TEXT NOT NULL,
+      session_id    TEXT NOT NULL,
+      injected_at   INTEGER NOT NULL,
+      PRIMARY KEY (checkpoint_id, session_id)
+    );
+    CREATE INDEX IF NOT EXISTS idx_injected_global_cid ON injected_global(checkpoint_id);
   `);
     indexCache = iddb;
     indexCacheDir = indexDir;
@@ -133,25 +156,41 @@ export function upsertRepoRegistry(row, indexDir = getIndexDir()) {
     const now = Date.now();
     db.prepare(`INSERT INTO repo_registry
        (repo_root, display_name, state_dir, first_seen, last_seen, last_compacted_at,
-        checkpoint_count, tokens_saved, compressed_original_bytes)
-     VALUES (@repo_root, @display_name, @state_dir, @now, @now, @last_compacted_at,
-             @checkpoint_count, @tokens_saved, @compressed_original_bytes)
+        checkpoint_count, tokens_saved, compressed_original_bytes,
+        provider, provider_name, model_name, input_rate, output_rate, model_captured_at)
+     VALUES (@repo_root, @display_name, @state_dir, @first_seen, @last_seen, @last_compacted_at,
+             @checkpoint_count, @tokens_saved, @compressed_original_bytes,
+             @provider, @provider_name, @model_name, @input_rate, @output_rate, @model_captured_at)
      ON CONFLICT(repo_root) DO UPDATE SET
        display_name = excluded.display_name,
        state_dir = excluded.state_dir,
-       last_seen = excluded.last_seen,
+       last_seen = COALESCE(excluded.last_seen, @now),
        last_compacted_at = COALESCE(excluded.last_compacted_at, repo_registry.last_compacted_at),
        checkpoint_count = excluded.checkpoint_count,
        tokens_saved = excluded.tokens_saved,
-       compressed_original_bytes = excluded.compressed_original_bytes`).run({
+       compressed_original_bytes = excluded.compressed_original_bytes,
+       provider = COALESCE(excluded.provider, repo_registry.provider),
+       provider_name = COALESCE(excluded.provider_name, repo_registry.provider_name),
+       model_name = COALESCE(excluded.model_name, repo_registry.model_name),
+       input_rate = COALESCE(excluded.input_rate, repo_registry.input_rate),
+       output_rate = COALESCE(excluded.output_rate, repo_registry.output_rate),
+       model_captured_at = COALESCE(excluded.model_captured_at, repo_registry.model_captured_at)`).run({
         repo_root: row.repoRoot,
         display_name: row.displayName,
         state_dir: row.stateDir,
         now,
+        first_seen: row.firstSeen ?? null,
+        last_seen: row.lastSeen ?? null,
         last_compacted_at: row.lastCompactedAt ?? null,
         checkpoint_count: row.checkpointCount,
         tokens_saved: row.tokensSaved,
         compressed_original_bytes: row.compressedOriginalBytes,
+        provider: row.provider ?? null,
+        provider_name: row.providerName ?? null,
+        model_name: row.modelName ?? null,
+        input_rate: row.inputRate ?? null,
+        output_rate: row.outputRate ?? null,
+        model_captured_at: row.modelCapturedAt ?? null,
     });
 }
 /**
@@ -225,6 +264,34 @@ export function closeIndexStore() {
         indexCacheDir = undefined;
     }
 }
+// ---------------------------------------------------------------------------
+// S18: machine-wide injected-set (cross-repo dedup markers)
+//
+// A foreign checkpoint injected in repo A is recorded here so repo B's recall
+// never re-injects it (a stronger, machine-wide version of the per-session
+// injected-set in the local store). Keyed by (checkpoint_id, session_id); the
+// session_id here is the RECEIVING session, so the same foreign checkpoint can
+// be injected into different sessions but never twice into the same one.
+// PRAMETERIZED queries (PREVENT-002); local node:sqlite + WAL (PREVENT-PI-004),
+// multi-process safe.
+// ---------------------------------------------------------------------------
+/** Record that a (foreign) checkpoint was injected into `sessionId`. Idempotent. */
+export function markInjectedGlobal(checkpointId, repoId, sessionId, indexDir = getIndexDir()) {
+    const db = openIndexStore(indexDir);
+    db.prepare("INSERT OR IGNORE INTO injected_global (checkpoint_id, repo_id, session_id, injected_at) VALUES ($cid, $rid, $sid, $ts)").run({ $cid: checkpointId, $rid: repoId, $sid: sessionId, $ts: Date.now() });
+}
+/** True when a checkpoint was already injected into `sessionId` (machine-wide). */
+export function wasInjectedGlobal(checkpointId, sessionId, indexDir = getIndexDir()) {
+    const db = openIndexStore(indexDir);
+    const row = db.prepare("SELECT 1 FROM injected_global WHERE checkpoint_id = $cid AND session_id = $sid LIMIT 1").get({ $cid: checkpointId, $sid: sessionId });
+    return row !== undefined;
+}
+/** Count of cross-repo injections recorded (for /mega-status stats). */
+export function countInjectedGlobal(indexDir = getIndexDir()) {
+    const db = openIndexStore(indexDir);
+    const row = db.prepare("SELECT COUNT(*) AS n FROM injected_global").get();
+    return row?.n ?? 0;
+}
 function initSchema(db) {
     db.exec(`
     CREATE TABLE IF NOT EXISTS context_chunks (
@@ -374,7 +441,12 @@ function initSchema(db) {
       content           TEXT NOT NULL,
       tags              TEXT,                   -- JSON array of strings
       created_at        INTEGER,
-      last_recalled_at  INTEGER
+      last_recalled_at  INTEGER,
+      -- S20 memory-RAG extension (auto-review add/replace/remove ops).
+      category          TEXT,                   -- typed bucket, e.g. decision | fact | preference
+      target            TEXT,                   -- optional subject/scope this memory targets
+      last_referenced   INTEGER,               -- last time memory was referenced by recall (epoch s)
+      source_turn       INTEGER                -- conversation turn that produced this memory
     );
     CREATE INDEX IF NOT EXISTS idx_memories_repo ON memories(repo);
 
@@ -391,6 +463,12 @@ function initSchema(db) {
     // databases created by an older version — otherwise repoStats()/upsert crash
     // with "no such column" and the extension fails to load. Additive only.
     ensureColumn(db, "context_chunks", "original_token_estimate", "INTEGER");
+    // S20 memory-RAG extension: additive columns for auto-review ops. Idempotent —
+    // only alters DBs created by an older version that lack these columns.
+    ensureColumn(db, "memories", "category", "TEXT");
+    ensureColumn(db, "memories", "target", "TEXT");
+    ensureColumn(db, "memories", "last_referenced", "INTEGER");
+    ensureColumn(db, "memories", "source_turn", "INTEGER");
     const v = db.prepare("SELECT value FROM meta WHERE key='schema_version'").get();
     if (!v) {
         db.prepare("INSERT INTO meta(key, value) VALUES(?, ?)").run("schema_version", String(SCHEMA_VERSION));
@@ -500,9 +578,9 @@ export function addMemory(memory, repo, stateDir = getStateDir()) {
     const db = openStore(stateDir);
     const now = Math.floor(Date.now() / 1000);
     const res = db
-        .prepare(`INSERT INTO memories(repo, kind, content, tags, created_at, last_recalled_at)
-       VALUES(?, ?, ?, ?, ?, NULL)`)
-        .run(repo ?? null, memory.kind ?? "note", memory.content, JSON.stringify(memory.tags ?? []), now);
+        .prepare(`INSERT INTO memories(repo, kind, content, tags, created_at, last_recalled_at, category, target, source_turn)
+       VALUES(?, ?, ?, ?, ?, NULL, ?, ?, ?)`)
+        .run(repo ?? null, memory.kind ?? "note", memory.content, JSON.stringify(memory.tags ?? []), now, memory.category ?? null, memory.target ?? null, memory.sourceTurn ?? null);
     return Number(res.lastInsertRowid);
 }
 /** List recent memories for a repo (or all repos when repo is null). */
@@ -529,6 +607,40 @@ export function recallMemory(id, stateDir = getStateDir()) {
     const res = db.prepare("UPDATE memories SET last_recalled_at = ? WHERE id = ?").run(now, id);
     return res.changes > 0;
 }
+/** Mark a memory as referenced (updates last_referenced). Returns true if found. */
+export function referenceMemory(id, stateDir = getStateDir()) {
+    const db = openStore(stateDir);
+    const now = Math.floor(Date.now() / 1000);
+    const res = db.prepare("UPDATE memories SET last_referenced = ? WHERE id = ?").run(now, id);
+    return res.changes > 0;
+}
+/** Replace a memory's mutable fields by id. Returns true if a row was updated. */
+export function replaceMemory(id, patch, stateDir = getStateDir()) {
+    const db = openStore(stateDir);
+    const res = db
+        .prepare(`UPDATE memories
+       SET kind = COALESCE(?, kind),
+           content = COALESCE(?, content),
+           tags = COALESCE(?, tags),
+           category = COALESCE(?, category),
+           target = COALESCE(?, target),
+           source_turn = COALESCE(?, source_turn)
+       WHERE id = ?`)
+        .run(patch.kind ?? null, patch.content ?? null, patch.tags ? JSON.stringify(patch.tags) : null, "category" in patch ? (patch.category ?? null) : null, "target" in patch ? (patch.target ?? null) : null, "sourceTurn" in patch ? (patch.sourceTurn ?? null) : null, id);
+    return res.changes > 0;
+}
+/** Remove a memory by id. Returns true if a row was deleted. */
+export function removeMemory(id, stateDir = getStateDir()) {
+    const db = openStore(stateDir);
+    const res = db.prepare("DELETE FROM memories WHERE id = ?").run(id);
+    return res.changes > 0;
+}
+/** Look up a single memory by id (or undefined). */
+export function getMemory(id, stateDir = getStateDir()) {
+    const db = openStore(stateDir);
+    const row = db.prepare("SELECT * FROM memories WHERE id = ?").get(id);
+    return row ? mapMemoryRow(row) : undefined;
+}
 function mapMemoryRow(row) {
     return {
         id: row.id,
@@ -538,6 +650,10 @@ function mapMemoryRow(row) {
         tags: row.tags ? JSON.parse(row.tags) : [],
         createdAt: row.created_at ?? 0,
         lastRecalledAt: row.last_recalled_at ?? null,
+        category: row.category ?? null,
+        target: row.target ?? null,
+        lastReferenced: row.last_referenced ?? null,
+        sourceTurn: row.source_turn ?? null,
     };
 }
 /**

package/dist/src/vectorStore.js

@@ -240,6 +240,7 @@ export class VectorStore {
         const checkpoint = {
             checkpointId,
             sessionId,
+            repoId: this.repoId,
             summary: input.summary,
             topicSummary: input.topicSummary,
             summaryHash,
@@ -412,11 +413,15 @@ export class VectorStore {
         }
         // Hydrate each index hit from the authoritative node:sqlite store. repoId is
         // that repo's stateDir, so cross-repo hits resolve against their own store.
+        // Tag cross-repo hits with their source repoId so the recall block can label
+        // them ("from repo <name>"); same-repo hits stay unlabeled.
+        const selfRepo = this.repoId;
         const hydrated = [];
         for (const h of indexHits) {
             const cp = getCheckpoint(h.sessionId, h.checkpointId, h.repoId);
             if (cp && cp.dedupStatus !== "removed") {
-                hydrated.push({ checkpoint: cp, score: h.score });
+                const crossRepo = opts.crossRepo && selfRepo && h.repoId && h.repoId !== selfRepo;
+                hydrated.push({ checkpoint: cp, score: h.score, repoId: crossRepo ? h.repoId : undefined });
             }
         }
         if (hydrated.length === 0)

package/extensions/dashboard-server.test.ts

@@ -124,6 +124,110 @@ 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())) as {
+        summary: { totalRepos: number; totalCheckpoints: number; totalTokensSaved: number };
+        repos: { repoRoot: string; displayName: string; checkpointCount: number; tokensSaved: number }[];
+      };
+      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())) as { repos: { displayName: string }[]; count: number };
+      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())) as { repos: { displayName: string }[]; count: number };
+      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())) as { activeRepos: number; totalRepos: number };
+      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
@@ -136,6 +240,12 @@ describe("port.pid file", () => {
 
 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: () => boolean | Promise<boolean>, timeoutMs = 6000): Promise<void> {
   const start = Date.now();
   return new Promise((resolve, reject) => {
@@ -151,8 +261,10 @@ function waitFor(cond: () => boolean | Promise<boolean>, timeoutMs = 6000): Prom
 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 {
@@ -169,7 +281,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/extensions/dashboard-server.ts

@@ -16,6 +16,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";
 
 // ---------------------------------------------------------------------------
@@ -130,6 +131,9 @@ function readIndex(): { updatedAt: string; summary: unknown; repos: unknown[] }
 // Types
 // ---------------------------------------------------------------------------
 
+/** Package version of this extension, surfaced in the dashboard header. */
+let dashboardServerVersion = "0.0.0";
+
 interface Snapshot {
   version: number;
   updatedAt: string | null;
@@ -252,6 +256,7 @@ function dashboardHtml(tierName: string): string {
   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; }
@@ -338,7 +343,7 @@ function dashboardHtml(tierName: string): string {
 
 <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>
@@ -771,9 +776,16 @@ export async function launchDashboardServer(stateDir: string): Promise<{ port: n
     for (const p of candidates) {
       if (!existsSync(p)) continue;
       const pkg = JSON.parse(readFileSync(p, "utf-8"));
-      if (pkg.version) { SERVER_VERSION = pkg.version; break; }
+      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: string) =>
+    (driftReq("../src/driftDetection.js") as typeof import("../src/driftDetection.js"))
+      .detectCrossRepoDrift(idxDir);
   const portFile = join(stateDir, "port.pid");
   const snapshotPath = join(stateDir, "dashboard.json");
   const eventsPath = join(stateDir, "events.log");
@@ -858,6 +870,54 @@ export async function launchDashboardServer(stateDir: string): Promise<{ port: n
       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 ?? []) as IndexRepo[];
+      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 ?? []) as IndexRepo[];
+      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",
@@ -924,8 +984,13 @@ export async function launchDashboardServer(stateDir: string): Promise<{ port: n
     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: number) {

package/extensions/mega-commands.ts

@@ -9,11 +9,11 @@
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 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 { MegaRuntime, 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, type MegaConfig, type CompactTier } from "./mega-config.js";
 
 /** Resolve a checkpoint by id (or "recent"/"last") from this session's store. */
@@ -47,16 +47,21 @@ export function registerCommands(pi: ExtensionAPI, runtime: MegaRuntime, 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: string, ctx: ExtensionContext) => {
-      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;
       }
@@ -64,10 +69,10 @@ export function registerCommands(pi: ExtensionAPI, runtime: MegaRuntime, 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`);
+      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}":\n${list}\n` +
+        `[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)`,
       );
     },
@@ -111,6 +116,15 @@ export function registerCommands(pi: ExtensionAPI, runtime: MegaRuntime, 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` +
@@ -126,6 +140,7 @@ export function registerCommands(pi: ExtensionAPI, runtime: MegaRuntime, config:
           `[mega-compact] 💰 ${costStr}\n` +
           `[mega-compact] 🤖 model: ${modelStr}\n` +
           `[mega-compact] 🎯 ${qualityStr}\n` +
+          `[mega-compact] 🌐 ${crossRepoStr}\n` +
           `[mega-compact] stateDir=${runtime.currentStateDir}`,
       );
     },