pi-mega-compact 0.4.27 → 0.5.0

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";
 
 // ---------------------------------------------------------------------------
@@ -774,6 +775,13 @@ export async function launchDashboardServer(stateDir: string): Promise<{ port: n
       if (pkg.version) { SERVER_VERSION = 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 +866,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 +980,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}`,
       );
     },

package/extensions/mega-compact.test.ts

@@ -18,6 +18,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";
 import type { AgentMessage } from "@earendil-works/pi-agent-core";
 
 const require = createRequire(import.meta.url);
@@ -83,6 +84,9 @@ function harness(opts: { keepTier?: boolean; keepThreshold?: boolean } = {}) {
   const sessionManager = {
     getSessionId: () => "sess_ext_001",
     getEntries: () => session.map(toEntry),
+    // Faithful mock: getBranch() returns the current branch's entries, which
+    // piCompactWouldNoop() reads to predict whether ctx.compact() would no-op.
+    getBranch: () => session.map(toEntry),
   };
 
   function makeCtx(over: Partial<any> = {}) {
@@ -174,22 +178,134 @@ function harness(opts: { keepTier?: boolean; keepThreshold?: boolean } = {}) {
   };
 }
 
-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);
+    // L1->L4 ran: a checkpoint was persisted to the SQLite store + a marker entry written.
+    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 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, 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 as any).messages), "result has a trimmed messages array");
+    // The trimmed view starts with the compacted summary (user-role) + is shorter.
+    assert.ok((res as any).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);
-  // L1->L4 ran: a checkpoint was persisted to the SQLite store + a marker entry written.
-  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 durable trim was supplied (summary + firstKeptEntryId from pi's prep).
-  assert.ok(h.compactCalls[0] !== undefined, "compaction flow executed");
+  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,
+  } as any, 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 () => {
@@ -331,10 +447,17 @@ 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 () => {
@@ -345,20 +468,23 @@ test("/dashboard-stop reports no server when pid file missing", async () => {
 });
 
 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: boolean[] = [];
-  // 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<void>((r) => server.listen(9320, "127.0.0.1", r));
-  const addr = server.address() as any;
+  await new Promise<void>((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: {
@@ -375,12 +501,15 @@ test("/dashboard skips server spawn when already running", async () => {
   assert.ok(confirms.length > 0, "confirm dialog was shown");
 
   await new Promise<void>((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");
@@ -388,15 +517,15 @@ 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<void>((r) => server.listen(9321, "127.0.0.1", r));
-  const addr = server.address() as any;
-  wf(j(h.stateDir, "port.pid"), JSON.stringify({ port: addr.port, pid: process.pid }));
+  await new Promise<void>((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<void>((r) => server.close(() => r()));
+  delete process.env.MEGACOMPACT_DASHBOARD_PORT;
 });
 
 test("state snapshot writes dashboard.json after compaction", async () => {
@@ -443,6 +572,10 @@ test("events.log receives compaction events", async () => {
   }
 });
 
-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/extensions/mega-config.ts

@@ -44,6 +44,23 @@ export interface MegaConfig {
   /** RAPTOR hierarchical recall enabled (Fix D). Drives both live recall and
    *  the durable-trim summary source (root summary). */
   raptorEnabled: boolean;
+  /** Legacy v0.4.28 behavior: auto-trigger calls ctx.compact() (which STOPS
+   *  the agent). Default false — the S16 redesign uses the live context-event
+   *  trim + pi native auto-compaction instead (compact and continue). Kept for
+   *  one release as rollback. */
+  legacyDurableTrim: boolean;
+  /** Cross-repo recall enabled (S17). Resume + /mega-recall --cross-repo can
+   *  pull checkpoints from OTHER repos via the PGlite HNSW index. Default true. */
+  crossRepoEnabled: boolean;
+  /** Stricter cosine floor for cross-repo hits (S17). Default 0.90 (trigram) /
+   *  tighter than same-repo so only genuinely-relevant cross-repo context is
+   *  injected. */
+  crossRepoCosine: number;
+  /** Memory-RAG auto-review enabled (S20). Every memoryReviewInterval turns the
+   *  conversation is auto-reviewed into durable add/replace/remove memories. */
+  memoryAutoReview: boolean;
+  /** Turn cadence for the auto-review scan (S20). Default 10. */
+  memoryReviewInterval: number;
   /** Token ceiling for the re-injected recall block (Fix C). Recall stops
    *  adding checkpoints once the block would exceed this — bounds read-path
    *  token cost so it can never net-inflate the window. */
@@ -104,6 +121,11 @@ export function loadConfig(): MegaConfig {
     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),

package/extensions/mega-conflict-cmds.ts

@@ -126,4 +126,85 @@ export function registerConflictCommands(pi: ExtensionAPI, runtime: MegaRuntime)
       for (const m of all) ctx.ui.notify(memoryLine(m));
     },
   });
+
+  // Shortform aliases — `m save "..."`, `m status`, `m list`, `m search <q>`,
+  // `m recall <id>`. Delegates to the same SQLite store so there's one source
+  // of truth. The /mega-memory command remains the canonical form.
+  pi.registerCommand("m", {
+    description: "Shortform alias for /mega-memory. Usage: /m save <text> | list | search <q> | recall <id> | status",
+    handler: async (args: string, ctx: ExtensionContext) => {
+      const repo = resolveRepoRoot(ctx.cwd) ?? runtime.currentStateDir;
+      const parts = args.trim().split(/\s+/);
+      const sub = parts[0]?.toLowerCase() ?? "list";
+
+      if (sub === "save") {
+        // Strip leading "save" so /m save "#foo bar" works the same as the
+        // canonical form. Then strip a balanced outer quote pair if the user
+        // wrote /m save "..." — common when the text contains spaces.
+        let text = args.trim().slice(4).trim();
+        const mq = text.match(/^["“](.*)["”]$/s);
+        if (mq) text = mq[1].trim();
+        if (!text) {
+          ctx.ui.notify('[/m] usage: /m save "<text>" or /m save <text>');
+          return;
+        }
+        const tagMatches = [...text.matchAll(/#([\w-]+)/g)].map((m) => m[1]);
+        const content = text.replace(/#[\w-]+/g, "").trim();
+        const id = addMemory({ content, tags: tagMatches }, repo, runtime.currentStateDir);
+        ctx.ui.notify(`[/m] saved #${id} to ${repo.split(/[\\/]/).pop()}`);
+        return;
+      }
+
+      if (sub === "search") {
+        const q = parts.slice(1).join(" ").trim();
+        if (!q) {
+          ctx.ui.notify("[/m] usage: /m search <query>");
+          return;
+        }
+        const hits = searchMemories(q, repo, 50, runtime.currentStateDir);
+        if (!hits.length) {
+          ctx.ui.notify("[/m] no memories match.");
+          return;
+        }
+        for (const mem of hits) ctx.ui.notify(memoryLine(mem));
+        return;
+      }
+
+      if (sub === "recall") {
+        const id = Number(parts[1]);
+        if (!Number.isFinite(id) || parts[1] === undefined) {
+          ctx.ui.notify("[/m] usage: /m recall <id>");
+          return;
+        }
+        if (recallMemory(id, runtime.currentStateDir)) {
+          const found = listMemories(repo, 1000, runtime.currentStateDir).find((mem) => mem.id === id);
+          ctx.ui.notify(found ? `[/m] ${memoryLine(found)}` : `[/m] recalled #${id}`);
+        } else {
+          ctx.ui.notify(`[/m] #${id} not found.`);
+        }
+        return;
+      }
+
+      if (sub === "status") {
+        const all = listMemories(repo, 1000, runtime.currentStateDir);
+        const byKind = all.reduce<Record<string, number>>((acc, m) => {
+          acc[m.kind] = (acc[m.kind] ?? 0) + 1;
+          return acc;
+        }, {});
+        const kinds = Object.entries(byKind).map(([k, n]) => `${k}=${n}`).join(", ");
+        const head = `[/m] ${all.length} memory record(s) in ${repo.split(/[\\/]/).pop() ?? repo}`;
+        ctx.ui.notify(kinds ? `${head} (${kinds})` : head);
+        return;
+      }
+
+      // default: list
+      const all = listMemories(repo, 50, runtime.currentStateDir);
+      if (!all.length) {
+        ctx.ui.notify("[/m] no saved memories yet. Use /m save <text>.");
+        return;
+      }
+      ctx.ui.notify(`[/m] ${all.length} memory record(s):`);
+      for (const mem of all) ctx.ui.notify(memoryLine(mem));
+    },
+  });
 }

package/extensions/mega-dashboard-cmds.ts

@@ -23,11 +23,13 @@ export function registerDashboardCommands(pi: ExtensionAPI, runtime: MegaRuntime
   // the shipped compiled dist/extensions/dashboard-server.js).
   let dashboardNeedsStrip = false;
 
-  // The dashboard server binds 9320–9329 (TARGET_PORT..TARGET_PORT+PORT_RANGE-1
-  // in dashboard-server.js). Probe each for a live /api/snapshot so we can detect
-  // readiness even when port.pid landed in a different state dir than we poll.
+  // The dashboard server binds a 10-port range starting at MEGACOMPACT_DASHBOARD_PORT
+  // (default 9320) — see TARGET_PORT/PORT_RANGE in dashboard-server.js. Probe each for
+  // a live /api/snapshot so we detect readiness even when port.pid landed in a different
+  // state dir than we poll. Configurable so tests can use a private, non-colliding range.
+  const DASH_BASE = Number(process.env.MEGACOMPACT_DASHBOARD_PORT ?? "9320");
   async function findLivePort(): Promise<number | null> {
-    for (let port = 9320; port <= 9329; port++) {
+    for (let port = DASH_BASE; port <= DASH_BASE + 9; port++) {
       try {
         const res = await fetch(`http://localhost:${port}/api/snapshot`, { signal: AbortSignal.timeout(800) }); // guardrails-allow PREVENT-PI-004: localhost liveness probe of the dashboard server this extension spawned
         if (res.ok) return port;