pi-mega-compact 0.4.28 → 0.5.1

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);
@@ -177,14 +178,18 @@ 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);
@@ -192,34 +197,115 @@ 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 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);
-  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,
+  } 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 () => {
@@ -361,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 () => {
@@ -375,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: {
@@ -405,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");
@@ -418,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 () => {
@@ -473,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;

package/extensions/mega-events.ts

@@ -8,12 +8,15 @@
  */
 
 import type { ExtensionAPI, ExtensionContext, ContextEvent, SessionBeforeCompactEvent } from "@earendil-works/pi-coding-agent";
+import type { AgentMessage } from "@earendil-works/pi-agent-core";
 import { normalizeSessionId } from "../src/store.js";
 import { autoCompactCheck } from "../src/compact.js";
 import { estimateSessionTokens } from "../src/tokens.js";
 import { MegaRuntime, recentUserQuery, WIDGET_KEY } from "./mega-runtime.js";
-import { runCompact, doRecall, piCompactWouldNoop } from "./mega-pipeline.js";
+import { runCompact, doRecall, doRecallAsync, piCompactWouldNoop } from "./mega-pipeline.js";
+import { recallMemoriesAndInline } from "../src/recall.js";
 import { driveNativeCompaction } from "./mega-compact-driver.js";
+import { computeLiveTrimCut, liveTrimSummaryMessage } from "./mega-trim.js";
 import { pressureFromPct, type MegaConfig } from "./mega-config.js";
 
 /** Register all pi lifecycle event handlers. */
@@ -29,6 +32,8 @@ export function registerEventHandlers(pi: ExtensionAPI, runtime: MegaRuntime, co
     runtime.resetRuntime(ctx.sessionManager.getSessionId());
     runtime.captureModel(ctx); // best-effort: ctx.model may be set by session start
     runtime.setStatus(ctx, config.auto ? "mega-compact: ready" : "mega-compact: manual only");
+    // S21: clear any stale memory block from a prior session.
+    runtime.pendingMemoryRecallBlock = undefined;
     // Auto-inline on resume/fork/continue: stage the most relevant checkpoints
     // so the next before_agent_start prepends them to the system prompt.
     // Triggered whenever this session already has persisted checkpoints AND a
@@ -40,13 +45,27 @@ export function registerEventHandlers(pi: ExtensionAPI, runtime: MegaRuntime, co
       const sid = normalizeSessionId(ctx.sessionManager.getSessionId());
       const query = recentUserQuery(ctx);
       if (query && runtime.store.stats(sid).checkpointCount > 0) {
-        const r = doRecall(runtime, config, ctx, query, "resume");
+        // S17: use the async variant on resume so cross-repo HNSW recall can
+        // augment when this repo's store is thin. session_start is an async-safe
+        // point (unlike the mid-turn context handler, which stays sync).
+        const r = await doRecallAsync(runtime, config, ctx, query, "resume", { crossRepo: config.crossRepoEnabled });
         if (!r.empty) {
           runtime.pendingRecallBlock = r.block;
-          runtime.setStatus(ctx, `mega-compact: recalled ${r.toInject.length} chkpt`);
-          runtime.logger.info("auto-inline", { reason: event.reason, query, injected: r.toInject.map((h) => h.checkpoint.checkpointId) });
+          const crossLabel = r.toInject.some((h) => h.repoId) ? " (cross-repo)" : "";
+          runtime.setStatus(ctx, `mega-compact: recalled ${r.toInject.length} chkpt${crossLabel}`);
+          runtime.logger.info("auto-inline", { reason: event.reason, query, injected: r.toInject.map((h) => h.checkpoint.checkpointId), crossRepo: r.toInject.some((h) => h.repoId) });
         }
       }
+      // S21: parallel memory recall. Same async context so we can await without
+      // breaking the handler contract. Best-effort — never throws.
+      try {
+        const mr = await recallMemoriesAndInline({
+          query, stateDir: runtime.getStateDir(), limit: 5,
+        });
+        if (!mr.empty) runtime.pendingMemoryRecallBlock = mr.block;
+      } catch (err) {
+        runtime.logger.warn("memory-recall skipped", { err: String(err) });
+      }
     }
     runtime.dashboard.event("session_start", { reason: event.reason, sessionId: runtime.rt.sessionId });
     runtime.snapshot(ctx);
@@ -65,6 +84,13 @@ export function registerEventHandlers(pi: ExtensionAPI, runtime: MegaRuntime, co
           runtime.pendingRecallBlock = r.block;
           runtime.logger.info("auto-inline", { reason: "session_tree", query, injected: r.toInject.map((h) => h.checkpoint.checkpointId) });
         }
+        // S21: parallel memory recall. Trigram embedder is sub-ms; await is fine.
+        try {
+          const mr = await recallMemoriesAndInline({ query, stateDir: runtime.getStateDir(), limit: 5 });
+          if (!mr.empty) runtime.pendingMemoryRecallBlock = mr.block;
+        } catch (err) {
+          runtime.logger.warn("memory-recall skipped", { err: String(err) });
+        }
       }
     }
     runtime.dashboard.event("session_tree", { sessionId: runtime.rt.sessionId });
@@ -74,10 +100,13 @@ export function registerEventHandlers(pi: ExtensionAPI, runtime: MegaRuntime, co
   // ---- Auto-inline injection point: prepend staged recall to systemPrompt ----
   pi.on("before_agent_start", async (event, ctx) => {
     runtime.captureModel(ctx); // most reliable point ctx.model is populated
-    if (!runtime.pendingRecallBlock) return;
-    const block = runtime.pendingRecallBlock;
-    runtime.pendingRecallBlock = undefined; // one-shot: consume so we never double-inject
-    return { systemPrompt: `${event.systemPrompt}\n\n${block}` };
+    const cpBlock = runtime.pendingRecallBlock;
+    const memBlock = runtime.pendingMemoryRecallBlock;
+    if (!cpBlock && !memBlock) return;
+    runtime.pendingRecallBlock = undefined;
+    runtime.pendingMemoryRecallBlock = undefined;
+    const composed = [cpBlock, memBlock].filter(Boolean).join("\n\n");
+    return { systemPrompt: `${event.systemPrompt}\n\n${composed}` };
   });
 
   pi.on("session_shutdown", async (_event, ctx) => {
@@ -105,6 +134,23 @@ export function registerEventHandlers(pi: ExtensionAPI, runtime: MegaRuntime, co
     } else {
       runtime.setStatus(ctx, config.auto ? "mega-compact: ready" : "mega-compact: manual only");
     }
+    // S16 continuation fallback: if the turn settled idle right after a live-trim
+    // compaction AND there is queued work AND we haven't nudged recently, nudge
+    // once so the agent continues (the live trim should make this rare). Guarded
+    // to never busy-loop: one nudge per 30s, only when truly idle + queued.
+    if (config.auto && runtime.activeAgents === 0) {
+      try {
+        const idle = ctx.isIdle?.() ?? true;
+        const queued = ctx.hasPendingMessages?.() ?? false;
+        const now = Date.now();
+        if (idle && queued && now >= runtime.resumeNudgeUntil) {
+          runtime.resumeNudgeUntil = now + 30_000;
+          pi.sendUserMessage("[mega-compact] continue from the compacted context above.");
+        }
+      } catch {
+        /* non-fatal: a failed nudge never blocks */
+      }
+    }
     runtime.snapshot(ctx);
   });
 
@@ -117,17 +163,44 @@ export function registerEventHandlers(pi: ExtensionAPI, runtime: MegaRuntime, co
   pi.on("turn_end", async (event, ctx) => {
     runtime.dashboard.event("turn_end", { turnIndex: event.turnIndex });
     runtime.snapshot(ctx);
+
+    // S20: auto-review the conversation every N turns and persist durable
+    // memories. Best-effort + non-fatal: a review failure must never break the
+    // agent loop. Debounced by memoryReviewInterval turns.
+    if (config.memoryAutoReview && runtime.currentTurn > 0 && runtime.currentTurn % config.memoryReviewInterval === 0) {
+      try {
+        const { reviewConversation } = await import("../src/memory.js");
+        const { applyMemoryOps } = await import("../src/memoryOps.js");
+        const entries = ctx.sessionManager.getEntries();
+        const view = runtime.engineView(entries.flatMap((e: any) => (e.message ? [e.message] : [])));
+        const ops = reviewConversation(view, []);
+        if (ops.length) {
+          await applyMemoryOps(ops, runtime.currentStateDir);
+          // S21.2: a memory op landed in this turn window. The pipeline reads
+          // this counter after a successful compaction and fires
+          // `consolidateMemories` only when it's > 0.
+          runtime.memoriesTouchedThisCompaction += ops.length;
+        }
+      } catch {
+        /* non-fatal — auto-review must not break the turn loop */
+      }
+    }
   });
 
-  // ---- Auto-trigger: own the decision, pi owns the durable write ----------
-  // OUR auto-trigger (over threshold + debounce): persist our Trident checkpoint,
-  // then start pi's compaction flow via ctx.compact(). That fires
-  // `session_before_compact`, where OUR handler returns our summary +
-  // firstKeptEntryId, and pi durably writes the trim to disk (appendCompaction).
-  // Result: auto-compact AND a durable trim — resume reloads the trimmed window,
-  // no full-reload + additive recall inflation (Fix B kills the token-growth bug).
-  // We do NOT drop messages here (that would be ephemeral; the read-only session
-  // manager can't trim disk, so the trim has to come through pi).
+  // ---- Auto-trigger: live trim (compact and continue) + native durable ----
+  // S16 redesign: we NO LONGER call ctx.compact() from the auto-trigger by
+  // default. That mapped to pi's MANUAL compaction path, which abort()s the
+  // in-flight turn (agent-session.js:1345) and stops the agent. Instead:
+  //  - LIVE: return { messages: trimmedView } from the context event. This
+  //    feeds pi's transformContext (sdk.js:226 → agent-loop.js:180) so the
+  //    model sees a compacted window EVERY LLM call, with no abort. The turn
+  //    continues. We persist our recall checkpoint (the durable value) first.
+  //  - DURABLE: pi's NATIVE auto-compaction fires at agent-end
+  //    (agent-session.js:1565), continues (return hasQueuedMessages()), and
+  //    emits session_before_compact — where OUR driveNativeCompaction supplies
+  //    the summary and pi truncates the transcript on disk. No ctx.compact().
+  // Legacy: MEGACOMPACT_LEGACY_DURABLE_TRIM=true restores the v0.4.28 ctx.compact
+  // path (kept one release as rollback).
   pi.on("context", async (event: ContextEvent, ctx: ExtensionContext) => {
     if (!config.auto) return;
     const usage = ctx.getContextUsage();
@@ -162,17 +235,55 @@ export function registerEventHandlers(pi: ExtensionAPI, runtime: MegaRuntime, co
     const ran = runCompact(pi, runtime, config, ctx, messages, { compressionPressure: pressure });
     if (ran.skipped) return;
 
-    // Skip pi's durable-trim flow when pi would no-op ("Nothing to compact /
-    // Already compacted"). pi throws that error *before* session_before_compact
-    // fires and renders it via a compaction_end event we can't mute (onError is
-    // too late), so the only fix is to not call ctx.compact() on a no-op. Our
-    // recall checkpoint above is already persisted; the durable trim is
-    // unnecessary for a transcript pi would keep in full anyway.
-    if (piCompactWouldNoop(ctx)) return;
-
-    // Start pi's compaction flow so our session_before_compact handler can
-    // supply the durable trim (pi writes it to disk). We never use pi's summary.
-    ctx.compact({ customInstructions: undefined });
+    // LEGACY path (rollback): v0.4.28 ctx.compact() + the no-op gate. The
+    // manual compact path aborts the in-flight turn — only used behind the flag.
+    // Read live from env (in addition to the load-time config) so the flag can be
+    // toggled per-test without reloading the module; config.legacyDurableTrim is
+    // the cached default. (Mirrors how piCompactWouldNoop re-reads its floor.)
+    const legacy = config.legacyDurableTrim || process.env.MEGACOMPACT_LEGACY_DURABLE_TRIM === "true" || process.env.MEGACOMPACT_LEGACY_DURABLE_TRIM === "1";
+    if (legacy) {
+      if (piCompactWouldNoop(ctx)) return;
+      ctx.compact({ customInstructions: undefined });
+      return;
+    }
+
+    // S16 LIVE trim: collapse the compacted region to a summary + recent anchor.
+    // Non-destructive: pi keeps the real transcript; only this LLM call sees the
+    // trimmed window. We compute the cut on the engine view (pure, tested) then
+    // slice the ORIGINAL pi AgentMessage[] from that index (lossless alignment,
+    // mirroring dropCompactedRange) and prepend a user-role summary message.
+    // A build failure or unsafe cut returns nothing (no trim this call — the
+    // next context event retries). The anchor floor is read live from env (the
+    // config value is the cached default) so it can be tuned per-test / per-run
+    // without reloading the module.
+    try {
+      const anchorEnv = process.env.MEGACOMPACT_ANCHOR_USER_MESSAGES;
+      const anchorUserMessages = (anchorEnv != null && anchorEnv !== "" && Number.isFinite(Number(anchorEnv)))
+        ? Number(anchorEnv)
+        : config.anchorUserMessages;
+      const cut = computeLiveTrimCut(view, {
+        compactedFrom: ran.result.compactedFrom,
+        summary: ran.result.summary,
+        anchorUserMessages,
+      });
+      if (cut === null) return; // unsafe / below anchor floor — no trim this call
+      const summaryMsg = liveTrimSummaryMessage({
+        compactedFrom: ran.result.compactedFrom,
+        summary: ran.result.summary,
+        anchorUserMessages: config.anchorUserMessages,
+      });
+      // Synthesize a user-role AgentMessage carrying the compacted summary.
+      const summaryAgentMsg = {
+        role: "user" as const,
+        content: summaryMsg.text,
+        timestamp: Date.now(),
+      } as unknown as AgentMessage;
+      const recent = messages.slice(cut); // guardrails-allow PREVENT-PI-002: `cut` is the pre-sanitized `compactedFrom` produced by src/boundary.ts computeDropRange, so the preserved run begins on a toolPair-safe index.
+      runtime.snapshot(ctx);
+      return { messages: [summaryAgentMsg, ...recent] };
+    } catch {
+      return; // non-fatal: no trim this call; the next context event retries
+    }
   });
 
   // ---- Supply a DURABLE trim to pi's native compaction (Fix B) ----------