pi-mega-compact 0.6.1 → 0.6.2

package/dist/src/recall.js

@@ -105,27 +105,53 @@ export function formatMemoryRecallBlock(hits) {
 export async function recallMemoriesAndInline(opts) {
     const limit = opts.limit ?? 5;
     const maxTokens = opts.recallMaxTokens ?? 0;
-    const { recallMemories } = await import("./memoryRecall.js");
+    const { recallMemories, recallMemoriesCrossRepo } = await import("./memoryRecall.js");
     const hits = await recallMemories(opts.query, opts.stateDir, {
         topK: limit,
         minSimilarity: opts.minSimilarity ?? 0.2,
     });
-    if (hits.length === 0)
+    // S24 cross-repo augmentation: if same-repo recall is thin, pull additional
+    // memories from OTHER repos via the PGlite HNSW index. Non-fatal: a failure
+    // degrades to the same-repo hits only.
+    const crossHits = [];
+    if (opts.crossRepo && hits.length < limit) {
+        try {
+            const x = await recallMemoriesCrossRepo(opts.query, opts.stateDir, {
+                repo: null,
+                limit: limit - hits.length,
+                crossRepoCosine: opts.crossRepoCosine ?? 0.3,
+            });
+            for (const h of x)
+                crossHits.push(h);
+        }
+        catch {
+            /* non-fatal — cross-repo failure → same-repo only */
+        }
+    }
+    if (hits.length === 0 && crossHits.length === 0)
         return { empty: true, block: "", report: [] };
     // Same incremental token cap pattern as checkpoint recall.
     const parts = [];
     const report = [];
     let blockTokens = 0;
-    for (const h of hits) {
-        const part = formatMemoryRecallBlock([
-            { content: h.memory.content, category: h.memory.category, score: h.score },
-        ]);
+    const pushHit = (content, category, score, label) => {
+        const part = formatMemoryRecallBlock([{ content, category, score }]);
         const partTokens = estimateBlockTokens(part);
         if (maxTokens > 0 && blockTokens + partTokens > maxTokens)
-            break;
+            return false;
         parts.push(part);
-        report.push(`  • memory#${h.memory.id} (${(h.score * 100).toFixed(0)}%): ${h.memory.content.slice(0, 60).replace(/\n/g, " ")}…`);
+        report.push(`  • ${label} (${(score * 100).toFixed(0)}%): ${content.slice(0, 60).replace(/\n/g, " ")}…`);
         blockTokens += partTokens;
+        return true;
+    };
+    for (const h of hits) {
+        if (!pushHit(h.memory.content, h.memory.category, h.score, `memory#${h.memory.id}`))
+            break;
+    }
+    for (const h of crossHits) {
+        const repoLabel = h.repoId.split(/[\\/]/).filter(Boolean).pop() ?? h.repoId;
+        if (!pushHit(h.memory.content, h.memory.category, h.score, `memory#${h.memory.id} (from ${repoLabel})`))
+            break;
     }
     return { empty: parts.length === 0, block: parts.join("\n"), report };
 }

package/dist/src/store/memoryIndex.js

@@ -0,0 +1,205 @@
+/**
+ * memoryIndex.ts — cross-repo async vector index for durable memories (S24).
+ *
+ * A REDUNDANT, additive, ASYNC index layered over the authoritative node:sqlite
+ * `memories` table. The same-repo linear cosine scan over the in-repo memories
+ * (src/memoryRecall.ts) stays the DEFAULT recall path; this global PGlite index
+ * exists only to provide real cross-repo nearest-neighbor memory recall — so a
+ * decision you saved in repo A can be inlined as RAG context when you start a
+ * session in repo B. It is best-effort and non-fatal: any init/write failure
+ * degrades to the same-repo scan and must NEVER break memory write, recall, or
+ * extension load.
+ *
+ * PREVENT-PI-004: PGlite is WASM Postgres — fully local, zero network. Memory
+ * remains AUTHORITATIVE in SQLite; this index only holds (repo_id, memory_id,
+ * content, embedding) for NN lookup and is rebuilt from SQLite at any time.
+ *
+ * Topology mirrors vectorIndex.ts (Slice 2): ONE global PGlite DB, `repo_id` is
+ * a first-class column. `searchMemoriesAsync(q, k, {repoId?})` → omit repoId for
+ * cross-repo NN, pass repoId to scope to a single repo. Hit content is stored
+ * inline because the recall process cannot open every other repo's SQLite dir.
+ */
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { mkdirSync, rmSync, existsSync } from "node:fs";
+// PGlite + pgvector are script-free WASM (no native build) → survive pi's
+// install-script block. Imported lazily so a missing/broken package degrades
+// gracefully instead of crashing module load.
+import { PGlite } from "@electric-sql/pglite";
+import { vector } from "@electric-sql/pglite-pgvector";
+/** Vector dimension produced by the default TrigramEmbedder (src/embedder.ts). */
+export const MEMORY_INDEX_DIM = 512;
+let db;
+let initPromise;
+let disabled = false;
+let warned = false;
+function indexDir() {
+    const override = process.env.MEGACOMPACT_INDEX_DIR;
+    if (override && override.trim() !== "")
+        return join(override, "memory");
+    try {
+        return join(homedir(), ".pi", "mega-compact-vector", "memory");
+    }
+    catch {
+        return join("/tmp", ".mega-compact-vector", "memory");
+    }
+}
+function logWarn(msg) {
+    // Never throw — degradation is the whole point. One warning per process.
+    if (warned)
+        return;
+    warned = true;
+    try {
+        console.warn(`[mega-compact:memoryIndex] ${msg} (falling back to same-repo scan)`);
+    }
+    catch {
+        /* ignore */
+    }
+}
+/** Honor the emergency kill-switch (shared with the checkpoint index). */
+export function isMemoryIndexDisabled() {
+    return (disabled ||
+        process.env.MEGACOMPACT_PGLITE_DISABLED === "true" ||
+        process.env.MEGACOMPACT_PGLITE_DISABLED === "1");
+}
+/**
+ * Lazily open + schema-init the global PGlite DB. Idempotent and safe to call
+ * from many places. Returns undefined when disabled/unavailable so callers can
+ * fall back to the synchronous scan. Never throws.
+ */
+export function initMemoryIndex() {
+    if (isMemoryIndexDisabled())
+        return Promise.resolve(undefined);
+    if (db)
+        return Promise.resolve(db);
+    if (initPromise)
+        return initPromise;
+    initPromise = openPgLite(/* retryOnCorrupt */ true);
+    return initPromise;
+}
+/**
+ * Open + schema-init PGlite. When `retryOnCorrupt` is true, a WASM-level abort
+ * (typically from a corrupted/torn data dir) triggers a delete + one retry.
+ */
+async function openPgLite(retryOnCorrupt) {
+    try {
+        const dir = indexDir();
+        mkdirSync(dir, { recursive: true });
+        const pg = await new PGlite({
+            dataDir: dir,
+            extensions: { vector },
+        });
+        await pg.exec("CREATE EXTENSION IF NOT EXISTS vector;");
+        await pg.exec(`
+      CREATE TABLE IF NOT EXISTS memory_index (
+        repo_id    TEXT NOT NULL,
+        memory_id  INTEGER NOT NULL,
+        content    TEXT NOT NULL,
+        embedding  vector(${MEMORY_INDEX_DIM}) NOT NULL,
+        PRIMARY KEY (repo_id, memory_id)
+      );
+    `);
+        await pg.exec("CREATE INDEX IF NOT EXISTS memory_index_hnsw ON memory_index USING hnsw (embedding vector_cosine_ops);");
+        db = pg;
+        return pg;
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        if (retryOnCorrupt && (msg.includes("Aborted") || msg.includes("RuntimeError"))) {
+            try {
+                const dir = indexDir();
+                if (existsSync(dir))
+                    rmSync(dir, { recursive: true, force: true });
+                initPromise = undefined;
+                return openPgLite(/* retryOnCorrupt */ false);
+            }
+            catch {
+                /* self-heal failed — fall through to disable */
+            }
+        }
+        disabled = true;
+        logWarn(`init failed: ${msg}`);
+        return undefined;
+    }
+}
+function toVectorLiteral(v) {
+    const parts = v.map((x) => (Number.isFinite(x) ? x : 0));
+    return `[${parts.join(",")}]`;
+}
+/**
+ * Best-effort upsert of one memory embedding into the global index.
+ * Dimension-mismatched vectors (e.g. a BYO embedder with dim ≠ 512) are skipped.
+ * Fire-and-forget: callers must NOT await this on the sync write path. Never
+ * throws. `content` is stored inline so cross-repo recall can read it directly.
+ */
+export async function upsertMemoryEmbedding(repoId, memoryId, content, embedding) {
+    if (isMemoryIndexDisabled())
+        return;
+    if (!embedding || embedding.length !== MEMORY_INDEX_DIM)
+        return;
+    try {
+        const pg = await initMemoryIndex();
+        if (!pg)
+            return;
+        const lit = toVectorLiteral(embedding);
+        await pg.query(`INSERT INTO memory_index (repo_id, memory_id, content, embedding)
+       VALUES ($1, $2, $3, $4::vector)
+       ON CONFLICT (repo_id, memory_id)
+       DO UPDATE SET content = EXCLUDED.content, embedding = EXCLUDED.embedding;`, [repoId, memoryId, content, lit]);
+    }
+    catch (err) {
+        disabled = true;
+        logWarn(`upsert failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
+}
+/**
+ * Cross-repo (or single-repo) HNSW nearest-neighbor memory search. Returns hits
+ * sorted by descending similarity. Never throws — on any failure returns [].
+ */
+export async function searchMemoriesAsync(query, opts = {}) {
+    if (isMemoryIndexDisabled() || !query || query.length !== MEMORY_INDEX_DIM)
+        return [];
+    const k = opts.k ?? 5;
+    const repoId = opts.repoId;
+    try {
+        const pg = await initMemoryIndex();
+        if (!pg)
+            return [];
+        const lit = toVectorLiteral(query);
+        const params = [lit, k];
+        let sql = "SELECT repo_id, memory_id, content, 1 - (embedding <=> $1::vector) AS score " +
+            "FROM memory_index";
+        if (repoId) {
+            sql += " WHERE repo_id = $3";
+            params.push(repoId);
+        }
+        sql += " ORDER BY embedding <=> $1::vector LIMIT $2";
+        const res = await pg.query(sql, params);
+        return res.rows.map((r) => ({
+            repoId: r.repo_id,
+            memoryId: Number(r.memory_id),
+            content: r.content,
+            score: r.score,
+        }));
+    }
+    catch (err) {
+        disabled = true;
+        logWarn(`search failed: ${err instanceof Error ? err.message : String(err)}`);
+        return [];
+    }
+}
+/** Close the index (test teardown / shutdown). Safe to call when unopened. */
+export async function closeMemoryIndex() {
+    if (db) {
+        try {
+            await db.close();
+        }
+        catch {
+            /* ignore */
+        }
+    }
+    db = undefined;
+    initPromise = undefined;
+    disabled = false;
+    warned = false;
+}

package/dist/src/store/memoryIndex.test.js

@@ -0,0 +1,51 @@
+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 { defaultEmbedder } from "../embedder.js";
+import { upsertMemoryEmbedding, searchMemoriesAsync, initMemoryIndex, closeMemoryIndex, isMemoryIndexDisabled, } from "./memoryIndex.js";
+const baseTmp = mkdtempSync(join(tmpdir(), "mc-memidx-"));
+test("memoryIndex: disabled when MEGACOMPACT_PGLITE_DISABLED", async () => {
+    process.env.MEGACOMPACT_PGLITE_DISABLED = "true";
+    try {
+        assert.equal(isMemoryIndexDisabled(), true, "kill-switch honored");
+        const hits = await searchMemoriesAsync(defaultEmbedder().embed("anything"), { k: 3 });
+        assert.deepEqual(hits, [], "search returns [] when disabled");
+    }
+    finally {
+        delete process.env.MEGACOMPACT_PGLITE_DISABLED;
+    }
+});
+test("memoryIndex: cross-repo upsert + NN search returns the right repo's memory", async () => {
+    // Isolate the global PGlite dir so concurrent test runs don't collide.
+    process.env.MEGACOMPACT_INDEX_DIR = join(baseTmp, "index");
+    const repoA = "/tmp/repo-a";
+    const repoB = "/tmp/repo-b";
+    try {
+        await initMemoryIndex();
+        // Two memories in different repos, with clearly distinct content so their
+        // trigram embeddings separate.
+        const vecA = defaultEmbedder().embed("We standardized on node:sqlite for the store backend");
+        const vecB = defaultEmbedder().embed("The deployment target is a raspberry pi in the closet");
+        await upsertMemoryEmbedding(repoA, 1, "We standardized on node:sqlite for the store backend", vecA);
+        await upsertMemoryEmbedding(repoB, 7, "The deployment target is a raspberry pi in the closet", vecB);
+        // Query close to A's content → top hit should be A's memory, not B's.
+        const q = defaultEmbedder().embed("standardized node:sqlite store backend choice");
+        const hits = await searchMemoriesAsync(q, { k: 3 });
+        assert.ok(hits.length >= 1, "at least one hit");
+        assert.equal(hits[0].repoId, repoA, "nearest neighbor is repo A");
+        assert.equal(hits[0].memoryId, 1, "correct memory id");
+        assert.ok(hits[0].score > 0.5, "high cosine for the matching memory");
+        // Scope to repoB only → A must not appear.
+        const scoped = await searchMemoriesAsync(q, { k: 3, repoId: repoB });
+        assert.ok(scoped.every((h) => h.repoId === repoB), "scoped search stays within repoB");
+    }
+    finally {
+        await closeMemoryIndex();
+        delete process.env.MEGACOMPACT_INDEX_DIR;
+    }
+});
+test("memoryIndex: cleanup", () => {
+    rmSync(baseTmp, { recursive: true, force: true });
+});

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

@@ -19,8 +19,18 @@ 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.");
@@ -215,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.
@@ -262,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,
@@ -276,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
     }
   });
@@ -290,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-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