pi-mega-compact 0.4.28 → 0.5.1

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

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

package/dist/extensions/mega-config.js

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

package/dist/extensions/mega-conflict-cmds.js

@@ -118,4 +118,83 @@ export function registerConflictCommands(pi, runtime) {
                 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, ctx) => {
+            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((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/dist/extensions/mega-dashboard-cmds.js

@@ -18,11 +18,13 @@ export function registerDashboardCommands(pi, runtime) {
     // when we fall back to the .ts source outside node_modules; false when using
     // 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() {
-        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)

package/dist/extensions/mega-events.js

@@ -10,8 +10,10 @@ import { normalizeSessionId } from "../src/store.js";
 import { autoCompactCheck } from "../src/compact.js";
 import { estimateSessionTokens } from "../src/tokens.js";
 import { 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 } from "./mega-config.js";
 /** Register all pi lifecycle event handlers. */
 export function registerEventHandlers(pi, runtime, config) {
@@ -25,6 +27,8 @@ export function registerEventHandlers(pi, runtime, config) {
         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
@@ -36,13 +40,29 @@ export function registerEventHandlers(pi, runtime, config) {
             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);
@@ -60,6 +80,15 @@ export function registerEventHandlers(pi, runtime, config) {
                     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 });
@@ -68,11 +97,14 @@ export function registerEventHandlers(pi, runtime, config) {
     // ---- 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)
+        const cpBlock = runtime.pendingRecallBlock;
+        const memBlock = runtime.pendingMemoryRecallBlock;
+        if (!cpBlock && !memBlock)
             return;
-        const block = runtime.pendingRecallBlock;
-        runtime.pendingRecallBlock = undefined; // one-shot: consume so we never double-inject
-        return { systemPrompt: `${event.systemPrompt}\n\n${block}` };
+        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) => {
         runtime.setStatus(ctx, undefined);
@@ -98,6 +130,24 @@ export function registerEventHandlers(pi, runtime, config) {
         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);
     });
     pi.on("turn_start", async (event, ctx) => {
@@ -108,16 +158,43 @@ export function registerEventHandlers(pi, runtime, config) {
     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) => (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, ctx) => {
         if (!config.auto)
             return;
@@ -151,17 +228,57 @@ export function registerEventHandlers(pi, runtime, config) {
         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))
+        // 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;
-        // 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 });
+        }
+        // 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",
+                content: summaryMsg.text,
+                timestamp: Date.now(),
+            };
+            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) ----------
     // We run the Trident pipeline to produce a compressed summary, then return