pi-mega-compact 0.6.1 → 0.6.3

package/README.md

@@ -6,28 +6,39 @@ sessions into a **local SQLite store** and offers **deduped inline recall** —
 running **locally inside the extension**, with **no remote MCP server** and
 **zero network calls at runtime** (PREVENT-PI-004).
 
-> **Current version:** `v0.6.1` — storage backend is **`node:sqlite`**
+> **Current version:** `v0.6.2` — storage backend is **`node:sqlite`**
 > (`DatabaseSync`, a Node ≥22.13 built-in), replacing the old `better-sqlite3`
 > native addon and the per-session gzipped JSON checkpoint files. **Zero native
 > build step, fully local, zero network at runtime.** Legacy
 > `.checkpoints.json.gz` snapshots are retained as disaster-recovery fallbacks
-> and auto-imported on first run. Cross-repo recall, durable memory, and a
-> localhost dashboard round out the continuity story.
+> and auto-imported on first run. The S24 line ties auto-compact, the tier
+> label, trim depth, and durable-memory review to one **unified pressure
+> signal**, adds a **cross-repo memory-RAG index**, and relieves context
+> **during team runs** (not just at the end).
 
 ---
 
 ## What this is (the 30-second version)
 
-pi's context window is finite. When a session gets long, pi-mega-compact:
-
-1. **Watches** context usage and, past a threshold, **compacts** the older part of
-   the conversation into a short structured summary + key facts ("a checkpoint").
-2. **Stores** each checkpoint in a **local vector database** (SQLite) with an
-   embedding, so similar regions can be found later — and so **duplicate
-   work is never stored twice**.
-3. **Recalls** the right checkpoints automatically when you resume a session or
-   invoke a recall command, re-injecting only what's relevant (deduped against
-   what's already in view).
+pi's context window is finite. When a session gets long — especially a team run
+with sub-agents — pi-mega-compact keeps it going without overflowing:
+
+1. **Watches one signal.** A single live `pressure = currentTokens / thresholdTokens`
+   drives everything — the tier label, how aggressively the live trim drops
+   context, and how often durable memory is reviewed. As context fills, the whole
+   system reacts together; as it's relieved, it backs off.
+2. **Compacts in two layers.** On every LLM call it returns a **live, compacted
+   view** (the model sees a summary + recent anchor, non-destructively). And it
+   persists a durable **checkpoint** — and, at each agent settle during a team
+   run, fires pi's **native durable trim** so the on-disk transcript is actually
+   truncated (context relieves mid-run, and resume reloads the trimmed transcript
+   instead of a 150k window).
+3. **Stores** each checkpoint in a **local vector database** (SQLite) with an
+   embedding, so similar regions are found later and **duplicate work is never
+   stored twice**.
+4. **Recalls** the right context automatically — same-repo checkpoints on resume,
+   plus **cross-repo memory-RAG**: decisions you saved in one repo are inlined as
+   context when you start a session in another.
 
 Everything lives on **your disk**. No telemetry, no API, no MCP server, no cloud.
 The only optional network surface is a **user-triggered localhost dashboard** you
@@ -35,11 +46,13 @@ open yourself.
 
 ### Why "mega"?
 
-The compaction pipeline is a **Trident** — three deterministic stages that run
-over your conversation before anything is persisted. The checkpoint it produces
-is small (a summary + key decisions + next steps + files touched), so the same
-session that would otherwise overflow its window keeps going on a fraction of the
-tokens.
+The compaction pipeline is a **Trident** — three deterministic stages
+(supersede → collapse → cluster) that run over your conversation before anything
+is persisted. The checkpoint it produces is small (a summary + key decisions +
+next steps + files touched), so the same session that would otherwise overflow
+its window keeps going on a fraction of the tokens. On top of the Trident, a
+single pressure signal orchestrates the live trim, the durable trim, and memory
+review as one coherent system rather than four independent triggers.
 
 ---
 
@@ -52,9 +65,12 @@ Layer 3  Cluster (vectorize)  local vector index → semantic dedup + recall
 Layer 2  Collapse (summarize)  summarizeMessages() heuristic + agent summary on /mega-compact
 Layer 1  Supersede (prune)     drop obsolete file-reads / superseded turns (zero cost)
 ─────────────────────────────────────────────────────────────────────────
-Trigger   context/turn_end → % gate → auto_compact_check → fire
+Trigger   context → token fast-gate → autoCompactCheck → live trim (per call)
+Durable    agent_end (idle + over threshold) → ctx.compact() → session_before_compact
+          supplies the summary; pi truncates the transcript (relieves context)
+Live      context handler returns { messages:[summary, …recent] } — model sees a
+          compacted window every LLM call; the on-disk transcript is untouched
 Marker    insert compact-marker; dedupe so repeated triggers cost ~0 tokens
-Cancel    session_before_compact → { cancel:true } once persisted (no double-compact)
 ```
 
 **One store, three ways to read it back — one dedup engine:**
@@ -168,7 +184,7 @@ building.
 pi-mega-compact uses a dual local backend — **zero network, no native build step**:
 
 - **`node:sqlite`** (`DatabaseSync`, Node ≥22.13 built-in) — the synchronous source of truth for checkpoints, session state, and the dedup index. No dependency, no install script, survives pi's `install-scripts` block.
-- **PGlite + `@electric-sql/pglite-pgvector`** (WASM Postgres + HNSW `vector_cosine_ops`) — an optional, best-effort async vector index for **cross-repo recall** at `~/.pi/mega-compact-vector`. The sync store stays authoritative; the index degrades to the sync per-session scan on any failure.
+- **PGlite + `@electric-sql/pglite-pgvector`** (WASM Postgres + HNSW `vector_cosine_ops`) — an optional, best-effort async vector index for **cross-repo recall** at `~/.pi/mega-compact-vector`. It holds both checkpoint embeddings and durable-memory embeddings, so decisions saved in one repo are findable from another. The sync store stays authoritative; the index degrades to the sync per-session scan on any failure.
 
 Kill-switch: `MEGACOMPACT_PGLITE_DISABLED=1` fully disables the PGlite index (falls back to sync scan). Requires Node ≥22.13 (`engines.node`).
 
@@ -178,7 +194,7 @@ On resume, recall augments from other repos' checkpoints when this repo's store
 
 ### Memory
 
-pi-mega-compact auto-reviews the conversation every 10 turns and writes durable `decision`/`fact`/`preference` memories to SQLite (local, hallucination-guarded). Relevant memories are injected as RAG context on recall (capped, deduped). Manual: `/mega-memory save|list|forget`.
+pi-mega-compact auto-reviews the conversation every 10 turns (the cadence shortens as pressure climbs) and writes durable `decision`/`fact`/`preference` memories to SQLite (local, hallucination-guarded). Relevant memories are injected as RAG context on recall (capped, deduped). **Cross-repo memory-RAG (S24):** every memory write is mirrored into the PGlite/HNSW index, so when same-repo recall is thin the system augments with the nearest memories from *other* repos (stricter `MEGACOMPACT_CROSSREPO_COSINE` floor, deduped against what's already in view). Manual: `/mega-memory save|list|forget` (or `/m`).
 
 ### Uninstall
 
@@ -352,7 +368,7 @@ The extension entry adapts between the engine and pi's runtime types.
 
 ```bash
 npm run build      # tsc
-npm test           # build + node --test on dist/**/*.test.js (346 tests)
+npm test           # build + node --test on dist/**/*.test.js (353 tests)
 npm run lint       # tsc --noEmit + guardrails-scan
 npm run guardrails # regression_check + guardrails-scan
 ```

package/dist/extensions/conflict-scan.test.js

@@ -0,0 +1,115 @@
+/**
+ * conflict-scan.test.ts — unit tests for the extension-conflict scanner.
+ *
+ * Fixture trees are written under a temp dir and scanned via
+ * MEGACOMPACT_EXT_SCAN_DIR (which makes collectScanRoots() return that
+ * single root). This covers the S24 follow-up fix:
+ *
+ *   1. node_modules-style code extensions (package.json + pi.extensions) are
+ *      still detected by source-marker grep (regression).
+ *   2. USER-LEVEL extensions installed outside npm (e.g. pi-hermes-memory)
+ *      now get scanned too — previously only `node_modules` was walked, so a
+ *      data-only memory store (MEMORY.md + sessions.db, no package.json)
+ *      was never flagged (the 5000-char file-buffer error slipped through).
+ *   3. The data-only memory-store signature is detected even with no source.
+ *   4. pi-mega-compact (selfName) is always skipped.
+ */
+import { test, after } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync, mkdirSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { detectConflicts, collectScanRoots } from "./conflict-scan.js";
+const base = mkdtempSync(join(tmpdir(), "mc-scan-"));
+let n = 0;
+/** Make a fixture root containing one or more fake extensions, return its path. */
+function fixture(build) {
+    const root = join(base, `case-${n++}`);
+    mkdirSync(root, { recursive: true });
+    build(root);
+    return root;
+}
+after(() => {
+    rmSync(base, { recursive: true, force: true });
+});
+test("scans a user-level, data-only memory store (no package.json)", () => {
+    const root = fixture((r) => {
+        const ext = join(r, "pi-hermes-memory");
+        mkdirSync(ext, { recursive: true });
+        // No package.json, no source — just pi's memory-store signature.
+        writeFileSync(join(ext, "MEMORY.md"), "# memory\n");
+        writeFileSync(join(ext, "sessions.db"), "");
+    });
+    process.env.MEGACOMPACT_EXT_SCAN_DIR = root;
+    try {
+        const { conflicts } = detectConflicts();
+        assert.ok(conflicts.length >= 1, "expected a memory conflict");
+        const hit = conflicts.find((c) => c.kind === "memory");
+        assert.ok(hit, "expected a memory-kind conflict");
+        assert.equal(hit.severity, "high");
+        assert.ok(hit.evidence.includes("MEMORY.md") ||
+            hit.evidence.includes("sessions.db"), "evidence should name the on-disk memory signature");
+    }
+    finally {
+        delete process.env.MEGACOMPACT_EXT_SCAN_DIR;
+    }
+});
+test("still detects a code extension by source marker (regression)", () => {
+    const root = fixture((r) => {
+        // A code extension is a DIRECT child of the scan root (mirrors the
+        // node_modules layout: packages live one level under the root).
+        const ext = join(r, "some-memory-ext");
+        mkdirSync(ext, { recursive: true });
+        writeFileSync(join(ext, "package.json"), JSON.stringify({ name: "some-memory-ext", pi: { extensions: ["x.ts"] } }));
+        writeFileSync(join(ext, "index.ts"), "export const MEMORY_TOOL = true;");
+    });
+    process.env.MEGACOMPACT_EXT_SCAN_DIR = root;
+    try {
+        const { conflicts } = detectConflicts();
+        const hit = conflicts.find((c) => c.package === "some-memory-ext");
+        assert.ok(hit, "expected some-memory-ext to be flagged");
+        assert.equal(hit.kind, "memory");
+    }
+    finally {
+        delete process.env.MEGACOMPACT_EXT_SCAN_DIR;
+    }
+});
+test("skips pi-mega-compact (selfName) and non-extension dirs", () => {
+    const root = fixture((r) => {
+        // selfName dir with a memory signature — must be ignored.
+        const me = join(r, "node_modules", "pi-mega-compact");
+        mkdirSync(me, { recursive: true });
+        writeFileSync(join(me, "sessions.db"), "");
+        // unrelated dir with no pi.extensions and no memory signature.
+        mkdirSync(join(r, "node_modules", "totally-fine"), { recursive: true });
+    });
+    process.env.MEGACOMPACT_EXT_SCAN_DIR = root;
+    try {
+        const { scanned, conflicts } = detectConflicts();
+        assert.equal(conflicts.length, 0, "no conflicts expected");
+        assert.ok(!scanned.some((s) => s.includes("pi-mega-compact")), "selfName should not appear in scanned");
+    }
+    finally {
+        delete process.env.MEGACOMPACT_EXT_SCAN_DIR;
+    }
+});
+test("collectScanRoots honors MEGACOMPACT_EXT_SCAN_DIR override", () => {
+    const root = fixture(() => { });
+    process.env.MEGACOMPACT_EXT_SCAN_DIR = root;
+    try {
+        const roots = collectScanRoots();
+        assert.deepEqual(roots, [root], "override replaces the whole root list");
+    }
+    finally {
+        delete process.env.MEGACOMPACT_EXT_SCAN_DIR;
+    }
+});
+test("collectScanRoots falls back to node_modules + user dir when no override", () => {
+    delete process.env.MEGACOMPACT_EXT_SCAN_DIR;
+    delete process.env.MEGACOMPACT_EXT_USER_DIR;
+    // No override set and this test file lives under extensions/, so node_modules
+    // resolution walks up from here; the user dir (~/.pi/agent) may or may
+    // not exist in CI. We only assert the call returns a non-throwing array.
+    const roots = collectScanRoots();
+    assert.ok(Array.isArray(roots), "collectScanRoots must return an array");
+});

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

@@ -9,6 +9,8 @@
 import { detectConflicts } from "./conflict-scan.js";
 import { addMemory, listMemories, searchMemories, recallMemory } from "../src/store/sqlite.js";
 import { resolveRepoRoot } from "./mega-config.js";
+import { defaultEmbedder } from "../src/embedder.js";
+import { upsertMemoryEmbedding } from "../src/store/memoryIndex.js";
 /** Run the conflict scan and format a human-readable report. */
 export function validateExtensions() {
     const report = detectConflicts();
@@ -74,6 +76,14 @@ export function registerConflictCommands(pi, runtime) {
                 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;
             }
@@ -142,6 +152,13 @@ export function registerConflictCommands(pi, runtime) {
                 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/dist/extensions/mega-events.js

@@ -15,8 +15,17 @@ import { recallMemoriesAndInline } from "../src/recall.js";
 import { driveNativeCompaction } from "./mega-compact-driver.js";
 import { computeLiveTrimCut, liveTrimSummaryMessage } from "./mega-trim.js";
 import { pressureFromPct, memoryReviewCadence } 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;
 /** Register all pi lifecycle event handlers. */
 export function registerEventHandlers(pi, runtime, config) {
+    lastRuntime = runtime;
     // ---- Session lifecycle (state reset points) -------------------------------
     // Capture model/provider whenever it changes (drives real cost estimation).
     pi.on("model_select", async (_event, ctx) => {
@@ -56,6 +65,8 @@ export function registerEventHandlers(pi, runtime, config) {
             try {
                 const mr = await recallMemoriesAndInline({
                     query, stateDir: runtime.getStateDir(), limit: 5,
+                    crossRepo: config.crossRepoEnabled,
+                    crossRepoCosine: config.crossRepoCosine,
                 });
                 if (!mr.empty)
                     runtime.pendingMemoryRecallBlock = mr.block;
@@ -82,7 +93,7 @@ export function registerEventHandlers(pi, runtime, config) {
                 }
                 // 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;
                 }
@@ -139,6 +150,46 @@ export function registerEventHandlers(pi, runtime, config) {
                 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.");
@@ -207,22 +258,30 @@ export function registerEventHandlers(pi, runtime, config) {
         const currentTokens = usage?.tokens ?? estimateSessionTokens(view) ??
             Math.round((pct / 100) * (usage?.contextWindow ?? 0));
         // FAST GATE: token-based (tier threshold), not percentage-based.
-        if (currentTokens < config.thresholdTokens)
+        if (currentTokens < config.thresholdTokens) {
+            runtime.diagCtxFastGate++;
             return;
+        }
         const check = autoCompactCheck(currentTokens, config.thresholdTokens); // SERVER-STYLE CONFIRM (local)
-        if (!check.shouldCompact)
+        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)
+        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)
+        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.
         // Read live from env (in addition to the load-time config) so the flag can be
@@ -254,8 +313,16 @@ export function registerEventHandlers(pi, runtime, config) {
                 summary: ran.result.summary,
                 anchorUserMessages,
             });
-            if (cut === null)
+            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,
@@ -269,9 +336,23 @@ export function registerEventHandlers(pi, runtime, config) {
             };
             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
         }
     });
@@ -283,11 +364,26 @@ export function registerEventHandlers(pi, runtime, config) {
     // there is no full-reload + additive recall inflation.
     pi.on("session_before_compact", async (event, ctx) => {
         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/dist/extensions/mega-runtime.js

@@ -120,6 +120,26 @@ export class MegaRuntime {
     lastCtxTokens = null;
     lastCtxPercent = 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/dist/extensions/mega-teamrun.test.js

@@ -0,0 +1,143 @@
+/**
+ * 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";
+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 = {};
+    const compactCalls = [];
+    function msg(role, text, toolName) {
+        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 };
+        }
+        if (role === "toolResult" && toolName) {
+            return { role: "toolResult", content: [{ type: "text", text }], toolCallId: "c1", toolName, isError: false, timestamp: 0 };
+        }
+        return { role: "user", content: text, timestamp: 0 };
+    }
+    const session = [];
+    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, i) => ({ 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 = {}) {
+        return {
+            ui: { setStatus: () => { }, notify: () => { }, select: () => { }, confirm: async () => true, input: async () => "", setWidget: () => { } },
+            mode: "tui", hasUI: true, cwd: stateDir, sessionManager,
+            modelRegistry: {}, 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) => {
+                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 } }, makeCtx());
+                }
+                return undefined;
+            },
+            getSystemPrompt: () => "system base",
+            ...over,
+        };
+    }
+    const pi = {
+        on: (ev, h) => { 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",
+        setThinkingLevel: () => { },
+    };
+    const mod = require("./mega-compact.js");
+    mod.default(pi);
+    const { lastRuntime } = require("./mega-events.js");
+    const fire = (ev, event, ctx) => 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 } }, 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 });
+});