pi-mega-compact 0.11.2 → 0.11.3

package/dist/extensions/mega-cache-replay.test.js

@@ -53,17 +53,48 @@ function harness() {
     // raising `tokens` while keeping `percent` null (→ token gate + token
     // grewEnough path in context-handler.ts). The REPLAY test keeps percent=100 so
     // the percent-basis grewEnough (>=10) never trips (no re-compact → pure replay).
-    const usage = { tokens: 200000, contextWindow: 200000, percent: 100 };
+    const usage = {
+        tokens: 200000,
+        contextWindow: 200000,
+        percent: 100,
+    };
     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 };
+            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: "toolResult",
+                content: [{ type: "text", text }],
+                toolCallId: "c1",
+                toolName,
+                isError: false,
+                timestamp: 0,
+            };
         }
-        return { role: "user", content: text, timestamp: 0 };
+        return {
+            role: "user",
+            content: text,
+            timestamp: 0,
+        };
     }
     // Build a session of `n` tool-call triples tagged `tag`. Set A and B differ in
     // content (so B never dedups against A) but A === A reproduces the same
@@ -77,7 +108,13 @@ function harness() {
         }
         return s;
     }
-    const toEntry = (m, i) => ({ type: "message", id: `e${i}`, parentId: null, timestamp: String(i), message: m });
+    const toEntry = (m, i) => ({
+        type: "message",
+        id: `e${i}`,
+        parentId: null,
+        timestamp: String(i),
+        message: m,
+    });
     const sessionManager = {
         getSessionId: () => "sess_cache_001",
         getEntries: () => buildSession("A", 14).map(toEntry),
@@ -85,39 +122,86 @@ function harness() {
     };
     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: () => { },
+            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: () => ({ ...usage }),
-            compact: (opts) => { compactCalls.push(opts); return undefined; },
+            compact: (opts) => {
+                compactCalls.push(opts);
+                return undefined;
+            },
             getSystemPrompt: () => "system base",
             ...over,
         };
     }
     const pi = {
-        on: (ev, h) => { if (!handlers[ev])
-            handlers[ev] = []; handlers[ev].push(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",
+        on: (ev, h) => {
+            if (!handlers[ev])
+                handlers[ev] = [];
+            handlers[ev].push(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 = async (ev, event, ctx) => { let r; for (const h of handlers[ev] || [])
-        r = await h(event, ctx); return r; };
+    const fire = async (ev, event, ctx) => {
+        let r;
+        for (const h of handlers[ev] || [])
+            r = await h(event, ctx);
+        return r;
+    };
     return {
-        stateDir, handlers, compactCalls, fire, ctx: makeCtx, usage, buildSession,
+        stateDir,
+        handlers,
+        compactCalls,
+        fire,
+        ctx: makeCtx,
+        usage,
+        buildSession,
         runtime: lastRuntime, // MegaRuntime with diag* counters + rt + trimCache
         // Bypass the 2s debounce so each fire proceeds without real waiting.
-        clearDebounce: () => { if (lastRuntime)
-            lastRuntime.debounceUntil = 0; },
+        clearDebounce: () => {
+            if (lastRuntime)
+                lastRuntime.debounceUntil = 0;
+        },
     };
 }
 test("REPLAY: >=2 gated context events within one epoch replay verbatim (byte-identical)", async () => {
@@ -185,6 +269,131 @@ test("DEDUP: re-compact that dedups onto a DIFFERENT checkpoint still replays ne
     await h.fire("context", { type: "context", messages: setA }, ctx);
     assert.ok(rt.diagLiveTrimReplays > replaysBefore, `replay fired after dedup-onto-different-checkpoint (got ${rt.diagLiveTrimReplays}, was ${replaysBefore})`);
 });
+// D.4-test-1 — Debounce exemption: the replay path sits BEFORE the debounce guard.
+// Two gated events <2s apart (no clearDebounce) must both replay — diagCtxDebounce
+// must NOT increment because the debounce guard is never reached when replay fires.
+test("DEBOUNCE-EXEMPTION: two events <2s apart (no clearDebounce) both replay; debounce never reached", async () => {
+    const h = harness();
+    const ctx = h.ctx();
+    const session = h.buildSession("A", 14);
+    // 1) Fresh trim.
+    h.clearDebounce(); // first event always needs a clear to pass the time guard
+    await h.fire("context", { type: "context", messages: session }, ctx);
+    assert.equal(h.runtime.diagLiveTrimFires, 1, "first fire was fresh trim");
+    // 2) Fire two events IN QUICK SUCCESSION without clearing the debounce.
+    //    The replay path (D.2) sits BEFORE the debounce guard, so both should
+    //    replay the cached trim and the debounce guard is NEVER reached.
+    const dbgBefore = h.runtime.diagCtxDebounce;
+    const rpyBefore = h.runtime.diagLiveTrimReplays;
+    await h.fire("context", { type: "context", messages: session }, ctx);
+    await h.fire("context", { type: "context", messages: session }, ctx);
+    assert.equal(h.runtime.diagCtxDebounce, dbgBefore, `debounce counter unchanged (${h.runtime.diagCtxDebounce} == ${dbgBefore}) — replay path was reached, not debounce`);
+    assert.ok(h.runtime.diagLiveTrimReplays >= rpyBefore + 2, `both events replayed (replays ${h.runtime.diagLiveTrimReplays} >= ${rpyBefore}+2)`);
+});
+// D.4-test-2 — Skip→replay fallback: when runCompact returns {skipped: true} and
+// a valid trimCache exists, the handler replays the cached trim instead of returning
+// empty. We force a skip by firing with a 1-message session (view.length ≤ 1) AFTER
+// a fresh trim with a full session has populated trimCache.
+test("SKIP-FALLBACK: runCompact skipped + valid trimCache → replays cached trim", async () => {
+    const h = harness();
+    const ctx = h.ctx();
+    const session = h.buildSession("A", 14);
+    // 1) Fresh trim with full session → populates trimCache with a valid cut.
+    h.clearDebounce();
+    await h.fire("context", { type: "context", messages: session }, ctx);
+    assert.equal(h.runtime.diagLiveTrimFires, 1, "fresh trim populated trimCache");
+    assert.ok(h.runtime.trimCache, "trimCache is set");
+    // 2) Lower the cut so a 1-message session still passes the cut≤length guard.
+    //    The skip→replay path checks cut <= messages.length before replaying.
+    h.runtime.trimCache.cut = 0;
+    // 3) Drive context growth so grewEnough=true (replay skipped → runCompact runs).
+    //    Then fire with just 1 message → runCompact: view.length ≤ 1 → {skipped: true}.
+    h.usage.percent = null; // token-basis path
+    h.usage.tokens = 200100; // grew 100 >= 25 (effectiveThreshold * 0.5)
+    h.clearDebounce();
+    const oneMsg = [h.buildSession("X", 1)[0]]; // single user message
+    await h.fire("context", { type: "context", messages: oneMsg }, ctx);
+    assert.ok(h.runtime.diagCtxRunSkipped >= 1, `diagCtxRunSkipped incremented (got ${h.runtime.diagCtxRunSkipped})`);
+    // The skip path replays trimCache → diagLiveTrimReplays increments.
+    assert.ok(h.runtime.diagLiveTrimReplays >= 1, `skip→replay fired (replays ${h.runtime.diagLiveTrimReplays} >= 1)`);
+});
+// D.4-test-3 — Recompact delta boundary: config.recompactPctDelta = 50.
+// 49% growth → replay (not enough to re-compact).
+// 51% growth → fresh compaction (exceeds the 50% delta threshold).
+//
+// diagLiveTrimFires counts every trim response (replay OR fresh), including
+// the initial fresh trim, so cumulative counts can't validate discrete steps.
+// Instead we snapshot (fires, replays) before each step and assert the delta.
+test("DELTA-BOUNDARY: 49% growth → replay; 51% growth → fresh compaction", async () => {
+    const h = harness();
+    const ctx = h.ctx();
+    const session = h.buildSession("A", 14);
+    // Start at low context (percent=5). The handler captures ctxPct from the first
+    // trim, then checks pct - ctxPct >= 50 (config.recompactPctDelta default=50).
+    h.usage.percent = 5;
+    h.usage.tokens = 200000;
+    // 1) Fresh trim at pct=5 → trimCache.ctxPct = 5.
+    h.clearDebounce();
+    await h.fire("context", { type: "context", messages: session }, ctx);
+    assert.ok(h.runtime.diagLiveTrimFires >= 1, "fresh trim at pct=5");
+    assert.equal(h.runtime.trimCache?.ctxPct, 5, "ctxPct captured as 5");
+    // 2) 49% growth: pct=54. grewEnough = 54-5 = 49 < 50 → replay.
+    //    Replay increments BOTH fires and replays (line 247-248).
+    h.usage.percent = 54;
+    h.clearDebounce();
+    const { fires: f2, replays: r2 } = {
+        fires: h.runtime.diagLiveTrimFires,
+        replays: h.runtime.diagLiveTrimReplays,
+    };
+    await h.fire("context", { type: "context", messages: session }, ctx);
+    assert.equal(h.runtime.diagLiveTrimFires, f2 + 1, `49% growth: fires +1 (replay counted as fire, ${f2}→${h.runtime.diagLiveTrimFires})`);
+    assert.equal(h.runtime.diagLiveTrimReplays, r2 + 1, `49% growth: replays +1 (${r2}→${h.runtime.diagLiveTrimReplays})`);
+    // 3) 51% growth: pct=56. grewEnough = 56-5 = 51 >= 50 → falls through to
+    //    debounce → runCompact → fresh compaction (line 509).
+    //    Fresh compaction increments fires but NOT replays.
+    h.usage.percent = 56;
+    h.clearDebounce();
+    const { fires: f3, replays: r3 } = {
+        fires: h.runtime.diagLiveTrimFires,
+        replays: h.runtime.diagLiveTrimReplays,
+    };
+    await h.fire("context", { type: "context", messages: session }, ctx);
+    assert.equal(h.runtime.diagLiveTrimFires, f3 + 1, `51% growth: fires +1 (fresh compaction, ${f3}→${h.runtime.diagLiveTrimFires})`);
+    assert.equal(h.runtime.diagLiveTrimReplays, r3, `51% growth: replays unchanged (fresh compaction ≠ replay, stays ${r3})`);
+});
+// D.4-test-4 — Epoch invalidation (PREVENT-PI-001/002 guard): a checkpointId
+// mismatch means the durable transcript was truncated (session_compact or
+// resetRuntime). The replay guard MUST reject a stale trimCache in that case.
+test("EPOCH-INVALIDATION: checkpointId mismatch → replay does NOT fire (PREVENT-PI-001/002)", async () => {
+    const h = harness();
+    const ctx = h.ctx();
+    const session = h.buildSession("A", 14);
+    // 1) Fresh trim → trimCache.checkpointId = lastCheckpointId = "cp-1".
+    h.clearDebounce();
+    await h.fire("context", { type: "context", messages: session }, ctx);
+    assert.equal(h.runtime.diagLiveTrimFires, 1, "fresh trim");
+    assert.ok(h.runtime.trimCache?.checkpointId, "trimCache has checkpointId");
+    // 2) Simulate a session_compact (durable truncation) by advancing
+    //    lastCheckpointId (harder: the compact path tracks its own epoch).
+    //    A mismatch between trimCache.checkpointId and rt.lastCheckpointId means
+    //    the cached cut is for a truncated transcript → replay must NOT fire.
+    h.runtime.rt.lastCheckpointId = "cp-mismatch";
+    assert.notEqual(h.runtime.trimCache?.checkpointId, h.runtime.rt.lastCheckpointId, "checkpointIds differ after simulated durable truncation");
+    // 3) Fire the same session (no growth → would normally replay if epoch matched).
+    const rpyBefore = h.runtime.diagLiveTrimReplays;
+    h.clearDebounce();
+    await h.fire("context", { type: "context", messages: session }, ctx);
+    // Replay path was blocked by the checkpointId guard → a fresh trim fires instead.
+    assert.equal(h.runtime.diagLiveTrimReplays, rpyBefore, `replay NOT incremented (was ${rpyBefore}, still ${h.runtime.diagLiveTrimReplays}) — stale trimCache rejected`);
+    // A fresh compaction should have been triggered instead (grewEnough=false, but
+    // replay guard failed → falls through to debounce → runCompact → fresh trim).
+    // Actually: grewEnough is false (no growth since last fire), and the replay
+    // guard rejected → falls to debounce (cleared) → runCompact.
+    // runCompact may skip or produce a fresh trim; either way the stale replay is blocked.
+    assert.ok(h.runtime.diagLiveTrimFires >= 2 || h.runtime.diagCtxRunSkipped >= 1, `handler did NOT replay stale trimCache (fires=${h.runtime.diagLiveTrimFires}, skipped=${h.runtime.diagCtxRunSkipped}, replays=${h.runtime.diagLiveTrimReplays})`);
+    // Restore for cleanup.
+    h.runtime.rt.lastCheckpointId = "cp-1";
+});
 test("cleanup", async () => {
     await closeVectorIndex();
     rmSync(baseTmp, { recursive: true, force: true });

package/dist/extensions/mega-compact-s38.test.js

@@ -576,9 +576,11 @@ test("R6(e): success resets retry-nudge-pending state", async () => {
 });
 test("R3: repeated identical transient error text upgrades to poisoned-context at threshold", async () => {
     // The stateful repeat signal: 3 consecutive identical transient errors
-    // (default threshold) upgrade to poisoned. Uses "5xx server error" (5xx
-    // marker → transient) so the classifier returns transient, then the repeat
-    // tracker upgrades it. auto=false to skip the compact attempt.
+    // (default threshold) upgrade to poisoned. Uses "5xx server error" —
+    // deliberately NO known-retryable marker ("5xx" is not /5\d\d/, and
+    // "server error" alone matches nothing): the classifier returns transient
+    // via the generic 'error' fallthrough, then the repeat tracker upgrades it.
+    // auto=false to skip the compact attempt.
     const prevAuto = process.env.MEGACOMPACT_AUTO;
     const prevBackoff = process.env.MEGACOMPACT_ERROR_RETRY_BACKOFF_MS;
     process.env.MEGACOMPACT_AUTO = "false";
@@ -608,6 +610,195 @@ test("R3: repeated identical transient error text upgrades to poisoned-context a
             process.env.MEGACOMPACT_ERROR_RETRY_BACKOFF_MS = prevBackoff;
     }
 });
+// ---- R7 regression tests: network/throughput errors must NEVER upgrade to ----
+// ---- poisoned-context (2026-07-30 false-alarm incident) ----
+/** R7 helper: fire the same transient error text `count` times with turn_start
+ *  + elapsed backoff between turns so each turn's nudge can fire. */
+async function r7RepeatTurns(h, text, count) {
+    for (let i = 0; i < count; i++) {
+        await s38TurnEnd(h, "error", text);
+        await h.fire("turn_start", { type: "turn_start", turnIndex: i + 2 }, h.ctx());
+        await new Promise((r) => setTimeout(r, 3));
+    }
+}
+/** R7 helper: shared assertions for "stays transient" — no poisoned upgrade,
+ *  no /clear advise, and the transient retry path actually ran. */
+function assertStaysTransient(h, label) {
+    assert.ok(!eventTypes(h.stateDir).includes("poisoned_context"), `${label}: no poisoned_context event (network errors never upgrade)`);
+    assert.ok(!h.sendUserMessages.some((m) => m.includes("/clear")), `${label}: no /clear advise message`);
+    assert.ok(eventTypes(h.stateDir).includes("error_retry"), `${label}: transient retry path ran (error_retry event)`);
+}
+test("R7(a): repeated 'timed out' phrasing (2026-07-30 incident text) stays transient — no poisoned upgrade", async () => {
+    // The incident error text was "Request timed out or failed. Try again" —
+    // "timed out" (two words) does NOT match the old guard's /timeout/, so the
+    // 3rd repeat fired the /clear poisoned advise. Must stay transient.
+    const prevAuto = process.env.MEGACOMPACT_AUTO;
+    const prevBackoff = process.env.MEGACOMPACT_ERROR_RETRY_BACKOFF_MS;
+    process.env.MEGACOMPACT_AUTO = "false";
+    process.env.MEGACOMPACT_ERROR_RETRY_BACKOFF_MS = "1";
+    try {
+        const h = harness();
+        await r7RepeatTurns(h, "Request timed out or failed. Try again", 3);
+        assertStaysTransient(h, "timed out x3");
+    }
+    finally {
+        if (prevAuto === undefined)
+            delete process.env.MEGACOMPACT_AUTO;
+        else
+            process.env.MEGACOMPACT_AUTO = prevAuto;
+        if (prevBackoff === undefined)
+            delete process.env.MEGACOMPACT_ERROR_RETRY_BACKOFF_MS;
+        else
+            process.env.MEGACOMPACT_ERROR_RETRY_BACKOFF_MS = prevBackoff;
+    }
+});
+test("R7(b): repeated ETIMEDOUT errno stays transient", async () => {
+    // Node's timeout errno lowercases to "etimedout" — does NOT contain the
+    // substring "timeout". Slipped through the old guard.
+    const prevAuto = process.env.MEGACOMPACT_AUTO;
+    const prevBackoff = process.env.MEGACOMPACT_ERROR_RETRY_BACKOFF_MS;
+    process.env.MEGACOMPACT_AUTO = "false";
+    process.env.MEGACOMPACT_ERROR_RETRY_BACKOFF_MS = "1";
+    try {
+        const h = harness();
+        await r7RepeatTurns(h, "connect ETIMEDOUT 142.250.80.46:443", 3);
+        assertStaysTransient(h, "ETIMEDOUT x3");
+    }
+    finally {
+        if (prevAuto === undefined)
+            delete process.env.MEGACOMPACT_AUTO;
+        else
+            process.env.MEGACOMPACT_AUTO = prevAuto;
+        if (prevBackoff === undefined)
+            delete process.env.MEGACOMPACT_ERROR_RETRY_BACKOFF_MS;
+        else
+            process.env.MEGACOMPACT_ERROR_RETRY_BACKOFF_MS = prevBackoff;
+    }
+});
+test("R7(c): repeated 'socket hang up' stays transient", async () => {
+    // Node surfaces ECONNRESET as the message "socket hang up" (the errno lives
+    // in error.code, which extractErrorSignature never sees).
+    const prevAuto = process.env.MEGACOMPACT_AUTO;
+    const prevBackoff = process.env.MEGACOMPACT_ERROR_RETRY_BACKOFF_MS;
+    process.env.MEGACOMPACT_AUTO = "false";
+    process.env.MEGACOMPACT_ERROR_RETRY_BACKOFF_MS = "1";
+    try {
+        const h = harness();
+        await r7RepeatTurns(h, "socket hang up", 3);
+        assertStaysTransient(h, "socket hang up x3");
+    }
+    finally {
+        if (prevAuto === undefined)
+            delete process.env.MEGACOMPACT_AUTO;
+        else
+            process.env.MEGACOMPACT_AUTO = prevAuto;
+        if (prevBackoff === undefined)
+            delete process.env.MEGACOMPACT_ERROR_RETRY_BACKOFF_MS;
+        else
+            process.env.MEGACOMPACT_ERROR_RETRY_BACKOFF_MS = prevBackoff;
+    }
+});
+test("R7(d): repeated 429 rate-limit stays transient", async () => {
+    // /clear cannot fix a rate limit — the classifier explicitly keeps 429
+    // transient, so the repeat-upgrade must not override that verdict.
+    const prevAuto = process.env.MEGACOMPACT_AUTO;
+    const prevBackoff = process.env.MEGACOMPACT_ERROR_RETRY_BACKOFF_MS;
+    process.env.MEGACOMPACT_AUTO = "false";
+    process.env.MEGACOMPACT_ERROR_RETRY_BACKOFF_MS = "1";
+    try {
+        const h = harness();
+        await r7RepeatTurns(h, "429 Too Many Requests: rate limit exceeded", 3);
+        assertStaysTransient(h, "429 x3");
+    }
+    finally {
+        if (prevAuto === undefined)
+            delete process.env.MEGACOMPACT_AUTO;
+        else
+            process.env.MEGACOMPACT_AUTO = prevAuto;
+        if (prevBackoff === undefined)
+            delete process.env.MEGACOMPACT_ERROR_RETRY_BACKOFF_MS;
+        else
+            process.env.MEGACOMPACT_ERROR_RETRY_BACKOFF_MS = prevBackoff;
+    }
+});
+test("R7(e): 0-token 'timed out' turn is NOT poisoned on first occurrence", async () => {
+    // Deeper gap: with usage PRESENT at 0 tokens, the classifier's 0-token
+    // poisoned signal fires on turn ONE for "timed out" phrasing (the stopReason
+    // 'error' is in the text blob and no transient marker matched). The network
+    // markers must be checked before that signal so this returns transient.
+    const prevAuto = process.env.MEGACOMPACT_AUTO;
+    process.env.MEGACOMPACT_AUTO = "false";
+    try {
+        const h = harness();
+        await s38TurnEndUsage(h, "error", "Request timed out or failed. Try again", 0);
+        assert.ok(!eventTypes(h.stateDir).includes("poisoned_context"), "0-token timed out: no poisoned_context on first turn");
+        assert.ok(!h.sendUserMessages.some((m) => m.includes("/clear")), "0-token timed out: no /clear advise on first turn");
+    }
+    finally {
+        if (prevAuto === undefined)
+            delete process.env.MEGACOMPACT_AUTO;
+        else
+            process.env.MEGACOMPACT_AUTO = prevAuto;
+    }
+});
+test("R7(f): repeated non-network transient still upgrades to poisoned-context (control)", async () => {
+    // True-positive control: an error with NO known-retryable marker that
+    // repeats identically must still upgrade (the R3 feature itself).
+    const prevAuto = process.env.MEGACOMPACT_AUTO;
+    const prevBackoff = process.env.MEGACOMPACT_ERROR_RETRY_BACKOFF_MS;
+    process.env.MEGACOMPACT_AUTO = "false";
+    process.env.MEGACOMPACT_ERROR_RETRY_BACKOFF_MS = "1";
+    try {
+        const h = harness();
+        await r7RepeatTurns(h, "upstream rejected the request", 3);
+        assert.ok(eventTypes(h.stateDir).includes("poisoned_context"), "non-network repeat: poisoned_context event logged");
+        assert.ok(h.sendUserMessages.some((m) => m.includes("/clear")), "non-network repeat: /clear advise fired");
+    }
+    finally {
+        if (prevAuto === undefined)
+            delete process.env.MEGACOMPACT_AUTO;
+        else
+            process.env.MEGACOMPACT_AUTO = prevAuto;
+        if (prevBackoff === undefined)
+            delete process.env.MEGACOMPACT_ERROR_RETRY_BACKOFF_MS;
+        else
+            process.env.MEGACOMPACT_ERROR_RETRY_BACKOFF_MS = prevBackoff;
+    }
+});
+test("R7(g): 'Request failed — please retry.' 0-token stays poisoned-context (2026-07-28 control)", async () => {
+    // The deterministic-rejection incident that motivated R3 must remain
+    // poisoned: the shared marker pattern must NOT match this text.
+    const prevAuto = process.env.MEGACOMPACT_AUTO;
+    process.env.MEGACOMPACT_AUTO = "false";
+    try {
+        const h = harness();
+        await s38TurnEndUsage(h, "error", "Request failed — please retry.", 0);
+        assert.ok(eventTypes(h.stateDir).includes("poisoned_context"), "deterministic rejection: poisoned_context event logged");
+        assert.ok(h.sendUserMessages.some((m) => m.includes("/clear")), "deterministic rejection: /clear advise fired");
+    }
+    finally {
+        if (prevAuto === undefined)
+            delete process.env.MEGACOMPACT_AUTO;
+        else
+            process.env.MEGACOMPACT_AUTO = prevAuto;
+    }
+});
+test("R7 classifier: 0-token 'timed out' error → transient (not poisoned)", () => {
+    // Unit-level pin of the R7(e) gap.
+    assert.equal(classifyErrorFn({
+        stopReason: "error",
+        content: "Request timed out or failed. Try again",
+        usage: { inputTokens: 0, outputTokens: 0 },
+    }), "transient");
+});
+test("R7 classifier: bare network phrasings → transient", () => {
+    assert.equal(classifyErrorFn("socket hang up"), "transient");
+    assert.equal(classifyErrorFn("the operation timed out"), "transient");
+    assert.equal(classifyErrorFn("connect ETIMEDOUT 10.0.0.1:443"), "transient");
+});
+test("R7 classifier: 429/rate-limit → transient (control)", () => {
+    assert.equal(classifyErrorFn("429 Too Many Requests: rate limit exceeded"), "transient");
+});
 test("cleanup", async () => {
     // PGlite WASM close can hang; race with a timeout to prevent 40-min hangs.
     try {
@@ -618,8 +809,12 @@ test("cleanup", async () => {
     // Force-exit: each harness() creates a MegaRuntime with an fs.watch
     // game-state watcher that is never disposed (no session_shutdown in tests).
     // Those handles keep the event loop alive indefinitely after all tests
-    // complete, so `node --test` (without --test-force-exit) would hang. The
-    // streaming reporter has already printed every test result by this point;
-    // process.exit(0) just forces the exit the watchers are preventing.
+    // complete, so `node --test` (without --test-force-exit) would hang.
+    // Drain stdout/stderr, then defer the exit: a bare process.exit() discards
+    // unflushed pipe buffers — observed 2026-07-30: when piped, the trailing
+    // tests' results and the run summary silently vanished from the report.
+    await new Promise((r) => process.stdout.write("", r));
+    await new Promise((r) => process.stderr.write("", r));
+    await new Promise((r) => setTimeout(r, 1500));
     process.exit(0);
 });

package/dist/extensions/mega-config.js

@@ -165,6 +165,9 @@ export function loadConfig() {
         recallMaxTokens: envFlag("MEGACOMPACT_RECALL_MAX_TOKENS", 1500),
         windowDedupe: envBool("MEGACOMPACT_WINDOW_DEDUPE", true),
         tuiWidget: envBool("MEGACOMPACT_TUI_WIDGET", true),
+        // D.1: env-overridable recompact delta (minimum context growth % before
+        // re-compacting instead of replaying the cached live trim). Default 50.
+        recompactPctDelta: envFlag("MEGACOMPACT_RECOMPACT_PCT_DELTA", 50),
         debug: envBool("MEGACOMPACT_DEBUG", false),
     };
 }

package/dist/extensions/mega-events/agent-handlers.js

@@ -1,11 +1,11 @@
 import { piCompactWouldNoop, runMemoryReview } from "../mega-pipeline.js";
 import { memoryReviewCadence } from "../mega-config.js";
-import { recordScore } from "../../src/store/sqlite.js";
+import { recordScore, readLatestCacheHitPct } from "../../src/store/sqlite.js";
 import { evaluateAndUnlockAchievements } from "../../src/store/sqlite/game-achievements.js";
 import { ensureConversationIdFor, recordTurnWrite, } from "../mega-turn-store.js";
 import { isMegaCache } from "../../src/game/scoring.js";
 import { resolveRepoRoot } from "../mega-config.js";
-import { classifyError, errorRetryBackoffMs, extractErrorSignature, } from "./error-classifier.js";
+import { classifyError, errorRetryBackoffMs, extractErrorSignature, isKnownRetryableTransient, } from "./error-classifier.js";
 import { safeSendUserMessage } from "./send-safe.js";
 import { vectorStats } from "../../src/vectorStore.js";
 /** Register agent/turn tracking event handlers. */
@@ -255,7 +255,9 @@ export function registerAgentHandlers(pi, runtime, config) {
             if (runtime.getCachedGameState().game_mode_on) {
                 const repo = resolveRepoRoot(ctx.cwd) ?? runtime.currentStateDir;
                 const st = vectorStats(runtime.store, runtime.rt.sessionId);
-                const cachePct = st.dedupHitRate * 100;
+                // C.3: prefer provider cache hit rate, fall back to dedup hit rate
+                const providerPct = readLatestCacheHitPct(runtime.currentStateDir);
+                const cachePct = providerPct != null ? providerPct : st.dedupHitRate * 100;
                 const modelId = runtime.currentModel?.modelId ?? "unknown";
                 recordScore(runtime.currentStateDir, {
                     repo_root: repo,
@@ -339,9 +341,11 @@ export function registerAgentHandlers(pi, runtime, config) {
                 // upgrade happens here. A 'transient' (or 'poisoned-context') turn
                 // whose normalized error signature matches the previous one bumps
                 // errorTextRepeatCount; once it crosses the threshold, the category
-                // is upgraded to 'poisoned-context' (the request is deterministic).
-                // Conservative: only upgrade, never downgrade, and only for transient
-                // (a 'permanent' auth error repeating is still permanent).
+                // is upgraded to 'poisoned-context' (the request is deterministic) —
+                // R7: unless the signature carries a known-retryable network/
+                // throughput marker (guard below). Conservative: only upgrade, never
+                // downgrade, and only for transient (a 'permanent' auth error
+                // repeating is still permanent).
                 let effectiveCategory = category;
                 const errSig = extractErrorSignature(event.message);
                 if (category === "transient" || category === "poisoned-context") {
@@ -356,7 +360,19 @@ export function registerAgentHandlers(pi, runtime, config) {
                         if (runtime.rt.errorTextRepeatCount >=
                             config.poisonedContextRepeatThreshold &&
                             category === "transient") {
-                            effectiveCategory = "poisoned-context";
+                            // R3/R7: upgrade only when the repeating error carries NO
+                            // known-retryable marker. Network/throughput failures (timeout,
+                            // ECONNRESET, 5xx, 429, connection lost, …) that repeat are
+                            // still retryable — the API is just flaky, and /clear cannot fix
+                            // them (2026-07-30 false-alarm incident). Only upgrade
+                            // transient → poisoned-context for errors that repeat identically
+                            // with no known-retryable cause, like the 2026-07-28 incident
+                            // where the provider returned "Request failed — please retry."
+                            // deterministically. The marker set is shared with classifyError
+                            // (error-classifier.ts) so the two never drift.
+                            if (!isKnownRetryableTransient(errSig)) {
+                                effectiveCategory = "poisoned-context";
+                            }
                         }
                     }
                 }