pi-mega-compact 0.4.27 → 0.5.0

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 } 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,9 +235,55 @@ export function registerEventHandlers(pi: ExtensionAPI, runtime: MegaRuntime, co
     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" 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) ----------

package/extensions/mega-pipeline.ts

@@ -12,9 +12,11 @@ import { sessionEntryToContextMessages } from "@earendil-works/pi-coding-agent";
 import type { AgentMessage } from "@earendil-works/pi-agent-core";
 import { compactSession } from "../src/engine.js";
 import type { EngineMessage } from "../src/types.js";
-import { recallAndInline } from "../src/recall.js";
+import { recallAndInline, recallAndInlineAsync, formatRecallBlock, type RecallInjectResult } 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 {
   MegaRuntime,
   C,
@@ -76,6 +78,10 @@ function doCompact(
   runtime: MegaRuntime,
 ): RunCompactResult {
   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,
@@ -147,6 +153,28 @@ function doCompact(
     /* 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, {
@@ -234,6 +262,90 @@ function doCompact(
   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: ExtensionContext): boolean {
+  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 as { role?: string }).role !== "toolResult") isCut = true;
+        const c = (m as { content?: unknown }).content;
+        const text =
+          typeof c === "string" ? c
+          : Array.isArray(c)
+            ? (c as { text?: string }[]).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(): number {
+  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)
@@ -278,6 +390,72 @@ export function doRecall(
   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: MegaRuntime,
+  config: MegaConfig,
+  ctx: ExtensionContext,
+  query: string,
+  source: "resume" | "command",
+  opts: { crossRepo?: boolean } = {},
+): Promise<RecallInjectResult> {
+  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/extensions/mega-runtime.ts

@@ -79,12 +79,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: string | undefined;
+  // S21: memory recall block, parallel to pendingRecallBlock. Same one-shot
+  // semantics; composed with the checkpoint block in before_agent_start.
+  pendingMemoryRecallBlock: string | undefined;
   statusKey: string | undefined; // 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
@@ -103,6 +108,11 @@ export class MegaRuntime {
   readonly 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;
@@ -364,6 +374,11 @@ 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(): string {
+    return this.currentStateDir;
+  }
+
   /** Build the sync onTier callback that paints the live per-tier trace. */
   makeTierCallback(ctx: ExtensionContext): (ev: { tier: "L0" | "L1" | "L2" | "new"; status: "scanning" | "deduped" | "passed" | "stored"; detail?: string }) => void {
     const order: Array<"L0" | "L1" | "L2" | "new"> = ["L0", "L1", "L2", "new"];

package/extensions/mega-trim.test.ts

@@ -0,0 +1,64 @@
+/**
+ * mega-trim.test.ts — tests for the live compaction view builder (S16).
+ */
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { buildLiveTrimmedView } from "./mega-trim.js";
+import type { EngineMessage } from "../src/types.js";
+
+function m(role: EngineMessage["role"], text: string, extra: Partial<EngineMessage> = {}): EngineMessage {
+  return { role, text, toolName: undefined, input: undefined, output: undefined, ...extra };
+}
+
+test("buildLiveTrimmedView: prepends a compacted summary and keeps the recent anchor", () => {
+  const view: EngineMessage[] = [
+    m("user", "old request one"), m("assistant", "old answer one"),
+    m("user", "old request two"), m("assistant", "old answer two"),
+    m("user", "recent keep me"), m("assistant", "recent keep me too"),
+  ];
+  // Compacted region = first 4; recent anchor = last 2.
+  const result = buildLiveTrimmedView(view, {
+    compactedFrom: 4,        // index where the compacted region ends
+    summary: "<summary>earlier work on old requests</summary>",
+    anchorUserMessages: 1,
+  });
+  // First element is the injected compacted summary as a user-role message.
+  assert.equal(result[0].role, "user");
+  assert.ok(String(result[0].text).includes("earlier work on old requests"));
+  // Recent anchor preserved in order, no older messages leak through.
+  assert.equal(result.length, 1 + 2, "summary + 2 recent");
+  assert.ok(result.slice(1).some((x) => String(x.text).includes("recent keep me")));
+});
+
+test("buildLiveTrimmedView: empty summary returns the original view unchanged", () => {
+  const view = [m("user", "x"), m("assistant", "y")];
+  const result = buildLiveTrimmedView(view, { compactedFrom: 0, summary: "", anchorUserMessages: 1 });
+  assert.deepEqual(result, view);
+});
+
+test("buildLiveTrimmedView: never splits a toolCall/toolResult pair (PREVENT-PI-002)", () => {
+  const view: EngineMessage[] = [
+    m("user", "q"), m("assistant", "calls tool", { toolName: "read" }), m("tool", "result"),
+    m("user", "keep"), m("assistant", "ok"),
+  ];
+  // cut=3 would start the preserved run on the orphaned tool result at index 2 —
+  // the builder must snap back so the toolCall/toolResult pair is not split.
+  const result = buildLiveTrimmedView(view, { compactedFrom: 3, summary: "<summary>s</summary>", anchorUserMessages: 1 });
+  // The tool result must never appear preserved WITHOUT its preceding toolCall.
+  const preserved = result.slice(1);
+  const hasToolResult = preserved.some((x) => x.role === "tool");
+  const hasToolCall = preserved.some((x) => x.role === "assistant" && x.toolName);
+  // Either the tool pair is kept together, or the tool result is dropped into
+  // the compacted region — it is never left orphaned.
+  assert.ok(!(hasToolResult && !hasToolCall), "no orphaned tool result in the preserved run");
+});
+
+test("buildLiveTrimmedView: honors the anchor floor (PREVENT-PI-001)", () => {
+  // cut would leave zero user messages in the anchor — must skip the trim.
+  const view: EngineMessage[] = [
+    m("user", "old q"), m("assistant", "old a"),
+    m("assistant", "only assistant kept"),
+  ];
+  const result = buildLiveTrimmedView(view, { compactedFrom: 2, summary: "<summary>s</summary>", anchorUserMessages: 1 });
+  assert.deepEqual(result, view, "below anchor floor → no trim this call");
+});

package/extensions/mega-trim.ts

@@ -0,0 +1,75 @@
+/**
+ * mega-trim.ts — the LIVE compaction view builder (S16).
+ *
+ * Produces the message list returned from the `context` event so the model sees
+ * a compacted window every LLM call WITHOUT aborting the turn (ctx.compact()
+ * would abort; the context-event return feeds pi's transformContext per call).
+ *
+ * Shape: [compactSummaryMessage, ...recentAnchor]. The compacted region
+ * [0, compactedFrom) is collapsed to a single user-role summary; the recent
+ * anchor [compactedFrom, end) is kept verbatim. Honors PREVENT-PI-002 (never
+ * splits a toolCall/toolResult pair) by snapping compactedFrom back to a
+ * boundary-safe index, and PREVENT-PI-001 (anchor floor) via the anchor knob.
+ *
+ * Pure + pi-agnostic: takes EngineMessage[], returns EngineMessage[]. No pi
+ * imports. Non-destructive: the caller still owns the real messages.
+ */
+import type { EngineMessage } from "../src/types.js";
+import { isBoundarySafe } from "../src/boundary.js";
+import { formatCompactSummary } from "../src/compact.js";
+
+export interface BuildLiveTrimViewOpts {
+  /** Index where the compacted region ends (the recent anchor starts here). */
+  compactedFrom: number;
+  /** The compacted-region summary text (already generated by runCompact). */
+  summary: string;
+  /** Min recent user messages to keep as the anchor (PREVENT-PI-001). */
+  anchorUserMessages: number;
+}
+
+/**
+ * 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: EngineMessage[], opts: BuildLiveTrimViewOpts): number | null {
+  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: BuildLiveTrimViewOpts): EngineMessage {
+  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: EngineMessage[],
+  opts: BuildLiveTrimViewOpts,
+): EngineMessage[] {
+  const cut = computeLiveTrimCut(view, opts);
+  if (cut === null) return view;
+  const recent = view.slice(cut);
+  const summaryMsg = liveTrimSummaryMessage(opts);
+  return [summaryMsg, ...recent];
+}