pi-mega-compact 0.4.27 → 0.5.0

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 } 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,9 +228,57 @@ export function registerEventHandlers(pi, runtime, config) {
         const ran = runCompact(pi, runtime, config, ctx, messages, { compressionPressure: pressure });
         if (ran.skipped)
             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",
+                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

package/dist/extensions/mega-pipeline.js

@@ -8,9 +8,11 @@
  */
 import { sessionEntryToContextMessages } from "@earendil-works/pi-coding-agent";
 import { compactSession } from "../src/engine.js";
-import { recallAndInline } from "../src/recall.js";
+import { recallAndInline, recallAndInlineAsync, formatRecallBlock } from "../src/recall.js";
 import { normalizeSessionId } from "../src/store.js";
+import { estimateBlockTokens } from "../src/tokens.js";
 import { touchSession, logDaily } from "../src/store/sqlite.js";
+import { consolidateMemories } from "../src/memory.js";
 import { C, MARKER_TYPE, } from "./mega-runtime.js";
 import { resolveRepoRoot, preserveRecentForPressure } from "./mega-config.js";
 import { runRaptor } from "../src/dedup/raptor/index.js";
@@ -41,6 +43,10 @@ export function runCompact(pi, runtime, config, ctx, messages, opts = {}) {
 }
 function doCompact(view, keepFrom, opts, sid, config, pi, ctx, runtime) {
     runtime.pulsing = true; // animate the status line while the (sync) pipeline runs
+    // S21.2: reset the per-compaction memory-op counter so the post-compact
+    // consolidate pass only fires when memory rows actually changed during the
+    // compaction window (turn_end → auto-review may have written some).
+    runtime.memoriesTouchedThisCompaction = 0;
     const result = compactSession({
         sessionId: sid,
         messages: view,
@@ -107,6 +113,26 @@ function doCompact(view, keepFrom, opts, sid, config, pi, ctx, runtime) {
     catch {
         /* non-fatal: stats bookkeeping only */
     }
+    // S21.2: best-effort consolidation of near-duplicate memories for this repo.
+    // Runs after the per-repo stats touch so `consolidateMemories` can use the
+    // same stateDir. Non-fatal — a failed consolidate never blocks a compaction.
+    // Only runs when new memory ops landed in this pass (otherwise the prior
+    // compaction's consolidate already had its shot — re-running would just
+    // touch every row again with no merges).
+    if (!result.deduped && runtime.memoriesTouchedThisCompaction > 0) {
+        try {
+            const root = resolveRepoRoot(ctx.cwd);
+            void consolidateMemories(runtime.currentStateDir, root).then((n) => {
+                if (n > 0)
+                    runtime.pushTicker(`${C.green}∫${C.reset} consolidated ${n} memory dup${n === 1 ? "" : "s"}`);
+            }, () => {
+                /* swallow: consolidate failures must never surface to the user */
+            });
+        }
+        catch {
+            /* non-fatal */
+        }
+    }
     // Sentinel marker: a non-LLM bookkeeping entry so subsequent triggers can
     // skip re-vectorizing an already-compacted region (zero token cost).
     pi.appendEntry(MARKER_TYPE, {
@@ -181,6 +207,100 @@ function doCompact(view, keepFrom, opts, sid, config, pi, ctx, runtime) {
     runtime.snapshot(ctx);
     return { skipped: false, result, keepFrom, saved };
 }
+/**
+ * Predict whether pi's `ctx.compact()` would throw a no-op error — "Already
+ * compacted" or "Nothing to compact (session too small)" — so the auto-trigger
+ * can SKIP the call instead of surfacing a hard, user-facing error.
+ *
+ * Why we can't intercept or suppress it: pi's public `compact()` computes
+ * `prepareCompaction()` and throws *before* it emits `session_before_compact`,
+ * so our handler there never runs on the no-op path. And `ctx.compact()`'s
+ * `onError` callback fires only AFTER pi has already emitted a `compaction_end`
+ * event carrying the error message (which the interactive UI renders) — so
+ * `onError` cannot mute it either. The only robust fix is to not call
+ * `ctx.compact()` when pi would no-op. (pi's own `_runAutoCompaction` path is
+ * silent on this same condition; the public path we're forced through is the
+ * one that throws.)
+ *
+ * Skipping is correct, not a compromise: by the time this runs, `runCompact()`
+ * has already persisted the recall checkpoint (Path A). The durable on-disk
+ * trim is only useful when pi can actually summarize a region; a transcript
+ * under pi's `keepRecentTokens` budget is small enough that reloading it on
+ * resume isn't a token-growth problem, so the durable trim is unnecessary
+ * there anyway.
+ *
+ * Mirrors pi's `prepareCompaction()` return-undefined conditions (compaction.js):
+ *  (1) last entry is a compaction      → "Already compacted"
+ *  (2) <2 cut-point messages since the last compaction → nothing to summarize
+ *      (a cut point = any non-toolResult message — user/assistant/bash/custom/
+ *       branchSummary/compactionSummary — matching pi's isCutPointMessage)
+ *  (3) transcript tokens since the last compaction < keepRecentTokens → pi
+ *      keeps everything → nothing to summarize
+ * `keepRecentTokens` isn't readable from the extension API, so (3) uses the pi
+ * default (20000) as a conservative floor; raise it via
+ * `MEGACOMPACT_DURABLE_TRIM_FLOOR` if you raise pi's `compact.keepRecentTokens`.
+ *
+ * Best-effort: on any read error returns true (skip) — skipping a durable trim
+ * is always safe; calling `ctx.compact()` on a no-op throws to the user.
+ */
+export function piCompactWouldNoop(ctx) {
+    try {
+        const branch = ctx.sessionManager.getBranch();
+        if (branch.length === 0)
+            return true;
+        // (1) already compacted — pi throws "Already compacted"
+        if (branch[branch.length - 1].type === "compaction")
+            return true;
+        // boundaryStart = index just after the most recent compaction entry (or 0)
+        let boundaryStart = 0;
+        for (let i = branch.length - 1; i >= 0; i--) {
+            if (branch[i].type === "compaction") {
+                boundaryStart = i + 1;
+                break;
+            }
+        }
+        let cutPoints = 0;
+        let tokens = 0;
+        for (let i = boundaryStart; i < branch.length; i++) {
+            const e = branch[i];
+            if (e.type === "compaction")
+                continue;
+            let isCut = false;
+            for (const m of sessionEntryToContextMessages(e)) {
+                // pi's isCutPointMessage: every role except toolResult
+                if (m.role !== "toolResult")
+                    isCut = true;
+                const c = m.content;
+                const text = typeof c === "string" ? c
+                    : Array.isArray(c)
+                        ? c.map((b) => b?.text ?? "").join(" ")
+                        : "";
+                if (text)
+                    tokens += estimateBlockTokens(text);
+            }
+            if (isCut)
+                cutPoints++;
+        }
+        // (2) need >=2 cut points so the kept cut isn't the first message
+        if (cutPoints < 2)
+            return true;
+        // (3) transcript under pi's keepRecentTokens budget → pi keeps everything
+        if (tokens < durableTrimFloorTokens())
+            return true;
+        return false;
+    }
+    catch {
+        return true; // safe: skip the durable trim rather than risk a user-facing throw
+    }
+}
+/** pi's default keepRecentTokens (compaction settings). Override with
+ *  MEGACOMPACT_DURABLE_TRIM_FLOOR if you raise pi's compact.keepRecentTokens. */
+function durableTrimFloorTokens() {
+    const raw = process.env.MEGACOMPACT_DURABLE_TRIM_FLOOR;
+    if (raw !== undefined && Number.isFinite(Number(raw)))
+        return Number(raw);
+    return 20_000;
+}
 /**
  * Unified recall (Layer 5). The ONE path that injects. Returns the recall
  * result; callers decide whether to stage it for before_agent_start (resume)
@@ -215,6 +335,64 @@ export function doRecall(runtime, config, ctx, query, source) {
     }
     return result;
 }
+/**
+ * S17: async recall with optional cross-repo augmentation. Used on resume
+ * (session_start) and /mega-recall --cross-repo — NEVER from the mid-turn
+ * context handler (that stays sync). Runs the sync same-repo scan first; if it
+ * returns < config.autoInlineK hits AND crossRepo is enabled, awaits the PGlite
+ * HNSW cross-repo path and merges (source-labeled, deduped by checkpointId). The
+ * recallMaxTokens cap + windowDedupe apply to the merged set so cross-repo can
+ * never net-inflate the window. Cross-repo uses a stricter cosine floor
+ * (config.crossRepoCosine) than same-repo. Non-fatal: any async failure returns
+ * the same-repo result unchanged.
+ */
+export async function doRecallAsync(runtime, config, ctx, query, source, opts = {}) {
+    runtime.bindRepo(ctx.cwd);
+    const sid = normalizeSessionId(ctx.sessionManager.getSessionId());
+    const liveWindow = config.windowDedupe ? extractLiveWindow(ctx) : undefined;
+    // Sync same-repo first (fast, never blocks).
+    const sameRepo = recallAndInline({
+        sessionId: sid, query, limit: config.autoInlineK, source, skipInjected: true,
+        recallMaxTokens: config.recallMaxTokens, windowDedupe: config.windowDedupe,
+        liveWindow, dedupSim: config.dedupSim,
+    }, runtime.store);
+    if (!config.crossRepoEnabled || !opts.crossRepo)
+        return sameRepo;
+    if (sameRepo.toInject.length >= config.autoInlineK)
+        return sameRepo; // same-repo satisfied
+    // Augment: cross-repo HNSW (async) with the stricter floor. Non-fatal.
+    try {
+        const x = await recallAndInlineAsync({
+            sessionId: sid, query, limit: config.autoInlineK, source, skipInjected: true,
+            recallMaxTokens: config.recallMaxTokens, windowDedupe: config.windowDedupe,
+            liveWindow, dedupSim: config.crossRepoCosine, crossRepo: true,
+            globalIndexDir: process.env.MEGACOMPACT_INDEX_DIR,
+        }, runtime.store);
+        runtime.dashboard.event("recall-crossrepo", {
+            source, query: query.slice(0, 120), injected: x.toInject.length,
+            sourceRepos: x.toInject.map((h) => h.repoId).filter(Boolean),
+        });
+        // Merge, dedup by checkpointId, respect the same token cap by reformatting.
+        const seen = new Set(sameRepo.toInject.map((h) => h.checkpoint.checkpointId));
+        const merged = [...sameRepo.toInject];
+        for (const h of x.toInject) {
+            if (!seen.has(h.checkpoint.checkpointId)) {
+                merged.push(h);
+                seen.add(h.checkpoint.checkpointId);
+            }
+        }
+        const block = merged.length ? formatRecallBlock(merged) : "";
+        return {
+            toInject: merged,
+            report: merged.map((h) => `  • ${h.checkpoint.checkpointId}${h.repoId ? ` (from ${h.repoId.split("/").filter(Boolean).pop()})` : ""}`),
+            block,
+            empty: merged.length === 0,
+        };
+    }
+    catch {
+        return sameRepo; // cross-repo failure → same-repo only (non-fatal)
+    }
+}
 /**
  * Extract the live-window message texts from the session manager (Fix C),
  * for inline-dedupe of recalled checkpoints. Best-effort: returns [] on any

package/dist/extensions/mega-runtime.js

@@ -57,12 +57,17 @@ export class MegaRuntime {
         tokensSaved: 0,
     };
     debounceUntil = 0;
+    // S16: debounce for the agent_end resume nudge (avoid busy-loops).
+    resumeNudgeUntil = 0;
     // Agent tracking for real-time widget updates
     activeAgents = 0;
     currentTurn = 0;
     // Recall block produced by auto-inline (resume/branch) that the next
     // before_agent_start should prepend to the system prompt. Unset after use.
     pendingRecallBlock;
+    // S21: memory recall block, parallel to pendingRecallBlock. Same one-shot
+    // semantics; composed with the checkpoint block in before_agent_start.
+    pendingMemoryRecallBlock;
     statusKey; // current status text for dashboard
     // Active model/provider (for real cost estimation). Captured from ctx.model
     // on model_select + session_start; persisted to SQL so cost + the dashboard
@@ -81,6 +86,11 @@ export class MegaRuntime {
     TICKER_MAX = 5;
     // Pulsing status: set true while a compaction is in flight, cleared on result.
     pulsing = false;
+    // S21.2: set by `applyMemoryOps` when a memory add/replace/remove lands in
+    // the current compaction. The pipeline reads this after a successful compact
+    // to decide whether to fire `consolidateMemories` (skip the work entirely
+    // when no memory rows changed).
+    memoriesTouchedThisCompaction = 0;
     // Rolling "saved" goal for the progress bar — grows as we save more, so the
     // bar always has a meaningful denominator (never sits at 100% forever).
     savedGoal = 50_000;
@@ -343,6 +353,10 @@ export class MegaRuntime {
         }
         catch { /* non-fatal: cost estimation degrades to model-in-memory only */ }
     }
+    /** S21: state dir of the currently bound repo (where memories live). */
+    getStateDir() {
+        return this.currentStateDir;
+    }
     /** Build the sync onTier callback that paints the live per-tier trace. */
     makeTierCallback(ctx) {
         const order = ["L0", "L1", "L2", "new"];

package/dist/extensions/mega-trim.js

@@ -0,0 +1,48 @@
+import { isBoundarySafe } from "../src/boundary.js";
+import { formatCompactSummary } from "../src/compact.js";
+/**
+ * Compute the safe cut index for the live trim. Snaps `compactedFrom` back to a
+ * boundary-safe index (PREVENT-PI-002: never start the preserved run on an
+ * orphaned tool result), and enforces the anchor floor (PREVENT-PI-001: keep at
+ * least `anchorUserMessages` user-role messages). Returns `null` when no trim is
+ * safe this call (empty summary, unsafe boundary, or below the anchor floor) so
+ * the caller keeps the original view and retries on the next context event.
+ *
+ * Exposed separately from `buildLiveTrimmedView` so the context handler can map
+ * the cut back onto the original pi `AgentMessage[]` (lossless index alignment,
+ * mirroring `dropCompactedRange` in src/adapt.ts).
+ */
+export function computeLiveTrimCut(view, opts) {
+    if (!opts.summary || !opts.summary.trim())
+        return null;
+    let cut = opts.compactedFrom;
+    while (cut > 0 && !isBoundarySafe(view, cut))
+        cut--;
+    if (cut <= 0)
+        return null; // nothing safe to cut — keep everything this call
+    const recent = view.slice(cut);
+    const userCount = recent.filter((m) => m.role === "user").length;
+    if (userCount < opts.anchorUserMessages)
+        return null;
+    return cut;
+}
+/** The formatted compacted-region summary as a user-role engine message. */
+export function liveTrimSummaryMessage(opts) {
+    return {
+        role: "user",
+        text: formatCompactSummary(opts.summary),
+        toolName: undefined,
+        input: undefined,
+        output: undefined,
+    };
+}
+/** Build the live trimmed view. Returns the original view if summary is empty
+ *  or the boundary is unsafe (no trim this call — try next). Pure + tested. */
+export function buildLiveTrimmedView(view, opts) {
+    const cut = computeLiveTrimCut(view, opts);
+    if (cut === null)
+        return view;
+    const recent = view.slice(cut);
+    const summaryMsg = liveTrimSummaryMessage(opts);
+    return [summaryMsg, ...recent];
+}