pi-mega-compact 0.6.0 → 0.6.2

package/extensions/mega-compact.test.ts

@@ -448,6 +448,56 @@ test("explicit MEGACOMPACT_THRESHOLD_TOKENS overrides the tier", async () => {
   );
 });
 
+// ---- S24: memory review tied to pressure / compaction -----------------------
+// Build a decision-bearing session large enough to guarantee a real (non-skipped,
+// non-deduped) compaction. Each user turn contains a decision phrase
+// (/\bactually\b/i, /\bwe (?:use|decided)\b/i) so reviewConversation yields ops.
+function decisionSession(): AgentMessage[] {
+  const out: AgentMessage[] = [];
+  for (let i = 0; i < 14; i++) {
+    out.push({ role: "user", content: `actually we decided to use approach ${i} for module ${i}`, timestamp: i } as unknown as AgentMessage);
+    out.push({ role: "assistant", content: [{ type: "toolCall", name: "Edit", id: `c${i}`, arguments: {} }], api: "anthropic-messages", provider: "anthropic", model: "m", usage: { inputTokens: 1, outputTokens: 1, cacheReadTokens: 0, cacheWriteTokens: 0 }, stopReason: "tool_use", timestamp: i } as unknown as AgentMessage);
+    out.push({ role: "toolResult", content: [{ type: "text", text: `edited module ${i}` }], toolCallId: `c${i}`, toolName: "Edit", isError: false, timestamp: i } as unknown as AgentMessage);
+  }
+  return out;
+}
+
+test("S24: high pressure triggers a memory review on compaction", async () => {
+  const h = harness();
+  // Force a real (non-legacy) compaction at full pressure → pressureBand "mega",
+  // which must fire the shared runMemoryReview on compact (review-on-compact).
+  process.env.MEGACOMPACT_LEGACY_DURABLE_TRIM = "false";
+  try {
+    const messages = decisionSession();
+    const ctx = h.ctx({ getContextUsage: () => ({ tokens: 200000, contextWindow: 200000, percent: 100 }) });
+    await h.fire("context", { type: "context", messages }, ctx);
+    // review-on-compact runs as a fire-and-forget async (doCompact is sync), so
+    // let the microtask/macrotask queue drain before asserting the side effect.
+    await new Promise((r) => setTimeout(r, 20));
+    const { listMemories, listCheckpoints } = await import("../src/store/sqlite.js");
+    // A checkpoint must have been persisted (proves compaction ran, not skipped).
+    assert.ok(listCheckpoints("sess_ext_001", h.stateDir).length > 0, "checkpoint persisted to local vector db");
+    // The just-compacted region is worth remembering, so durable memories must
+    // have been written to the SQLite store (review-on-compact path).
+    const mem = listMemories(null, 50, h.stateDir);
+    assert.ok(mem.length > 0, "memory review wrote durable memories on compact");
+  } finally {
+    delete process.env.MEGACOMPACT_LEGACY_DURABLE_TRIM;
+  }
+});
+
+test("S24: /mega-status reports the live pressure band + %", async () => {
+  const h = harness();
+  // Populate the runtime's live context first (a context event sets
+  // lastCtxTokens/lastCtxPercent), then read /mega-status. At 100% usage the live
+  // band must read "mega" and pressure must report 100%.
+  const ctx = h.ctx({ getContextUsage: () => ({ tokens: 200000, contextWindow: 200000, percent: 100 }) });
+  await h.fire("context", { type: "context", messages: h.session }, ctx);
+  await h.commands["mega-status"].handler("", ctx);
+  assert.ok(h.notifies.some((n) => n.includes("tier=mega (live)")), "live band reported as mega at 100% pressure");
+  assert.ok(h.notifies.some((n) => n.includes("pressure=100%")), "live pressure % reported");
+});
+
 // ---- /dashboard commands ----------------------------------------------------
 test("/dashboard-status reports no server when pid file missing", async () => {
   // Private base so this asserts "no server" on a range nothing else uses,

package/extensions/mega-conflict-cmds.ts

@@ -11,6 +11,8 @@ import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-a
 import { detectConflicts, type ConflictReport } from "./conflict-scan.js";
 import { addMemory, listMemories, searchMemories, recallMemory, type MemoryRecord } from "../src/store/sqlite.js";
 import { resolveRepoRoot } from "./mega-config.js";
+import { defaultEmbedder } from "../src/embedder.js";
+import { upsertMemoryEmbedding } from "../src/store/memoryIndex.js";
 import { MegaRuntime } from "./mega-runtime.js";
 
 /** Run the conflict scan and format a human-readable report. */
@@ -82,6 +84,13 @@ export function registerConflictCommands(pi: ExtensionAPI, runtime: MegaRuntime)
         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);
+        // S24: mirror into the cross-repo memory index (fire-and-forget).
+        try {
+          const vec = defaultEmbedder().embed(content);
+          void upsertMemoryEmbedding(repo, id, content, vec);
+        } catch {
+          /* non-fatal */
+        }
         ctx.ui.notify(`[mega-memory] saved #${id} to ${repo.split(/[\\/]/).pop()}`);
         return;
       }
@@ -151,6 +160,12 @@ export function registerConflictCommands(pi: ExtensionAPI, runtime: MegaRuntime)
         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);
+        try {
+          const vec = defaultEmbedder().embed(content);
+          void upsertMemoryEmbedding(repo, id, content, vec);
+        } catch {
+          /* non-fatal */
+        }
         ctx.ui.notify(`[/m] saved #${id} to ${repo.split(/[\\/]/).pop()}`);
         return;
       }

package/extensions/mega-events.ts

@@ -13,14 +13,24 @@ 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, doRecallAsync, piCompactWouldNoop } from "./mega-pipeline.js";
+import { runCompact, doRecall, doRecallAsync, piCompactWouldNoop, runMemoryReview } 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, memoryReviewCadence, type MegaConfig } from "./mega-config.js";
 
+/**
+ * DIAG accessor for the headless test harness: the most recently constructed
+ * MegaRuntime, so a test that loads the compiled extension via its default
+ * export can read diag counters (diagLiveTrimFires / diagBeforeCompactFires /
+ * diagBeforeCompactSupplied / diagAgentEndIdle) after firing synthetic events.
+ * No-op in production — nothing reads this outside tests.
+ */
+export let lastRuntime: MegaRuntime | undefined;
+
 /** Register all pi lifecycle event handlers. */
 export function registerEventHandlers(pi: ExtensionAPI, runtime: MegaRuntime, config: MegaConfig): void {
+  lastRuntime = runtime;
   // ---- Session lifecycle (state reset points) -------------------------------
   // Capture model/provider whenever it changes (drives real cost estimation).
   pi.on("model_select", async (_event, ctx) => {
@@ -61,6 +71,8 @@ export function registerEventHandlers(pi: ExtensionAPI, runtime: MegaRuntime, co
       try {
         const mr = await recallMemoriesAndInline({
           query, stateDir: runtime.getStateDir(), limit: 5,
+          crossRepo: config.crossRepoEnabled,
+          crossRepoCosine: config.crossRepoCosine,
         });
         if (!mr.empty) runtime.pendingMemoryRecallBlock = mr.block;
       } catch (err) {
@@ -86,7 +98,7 @@ export function registerEventHandlers(pi: ExtensionAPI, runtime: MegaRuntime, co
         }
         // S21: parallel memory recall. Trigram embedder is sub-ms; await is fine.
         try {
-          const mr = await recallMemoriesAndInline({ query, stateDir: runtime.getStateDir(), limit: 5 });
+          const mr = await recallMemoriesAndInline({ query, stateDir: runtime.getStateDir(), limit: 5, crossRepo: config.crossRepoEnabled, crossRepoCosine: config.crossRepoCosine });
           if (!mr.empty) runtime.pendingMemoryRecallBlock = mr.block;
         } catch (err) {
           runtime.logger.warn("memory-recall skipped", { err: String(err) });
@@ -143,6 +155,46 @@ export function registerEventHandlers(pi: ExtensionAPI, runtime: MegaRuntime, co
         const idle = ctx.isIdle?.() ?? true;
         const queued = ctx.hasPendingMessages?.() ?? false;
         const now = Date.now();
+        // DIAG (team-run relief): surface whether the agent is idle + over
+        // threshold at agent_end so we can see if a mid-run durable-trim trigger
+        // *should* have fired but didn't.
+        const overThreshold = (runtime.lastCtxTokens ?? 0) >= config.thresholdTokens;
+        runtime.diagAgentEndIdle++;
+        runtime.logger.info("agent-end-idle", {
+          sessionId: runtime.rt.sessionId,
+          idle,
+          queued,
+          overThreshold,
+          ctxPct: runtime.lastCtxPercent,
+          ctxTokens: runtime.lastCtxTokens,
+          thresholdTokens: config.thresholdTokens,
+          wouldNudge: idle && queued && now >= runtime.resumeNudgeUntil,
+        });
+        // S16+S24: MID-RUN DURABLE TRIM. During a long team run (sub-agents),
+        // pi's native durable compaction only fires from _checkCompaction at
+        // PARENT settle (agent-session.js:760/844), so the on-disk transcript +
+        // context meter balloon to ~150k and never relieve until the very end
+        // ("compacts but doesn't resume"). agent_end with activeAgents===0 is a
+        // SAFE, settled point: calling ctx.compact() here does NOT abort an
+        // in-flight turn (the S16 danger is only mid-turn). ctx.compact() runs
+        // pi's flow, which fires our session_before_compact handler to supply
+        // the durable trim (truncates the transcript from firstKeptEntryId).
+        // Guarded three ways: only when truly idle + over threshold, only when
+        // pi would actually compact (piCompactWouldNoop skips the user-facing
+        // no-op throw), and debounced (one durable trim per 2s) to avoid
+        // thrashing the transcript while sub-agents keep settling.
+        if (idle && overThreshold && now >= runtime.debounceUntil) {
+          if (!piCompactWouldNoop(ctx)) {
+            runtime.debounceUntil = now + 2000;
+            runtime.diagAgentEndDurable++;
+            runtime.logger.info("agent-end-durable-trigger", {
+              sessionId: runtime.rt.sessionId,
+              ctxTokens: runtime.lastCtxTokens,
+              thresholdTokens: config.thresholdTokens,
+            });
+            ctx.compact({ customInstructions: undefined }); // guardrails-allow PREVENT-PI-004: local ctx.compact() — no network; agent settled so no in-flight abort
+          }
+        }
         if (idle && queued && now >= runtime.resumeNudgeUntil) {
           runtime.resumeNudgeUntil = now + 30_000;
           pi.sendUserMessage("[mega-compact] continue from the compacted context above.");
@@ -172,22 +224,13 @@ export function registerEventHandlers(pi: ExtensionAPI, runtime: MegaRuntime, co
     if (config.memoryAutoReview && runtime.currentTurn > 0) {
       const cadence = memoryReviewCadence(runtime.pressureBand, config.memoryReviewInterval);
       if (runtime.currentTurn % cadence === 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 */
-        }
+        // S20+S24: review the conversation and persist durable memories. The
+        // cadence scales with pressure (memoryReviewCadence): as context fills,
+        // the conversation is reviewed more often so memories keep pace with
+        // faster churn. Shared runMemoryReview body (also used on compact).
+        const entries = ctx.sessionManager.getEntries();
+        const view = runtime.engineView(entries.flatMap((e: any) => (e.message ? [e.message] : [])));
+        await runMemoryReview(runtime, view, "turn");
       }
     }
   });
@@ -224,21 +267,21 @@ export function registerEventHandlers(pi: ExtensionAPI, runtime: MegaRuntime, co
       Math.round((pct / 100) * (usage?.contextWindow ?? 0));
 
     // FAST GATE: token-based (tier threshold), not percentage-based.
-    if (currentTokens < config.thresholdTokens) return;
+    if (currentTokens < config.thresholdTokens) { runtime.diagCtxFastGate++; return; }
 
     const check = autoCompactCheck(currentTokens, config.thresholdTokens); // SERVER-STYLE CONFIRM (local)
-    if (!check.shouldCompact) return;
+    if (!check.shouldCompact) { runtime.diagCtxNoCompact++; return; }
 
     // Debounce so we don't fire on every context event past threshold.
     const now = Date.now();
-    if (now < runtime.debounceUntil) return;
+    if (now < runtime.debounceUntil) { runtime.diagCtxDebounce++; return; }
     runtime.debounceUntil = now + 2000;
 
     // Adaptive compression (Fix E): scale compression strength + keepFrom depth
     // with how close we are to the model context limit.
     const pressure = pressureFromPct(pct);
     const ran = runCompact(pi, runtime, config, ctx, messages, { compressionPressure: pressure });
-    if (ran.skipped) return;
+    if (ran.skipped) { runtime.diagCtxRunSkipped++; return; }
 
     // 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.
@@ -271,7 +314,16 @@ export function registerEventHandlers(pi: ExtensionAPI, runtime: MegaRuntime, co
         summary: ran.result.summary,
         anchorUserMessages,
       });
-      if (cut === null) return; // unsafe / below anchor floor — no trim this call
+      if (cut === null) {
+        runtime.diagCtxCutNull++;
+        runtime.logger.info("live-trim-skip", {
+          sessionId: runtime.rt.sessionId,
+          compactedFrom: ran.result.compactedFrom,
+          viewLen: view.length,
+          anchorUserMessages,
+        });
+        return; // unsafe / below anchor floor — no trim this call
+      }
       const summaryMsg = liveTrimSummaryMessage({
         compactedFrom: ran.result.compactedFrom,
         summary: ran.result.summary,
@@ -285,8 +337,22 @@ export function registerEventHandlers(pi: ExtensionAPI, runtime: MegaRuntime, co
       } 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);
+      // DIAG (team-run relief): confirm the live trim actually fires + how big
+      // the window still is. The return is non-durable (per-LLM-call only), so
+      // this is the signal that the model is being fed a compacted view while
+      // the on-disk transcript + context meter keep growing.
+      runtime.diagLiveTrimFires++;
+      runtime.logger.info("live-trim", {
+        sessionId: runtime.rt.sessionId,
+        inputMsgs: messages.length,
+        outputMsgs: recent.length + 1,
+        compactedFrom: cut,
+        ctxPct: pct,
+        ctxTokens: usage?.tokens ?? null,
+      });
       return { messages: [summaryAgentMsg, ...recent] };
     } catch {
+      runtime.diagCtxThrown++;
       return; // non-fatal: no trim this call; the next context event retries
     }
   });
@@ -299,10 +365,25 @@ export function registerEventHandlers(pi: ExtensionAPI, runtime: MegaRuntime, co
   // there is no full-reload + additive recall inflation.
   pi.on("session_before_compact", async (event: SessionBeforeCompactEvent, ctx: ExtensionContext) => {
     runtime.resetRuntime(ctx.sessionManager.getSessionId());
+    // DIAG (team-run relief): this is the ONLY durable-trim entry point. Log
+    // every fire + whether we supplied a compaction (truncates transcript) or
+    // fell through to {} (pi runs its own). If this is sparse during a team
+    // run, the durable trim is firing too late (only at parent settle).
+    const prep = event.preparation;
+    runtime.diagBeforeCompactFires++;
+    runtime.logger.info("before-compact-entry", {
+      sessionId: runtime.rt.sessionId,
+      reason: event.reason,
+      hasPrep: !!prep,
+      msgsToSummarize: prep?.messagesToSummarize?.length ?? 0,
+      firstKeptEntryId: prep?.firstKeptEntryId ?? null,
+      activeAgents: runtime.activeAgents,
+    });
     if (!config.auto) return {}; // let pi run its own native compaction
     try {
       const result = driveNativeCompaction(event, runtime, config);
       if (result) {
+        runtime.diagBeforeCompactSupplied++;
         runtime.logger.info("native-compact", {
           sessionId: runtime.rt.sessionId,
           firstKeptEntryId: result.compaction.firstKeptEntryId,

package/extensions/mega-pipeline.ts

@@ -31,6 +31,39 @@ export type RunCompactResult =
   | { skipped: true }
   | { skipped: false; result: ReturnType<typeof compactSession>; keepFrom: number; saved: number };
 
+/**
+ * Review the live conversation and persist durable memories (S20+S24). Shared by
+ * the pressure-scaled turn-end cadence (mega-events.ts) AND review-on-compact
+ * (below) so both paths run the identical review body. Best-effort + non-fatal:
+ * a review failure is swallowed and never breaks the caller. On success, the
+ * number of applied ops is returned so callers can feed the consolidation gate.
+ *
+ * @param view the engine message view to review (caller builds it)
+ * @param label a short source tag for the ticker line (e.g. "pressure" / "turn")
+ */
+export async function runMemoryReview(
+  runtime: MegaRuntime,
+  view: ReturnType<MegaRuntime["engineView"]>,
+  label: string,
+): Promise<number> {
+  try {
+    const { reviewConversation } = await import("../src/memory.js");
+    const { applyMemoryOps } = await import("../src/memoryOps.js");
+    const ops = reviewConversation(view, []);
+    if (ops.length) {
+      await applyMemoryOps(ops, runtime.currentStateDir);
+      // S21.2: ops landed — the compaction path reads this counter and fires
+      // `consolidateMemories` only when > 0.
+      runtime.memoriesTouchedThisCompaction += ops.length;
+      runtime.pushTicker(`${C.green}🧠${C.reset} reviewed ${ops.length} memory op${ops.length === 1 ? "" : "s"} (${label})`);
+    }
+    return ops.length;
+  } catch {
+    /* non-fatal — auto-review must never break the turn loop / compaction */
+    return 0;
+  }
+}
+
 /** Run the full compaction pipeline and persist a checkpoint. Returns the result. */
 export function runCompact(
   pi: ExtensionAPI,
@@ -177,24 +210,11 @@ function doCompact(
 
   // S24 review-on-compact: when pressure is high, the just-compacted region is
   // exactly the context worth remembering, so review it immediately rather than
-  // waiting for the next turn-cadence tick. Fire-and-forget (doCompact is sync):
-  // best-effort + non-fatal, paralleling the consolidate pass above. Only fires
-  // above the `high` band so low-pressure compactions don't pay the review cost.
+  // waiting for the next turn-cadence tick. Uses the shared runMemoryReview
+  // helper (fire-and-forget; doCompact is sync). Best-effort + non-fatal. Only
+  // fires above the `high` band so low-pressure compactions don't pay the cost.
   if (!result.deduped && config.memoryAutoReview && runtime.pressureBand !== "low" && runtime.pressureBand !== "medium") {
-    void (async () => {
-      try {
-        const { reviewConversation } = await import("../src/memory.js");
-        const { applyMemoryOps } = await import("../src/memoryOps.js");
-        const ops = reviewConversation(view, []);
-        if (ops.length) {
-          await applyMemoryOps(ops, runtime.currentStateDir);
-          runtime.memoriesTouchedThisCompaction += ops.length;
-          runtime.pushTicker(`${C.green}🧠${C.reset} reviewed ${ops.length} memory op${ops.length === 1 ? "" : "s"} (pressure)`);
-        }
-      } catch {
-        /* non-fatal — review-on-compact must never break the compaction */
-      }
-    })();
+    void runMemoryReview(runtime, view, "pressure");
   }
 
   // Sentinel marker: a non-LLM bookkeeping entry so subsequent triggers can

package/extensions/mega-runtime.ts

@@ -143,6 +143,27 @@ export class MegaRuntime {
   lastCtxPercent: number | null = null;
   lastCtxWindow = 0;
 
+  /**
+   * DIAG counters for the "team run doesn't relieve context" investigation.
+   * Plain integers, incremented at the three compaction decision points. They
+   * let a headless test drive the real event handlers and assert the firing
+   * cadence without scraping log files. Inert in production (the live-trim and
+   * before-compact probes also emit logger.info, but these counters are always
+   * updated and cost nothing).
+   */
+  diagLiveTrimFires = 0;     // context handler returned a trimmed view
+  diagBeforeCompactFires = 0; // session_before_compact handler entered
+  diagBeforeCompactSupplied = 0; // session_before_compact supplied our trim
+  diagAgentEndIdle = 0;       // agent_end with activeAgents===0
+  diagAgentEndDurable = 0;    // agent_end fired ctx.compact() (mid-run durable trim)
+  // Per-skip-path counters for the team-run diagnosis.
+  diagCtxFastGate = 0;        // returned at token fast-gate (below threshold)
+  diagCtxNoCompact = 0;       // autoCompactCheck().shouldCompact === false
+  diagCtxDebounce = 0;        // debounceUntil not yet elapsed
+  diagCtxRunSkipped = 0;      // runCompact() returned skipped
+  diagCtxCutNull = 0;         // computeLiveTrimCut returned null (anchor/boundary)
+  diagCtxThrown = 0;          // live-trim try threw (caught)
+
   /**
    * Live 0–1 pressure: how full the context window is relative to the compaction
    * threshold. Computed from the most recent context event the runtime already

package/extensions/mega-teamrun.test.ts

@@ -0,0 +1,164 @@
+/**
+ * mega-teamrun.test.ts — regression test for the "auto-compact runs but context
+ * never relieves during a team run (sub-agents)" bug.
+ *
+ * Loads the REAL compiled extension (extensions/mega-compact.js) through a
+ * faithful mock pi (mirrors mega-compact.test.ts's harness) and drives the
+ * exact event sequence a long team run produces:
+ *
+ *   agent_start -> context (over threshold) xN -> agent_end   (repeat x3)
+ *
+ * Asserts the TWO fixes:
+ *   1. live trim FIRES per-call (computeLiveTrimCut no longer returns null on
+ *      the anchor floor — was `cutNull`, liveTrimFires===0 before the fix).
+ *   2. the DURABLE trim fires at agent_end while idle + over threshold
+ *      (mid-run durable trigger), not only at parent settle.
+ *
+ * The mock ctx.compact() drives session_before_compact so we observe the
+ * durable truncation. Counters come from MegaRuntime.diag* (set behind the
+ * real handler code, inert in production).
+ *
+ * MEGACOMPACT_PGLITE_DISABLED keeps the run fast (no WASM index init).
+ */
+
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { createRequire } from "node:module";
+import { closeVectorIndex } from "../src/store/vectorIndex.js";
+import type { AgentMessage } from "@earendil-works/pi-agent-core";
+
+const require = createRequire(import.meta.url);
+const baseTmp = mkdtempSync(join(tmpdir(), "mc-team-"));
+process.env.MEGACOMPACT_INDEX_DIR = join(baseTmp, "index");
+process.env.MEGACOMPACT_PGLITE_DISABLED = "true"; // fast: skip WASM index
+let counter = 0;
+
+function harness() {
+  const stateDir = join(baseTmp, `run-${counter++}`);
+  process.env.MEGACOMPACT_STATE_DIR = stateDir;
+  process.env.MEGACOMPACT_DEBUG = "true";
+  process.env.MEGACOMPACT_THRESHOLD_TOKENS = "50";
+  process.env.MEGACOMPACT_FAST_GATE_PCT = "1";
+  process.env.MEGACOMPACT_ANCHOR_USER_MESSAGES = "1";
+  process.env.MEGACOMPACT_DURABLE_TRIM_FLOOR = "0"; // piCompactWouldNoop must not skip
+  process.env.MEGACOMPACT_MEMORY_AUTO_REVIEW = "false";
+  process.env.MEGACOMPACT_RAPTOR_ENABLED = "false";
+  delete process.env.MEGACOMPACT_LEGACY_DURABLE_TRIM;
+
+  const handlers: Record<string, Function> = {};
+  const compactCalls: any[] = [];
+
+  function msg(role: string, text: string, toolName?: string): AgentMessage {
+    if (role === "assistant" && toolName) {
+      return { role: "assistant", content: [{ type: "toolCall", name: toolName, id: "c1", arguments: {} }], api: "anthropic-messages", provider: "anthropic", model: "m", usage: { inputTokens: 1, outputTokens: 1, cacheReadTokens: 0, cacheWriteTokens: 0 }, stopReason: "tool_use", timestamp: 0 } as unknown as AgentMessage;
+    }
+    if (role === "toolResult" && toolName) {
+      return { role: "toolResult", content: [{ type: "text", text }], toolCallId: "c1", toolName, isError: false, timestamp: 0 } as unknown as AgentMessage;
+    }
+    return { role: "user", content: text, timestamp: 0 } as unknown as AgentMessage;
+  }
+
+  const session: AgentMessage[] = [];
+  for (let i = 0; i < 14; i++) {
+    session.push(msg("user", `actually we decided to use approach ${i} for module ${i}`));
+    session.push(msg("assistant", `edited module ${i}`, "Edit"));
+    session.push(msg("toolResult", `edited module ${i}`, "Edit"));
+  }
+
+  const toEntry = (m: AgentMessage, i: number): any => ({ type: "message", id: `e${i}`, parentId: null, timestamp: String(i), message: m });
+  const sessionManager = {
+    getSessionId: () => "sess_team_001",
+    getEntries: () => session.map(toEntry),
+    getBranch: () => session.map(toEntry),
+  };
+
+  function makeCtx(over: Partial<any> = {}) {
+    return {
+      ui: { setStatus: () => {}, notify: () => {}, select: () => {}, confirm: async () => true, input: async () => "", setWidget: () => {} },
+      mode: "tui" as any, hasUI: true, cwd: stateDir, sessionManager,
+      modelRegistry: {} as any, model: undefined, isIdle: () => true, isProjectTrusted: () => true,
+      signal: undefined, abort: () => {}, hasPendingMessages: () => false, shutdown: () => {},
+      getContextUsage: () => ({ tokens: 200000, contextWindow: 200000, percent: 100 }),
+      // Mock ctx.compact() runs pi's flow and fires session_before_compact.
+      compact: (opts?: any) => {
+        compactCalls.push(opts);
+        if (handlers["session_before_compact"]) {
+          return handlers["session_before_compact"](
+            { type: "session_before_compact", reason: "threshold", willRetry: false, signal: undefined, preparation: { firstKeptEntryId: "e2", messagesToSummarize: session.slice(0, 2), tokensBefore: 500 } } as any,
+            makeCtx(),
+          );
+        }
+        return undefined;
+      },
+      getSystemPrompt: () => "system base",
+      ...over,
+    } as any;
+  }
+
+  const pi = {
+    on: (ev: string, h: Function) => { handlers[ev] = h; },
+    registerCommand: () => {}, registerTool: () => {}, registerShortcut: () => {},
+    registerFlag: () => {}, getFlag: () => undefined, registerMessageRenderer: () => {},
+    registerEntryRenderer: () => {}, sendMessage: () => {}, sendUserMessage: () => {},
+    appendEntry: () => {}, setSessionName: () => {}, getSessionName: () => undefined,
+    setLabel: () => {}, exec: async () => ({ stdout: "", stderr: "", code: 0 }),
+    getActiveTools: () => [], getAllTools: () => [], setActiveTools: () => {},
+    getCommands: () => [], setModel: async () => false, getThinkingLevel: () => "off" as any,
+    setThinkingLevel: () => {},
+  } as any;
+
+  const mod = require("./mega-compact.js") as { default: (p: any) => void };
+  mod.default(pi);
+  const { lastRuntime } = require("./mega-events.js") as { lastRuntime: any };
+
+  const fire = (ev: string, event: any, ctx: any) => handlers[ev](event, ctx);
+  return {
+    stateDir, handlers, compactCalls, fire, ctx: makeCtx, session,
+    runtime: lastRuntime, // MegaRuntime with diag* counters
+    // Advance the debounce so agent_end (same instant) can trigger durable trim.
+    clearDebounce: () => { if (lastRuntime) lastRuntime.debounceUntil = 0; },
+  };
+}
+
+test("team run: live trim fires AND durable trim fires per sub-agent (relieves context)", async () => {
+  const h = harness();
+  const ctx = h.ctx();
+  for (let a = 0; a < 3; a++) {
+    await h.fire("agent_start", { type: "agent_start", messages: [] }, ctx);
+    for (let i = 0; i < 4; i++) {
+      await h.fire("context", { type: "context", messages: h.session }, ctx);
+    }
+    // Real team runs settle seconds after the last context event; mimic that
+    // so the 2s debounce has elapsed and the durable trigger can fire.
+    await new Promise((r) => setTimeout(r, 2100));
+    h.clearDebounce();
+    await h.fire("agent_end", { type: "agent_end", messages: [] }, ctx);
+  }
+  const rt = h.runtime;
+  // FIX 1: live trim must actually fire (was 0 — computeLiveTrimCut returned null).
+  assert.ok(rt.diagLiveTrimFires > 0, "live trim fires during the team run (anchor-floor fix)");
+  assert.equal(rt.diagCtxCutNull, 0, "no live-trim cut skipped on anchor floor");
+  // FIX 2: durable trim must fire at each agent_end (was 0 — only at parent settle).
+  assert.equal(rt.diagAgentEndDurable, 3, "mid-run durable trigger fired at each agent_end");
+  assert.equal(rt.diagBeforeCompactSupplied, 3, "our durable trim supplied 3x (context relieved)");
+  assert.ok(h.compactCalls.length >= 3, "ctx.compact() invoked for durable trim between sub-agents");
+});
+
+test("control: session_before_compact supplies a durable compaction (parent settles)", async () => {
+  const h = harness();
+  const res = await h.fire(
+    "session_before_compact",
+    { type: "session_before_compact", reason: "threshold", willRetry: false, signal: undefined, preparation: { firstKeptEntryId: "e2", messagesToSummarize: h.session.slice(0, 4), tokensBefore: 500 } } as any,
+    h.ctx(),
+  );
+  assert.ok(res?.compaction, "compaction result returned to pi");
+  assert.equal(res.compaction.firstKeptEntryId, "e2", "reuses pi's boundary (PREVENT-PI-002)");
+});
+
+test("cleanup", async () => {
+  await closeVectorIndex();
+  rmSync(baseTmp, { recursive: true, force: true });
+});

package/extensions/mega-trim.ts

@@ -46,7 +46,34 @@ export function computeLiveTrimCut(view: EngineMessage[], opts: BuildLiveTrimVie
   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;
+  // ANCHOR FLOOR (PREVENT-PI-001): the recent window must keep at least
+  // `anchorUserMessages` user messages. The original compactedFrom can land on a
+  // run that starts with fewer than that (e.g. the preserved region begins on a
+  // tool pair, or the session's tail is tool-heavy). Instead of bailing out and
+  // skipping the live trim entirely this call (which left the model fed a
+  // 150k-context window during long team runs), walk `cut` backward until the
+  // preserved run contains enough user messages — bounded by the boundary-safe
+  // constraint so we never split a tool pair. Falls back to null only when the
+  // whole view can't satisfy the floor (tiny sessions) — the next context event
+  // retries.
+  if (userCount < opts.anchorUserMessages) {
+    let c = cut;
+    while (c > 1) {
+      c--;
+      if (!isBoundarySafe(view, c)) continue;
+      const recentNow = view.slice(c);
+      const usersNow = recentNow.filter((m) => m.role === "user").length;
+      if (usersNow >= opts.anchorUserMessages) { cut = c; break; }
+    }
+    if (cut > 1) {
+      const finalRecent = view.slice(cut);
+      if (finalRecent.filter((m) => m.role === "user").length < opts.anchorUserMessages) {
+        return null; // cannot satisfy the floor without dropping too much — retry next call
+      }
+    } else {
+      return null;
+    }
+  }
   return cut;
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-mega-compact",
-  "version": "0.6.0",
+  "version": "0.6.2",
   "description": "Layered, local, vector-backed context compressor for pi — supersede/collapse/cluster compaction with deduped inline recall.",
   "type": "module",
   "license": "BSD-2-Clause",