pi-mega-compact 0.11.1 → 0.11.3

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";
+                            }
                         }
                     }
                 }

package/dist/extensions/mega-events/context-handler.js

@@ -170,30 +170,24 @@ export function registerContextHandler(pi, runtime, config) {
             runtime.diagCtxFastGate++;
             return;
         }
-        // Debounce so we don't fire on every context event past threshold.
-        const now = Date.now();
-        if (now < runtime.debounceUntil) {
-            runtime.diagCtxDebounce++;
-            return;
-        }
-        runtime.debounceUntil = now + 2000;
+        // D.2: Replay MUST be exempt from debounce — replay is free (no compute,
+        // no re-write) and prevents unnecessary KV-cache invalidation. Check
+        // replay FIRST, before debounce, so two context events <2s apart both
+        // return the cached sentinel verbatim (re-stabilises the provider prefix).
+        //
         // v0.8.6 cache-stability: replay the cached trim view when still in the
         // same compaction epoch AND context hasn't grown enough to warrant a
-        // re-compact. This stabilizes the provider KV-cache prefix (the summary +
-        // cut are reused verbatim) instead of regenerating a fresh summary +
-        // sentinel every fire, which invalidated the prefix on every other turn
-        // (the alternating cache-miss regression). Re-compact only when context
-        // grew >=10% of the window (percent basis) or >=50% of the effective
-        // threshold (token basis, when percent is unavailable). The cached `cut`
-        // is only valid while the transcript grows within the epoch — it is
-        // cleared on session_compact (durable truncation) + resetRuntime, so we
-        // never replay a stale cut into a truncated transcript (PREVENT-PI-001/002).
-        const RECOMPACT_PCT_DELTA = 10;
+        // re-compact. Re-compact only when context grew >=config.recompactPctDelta%
+        // of the window (percent basis) or >=50% of the effective threshold
+        // (token basis, when percent is unavailable). The cached `cut` is only
+        // valid while the transcript grows within the epoch — it is cleared on
+        // session_compact (durable truncation) + resetRuntime, so we never replay
+        // a stale cut into a truncated transcript (PREVENT-PI-001/002).
         if (runtime.trimCache &&
             runtime.trimCache.checkpointId === runtime.rt.lastCheckpointId &&
             runtime.trimCache.cut <= messages.length) {
             const grewEnough = pct != null && runtime.trimCache.ctxPct != null
-                ? pct - runtime.trimCache.ctxPct >= RECOMPACT_PCT_DELTA
+                ? pct - runtime.trimCache.ctxPct >= config.recompactPctDelta
                 : currentTokens - (runtime.trimCache.ctxTokens ?? 0) >=
                     runtime.effectiveThreshold * 0.5;
             if (!grewEnough) {
@@ -209,6 +203,14 @@ export function registerContextHandler(pi, runtime, config) {
             }
             // else: context grew enough → fall through to re-compact (cache is stale)
         }
+        // Debounce so we don't fire on every context event past threshold.
+        // (Replay already returned above — only fresh compacts reach this point.)
+        const now = Date.now();
+        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. Null-safe: when the
         // token-fallback path ran (pct unavailable) use the token-basis pressure
@@ -219,8 +221,22 @@ export function registerContextHandler(pi, runtime, config) {
         const ran = runCompact(pi, runtime, config, ctx, messages, {
             compressionPressure: pressure,
         });
+        // D.3: skip paths fall back to replay instead of returning empty.
+        // If runCompact skipped and we have a valid trimCache, replay it
+        // (free stability win) — otherwise defer to the next event.
         if (ran.skipped) {
             runtime.diagCtxRunSkipped++;
+            if (runtime.trimCache &&
+                runtime.trimCache.checkpointId === runtime.rt.lastCheckpointId &&
+                runtime.trimCache.cut <= messages.length) {
+                const recent = messages.slice(runtime.trimCache.cut); // guardrails-allow PREVENT-PI-002
+                runtime.diagLiveTrimFires++;
+                runtime.diagLiveTrimReplays++;
+                runtime.snapshot(ctx);
+                return {
+                    messages: [{ ...runtime.trimCache.summaryAgentMsg }, ...recent],
+                };
+            }
             return;
         }
         // S27 DB-mirror: write checkpoint_epoch with deterministic nonce.
@@ -277,7 +293,9 @@ export function registerContextHandler(pi, runtime, config) {
                     }
                 }
                 catch (wikiErr) {
-                    runtime.logger.warn("wiki_rebuild_failed", { error: String(wikiErr) });
+                    runtime.logger.warn("wiki_rebuild_failed", {
+                        error: String(wikiErr),
+                    });
                 }
                 // S27 Task 6: Fire-and-forget dedup pipeline.
                 // Deduplicates raw_transcript rows for the compacted range.

package/dist/extensions/mega-events/error-classifier.js

@@ -11,6 +11,25 @@
  * compact per signature). Conservative: when unsure between transient and
  * poisoned, choose transient (bounded by R1 dedup + R2 session cap).
  */
+/** R7: known-retryable transient markers — network/throughput failures that
+ *  retry can fix and /clear cannot. SINGLE SOURCE OF TRUTH: classifyError uses
+ *  this for its transient-marker stage, and the agent-handlers R3 repeat
+ *  upgrade guard uses it to keep these errors out of poisoned-context. Add new
+ *  transient phrasings HERE only.
+ *
+ *  Non-obvious alternatives:
+ *  - `time(?:d[\s-]?out|out)` covers "timeout", "timed out", "timed-out" —
+ *    "timed out" does NOT match /timeout/ (the 2026-07-30 incident phrasing).
+ *  - `etimedout` is Node's timeout errno lowercased — does NOT contain the
+ *    substring "timeout".
+ *  - `socket hang up` is Node's ECONNRESET *message*; the errno lives in
+ *    error.code, which extractErrorSignature never sees. */
+export const KNOWN_RETRYABLE_TRANSIENT_PATTERN = /max(imum)? output token|rate[\s.-]?limit|429|too many requests|overloaded|5\d\d|internal server|bad gateway|service unavailable|network|time(?:d[\s-]?out|out)|etimedout|econnreset|econnrefused|epipe|eai_again|socket hang up|premature close|other side closed|connection (lost|refused|reset|aborted?)|stream (interrupted|closed|ended|failed)|disconnected/;
+/** R7: true when the error text carries a known-retryable transient marker.
+ *  Defensively lowercases so callers can pass raw or normalized text. */
+export function isKnownRetryableTransient(text) {
+    return KNOWN_RETRYABLE_TRANSIENT_PATTERN.test(text.toLowerCase());
+}
 /** S38.2: classify a turn-end error/stop signal into a retry category.
  *
  * `length` is returned as null — S28 owns the max-output-token length stopReason
@@ -134,22 +153,14 @@ export function classifyError(message) {
     if (/too long|context window|maximum context length|context length exceeded|requires at least \d+ tokens|even after compaction|reduce the conversation|reduce your input/.test(s)) {
         return 'context-overflow';
     }
-    // --- transient (specific markers FIRST — these override poisoned signals) ---
-    // R3: network failures (timeout, ECONNRESET, 5xx, 429) MUST stay transient
-    // even when usage is 0 tokens, because they are retryable. The specific
-    // markers below return before any poisoned signal is evaluated.
-    if (/max(imum)? output token/.test(s))
-        return 'transient';
-    if (/rate[\s.-]?limit|429|too many requests/.test(s))
-        return 'transient';
-    if (/5\d\d|internal server|bad gateway|service unavailable/.test(s))
-        return 'transient';
-    // 'connection aborted' is a network failure (ECONNABORTED), NOT a user ESC
-    // (which is stopReason 'aborted', handled by the early-return above). Added
-    // so "Connection aborted by peer" stays transient under R3. ECONNRESET and
-    // common errno names are included so a bare 0-token 'ECONNRESET' turn is not
-    // misclassified as poisoned (R6: ECONNRESET → transient).
-    if (/network|timeout|econnreset|econnrefused|epipe|connection (lost|refused|reset|aborted)|stream (interrupted|closed|ended|failed)|disconnected/.test(s))
+    // --- transient (known-retryable markers FIRST — these override poisoned signals) ---
+    // R3: network/throughput failures (timeout, ECONNRESET, 5xx, 429) MUST stay
+    // transient even when usage is 0 tokens, because they are retryable and
+    // /clear cannot fix them. 'connection aborted' is a network failure
+    // (ECONNABORTED), NOT a user ESC (stopReason 'aborted', early-return above).
+    // The marker set is shared with the agent-handlers R3 repeat-upgrade guard
+    // (isKnownRetryableTransient) so the two never drift.
+    if (isKnownRetryableTransient(s))
         return 'transient';
     // --- poisoned-context (R3: ORDER AFTER specific transient markers, BEFORE
     // the generic 'error' transient fallthrough) ---

package/dist/extensions/mega-runtime/runtime-snapshot.js

@@ -18,8 +18,8 @@
  */
 import { join } from "node:path";
 import { vectorStats, vectorRepoStats, vectorDataInvariant, } from "../../src/vectorStore.js";
-import { latestModelSnapshot, recordPerfSample, recordSessionHeartbeat, appendTokenSample, } from "../../src/store/sqlite.js";
-import { resolveRepoRoot } from "../mega-config.js";
+import { latestModelSnapshot, readLatestCacheHitPct, recordPerfSample, recordSessionHeartbeat, appendTokenSample, } from "../../src/store/sqlite.js";
+import { resolveRepoRoot, } from "../mega-config.js";
 import { computeMegaSnapshot } from "./snapshot.js";
 import { buildDashboardSnapshot } from "./dashboard-snapshot.js";
 import { materialSigImpl, embedderNameImpl, driftStatusImpl, getTurnLevelImpl, } from "./runtime-helpers.js";
@@ -134,6 +134,16 @@ export function snapshotImpl(self, ctx) {
         }
         // ── gather widget data (computed per snapshot, rendered per frame) ────
         const modelSnap = latestModelSnapshot(self.currentStateDir);
+        // Provider prompt cache hit % for the widget (B/C): latest
+        // cache_hit_pct sample. Non-fatal — one extra sync open per
+        // material-change-gated recompute, acceptably cheap.
+        let providerCachePct = 0;
+        try {
+            providerCachePct = readLatestCacheHitPct(self.currentStateDir);
+        }
+        catch {
+            /* non-fatal */
+        }
         const _snapResult = computeMegaSnapshot({
             lastCtxTokens: self.lastCtxTokens,
             lastCtxWindow: self.lastCtxWindow,
@@ -165,6 +175,7 @@ export function snapshotImpl(self, ctx) {
             ready,
             armed,
             modelSnap,
+            providerCachePct,
         });
         self.widgetData = _snapResult.widgetData;
         // S33: consume the flare after copying it into widgetData so it fires
@@ -186,8 +197,7 @@ export function snapshotImpl(self, ctx) {
         // (effectBorderSgr returns '' once expired), so this is bookkeeping to
         // free the slot and prevent a stale effect lingering between snapshots.
         if (self.activeEffect &&
-            Date.now() - self.activeEffect.startedAt >=
-                self.activeEffect.durationMs) {
+            Date.now() - self.activeEffect.startedAt >= self.activeEffect.durationMs) {
             self.activeEffect = null;
         }
         // Auto-fit: register a factory so pi re-renders the panel at the REAL

package/dist/extensions/mega-runtime/snapshot.js

@@ -91,7 +91,7 @@ export function computeMegaSnapshot(p) {
     // ── S31: game-mode state ──────────────────────────────────────────────
     const gs = p.getCachedGameState();
     const curLevel = p.getTurnLevel();
-    const cachePct = st.dedupHitRate * 100;
+    const cachePct = p.providerCachePct;
     const widgetData = {
         version: ownVersion(),
         tierLabel,

package/dist/extensions/mega-runtime/snapshot.test.js

@@ -0,0 +1,127 @@
+/**
+ * snapshot.test.ts — C.4 computeMegaSnapshot tests for providerCachePct
+ * and megaCacheFlare fields.
+ *
+ * Uses MEGACOMPACT_STATE_DIR + mkdtemp (G7). No pi runtime.
+ */
+import { describe, it, before, after } from "node:test";
+import assert from "node:assert/strict";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { mkdtempSync, rmSync } from "node:fs";
+import { computeMegaSnapshot } from "./snapshot.js";
+function baseInput(overrides = {}) {
+    return {
+        rtTokensSaved: 1000,
+        lastCtxPercent: null,
+        lastCtxTokens: 0,
+        lastCtxWindow: 0,
+        activeAgents: 0,
+        currentTurn: 0,
+        statusKey: undefined,
+        ready: false,
+        armed: false,
+        st: {
+            totalTokenEstimate: 800,
+            originalTokens: 1200,
+            storageDedupRate: 0.12,
+            checkpointCount: 3,
+            lastCheckpointId: undefined,
+            lastSummary: undefined,
+            injectedCount: 0,
+            dedupHitRate: 0.05,
+            tokensSaved: 200,
+            dedupAttempts: 40,
+            dedupCollapsed: 5,
+        },
+        repo: {
+            tokensSaved: 5000,
+            totalTokenEstimate: 4000,
+            checkpointCount: 9,
+            sessionCount: 2,
+            originalTokens: 6000,
+            dedupAttempts: 100,
+            dedupCollapsed: 30,
+            storageDedupRate: 0.3,
+        },
+        pressureBand: "low",
+        configTier: "default",
+        modelSnap: undefined,
+        lastCompactAt: null,
+        embedderName: () => "Trigram",
+        driftStatus: () => "ok",
+        getCachedGameState: () => ({
+            game_mode_on: false,
+            theme: "transparent",
+            tui_display_mode: "full",
+        }),
+        getTurnLevel: () => 1,
+        providerCachePct: 56.2,
+        megaCacheFlare: false,
+        megaCacheFlarePct: 0,
+        levelUpFlare: false,
+        achievementFlare: false,
+        achievementFlareTitles: [],
+        activeEffect: null,
+        lastActivityAt: Date.now(),
+        ticker: [],
+        lastWhy: undefined,
+        tierTrace: undefined,
+        pulsing: false,
+        ...overrides,
+    };
+}
+describe("computeMegaSnapshot (C.4)", () => {
+    let dir;
+    before(() => {
+        dir = mkdtempSync(join(tmpdir(), "mc-snap-"));
+        process.env.MEGACOMPACT_STATE_DIR = dir;
+    });
+    after(() => {
+        delete process.env.MEGACOMPACT_STATE_DIR;
+        rmSync(dir, { recursive: true, force: true });
+    });
+    // ── C.1: providerCachePct flows into cachePct ─────────────────────────
+    it("cachePct equals providerCachePct (not dedup hit rate)", () => {
+        const res = computeMegaSnapshot(baseInput({ providerCachePct: 56.2 }));
+        assert.equal(res.widgetData.cachePct, 56.2, "cachePct is providerCachePct");
+    });
+    it("cachePct is 0 when providerCachePct is 0", () => {
+        const res = computeMegaSnapshot(baseInput({ providerCachePct: 0 }));
+        assert.equal(res.widgetData.cachePct, 0, "cachePct is 0");
+    });
+    it("cachePct is independent of dedup hit rate", () => {
+        const res = computeMegaSnapshot(baseInput({
+            providerCachePct: 12.5,
+            st: {
+                totalTokenEstimate: 99999,
+                originalTokens: 99999,
+                storageDedupRate: 0.99,
+                checkpointCount: 1,
+                lastCheckpointId: undefined,
+                lastSummary: undefined,
+                injectedCount: 0,
+                dedupHitRate: 0.05,
+                tokensSaved: 200,
+                dedupAttempts: 40,
+                dedupCollapsed: 5,
+            },
+        }));
+        assert.equal(res.widgetData.cachePct, 12.5, "cachePct ignores dedup");
+    });
+    // ── megaCacheFlare fields pass through ────────────────────────────────
+    it("megaCacheFlare + megaCacheFlarePct pass through to widgetData", () => {
+        const res = computeMegaSnapshot(baseInput({ megaCacheFlare: true, megaCacheFlarePct: 287 }));
+        assert.equal(res.widgetData.megaCacheFlare, true);
+        assert.equal(res.widgetData.megaCacheFlarePct, 287);
+    });
+    it("megaCacheFlare is false by default", () => {
+        const res = computeMegaSnapshot(baseInput());
+        assert.equal(res.widgetData.megaCacheFlare, false);
+    });
+    // ── level pass-through ────────────────────────────────────────────────
+    it("level flows from getTurnLevel", () => {
+        const res = computeMegaSnapshot(baseInput({ getTurnLevel: () => 42 }));
+        assert.equal(res.curLevel, 42);
+    });
+});