pi-mega-compact 0.8.14 → 0.8.15

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

@@ -4,6 +4,7 @@ import { recordScore } from "../../src/store/sqlite.js";
 import { evaluateAndUnlockAchievements } from "../../src/store/sqlite/game-achievements.js";
 import { isMegaCache } from "../../src/game/scoring.js";
 import { resolveRepoRoot } from "../mega-config.js";
+import { classifyError } from "./error-classifier.js";
 /** Register agent/turn tracking event handlers. */
 export function registerAgentHandlers(pi, runtime, config) {
     // ---- Agent tracking for real-time widget + status-line updates ---------
@@ -37,10 +38,31 @@ export function registerAgentHandlers(pi, runtime, config) {
                 const idle = ctx.isIdle?.() ?? true;
                 const queued = ctx.hasPendingMessages?.() ?? false;
                 const now = Date.now();
+                // S38.5: read LIVE pressure from ctx.getContextUsage() instead of the
+                // stale runtime.lastCtxTokens (only updated by the `context` event).
+                // agent_end may fire without a preceding context event this turn (e.g.
+                // a sub-agent settling), so the cached value can be null/stale and the
+                // durable-trim branch would be unreachable. ctx.getContextUsage() is the
+                // authoritative live reading (mirrors context-handler.ts:86). Fall back
+                // to the cached value only if the ctx omits it.
+                const liveUsage = ctx.getContextUsage?.();
+                const liveTokens = typeof liveUsage?.tokens === "number"
+                    ? liveUsage.tokens
+                    : runtime.lastCtxTokens ?? 0;
+                // Keep the cache fresh for snapshot()/diag regardless of which source we use.
+                if (typeof liveUsage?.tokens === "number") {
+                    runtime.lastCtxTokens = liveUsage.tokens;
+                }
+                if (typeof liveUsage?.percent === "number") {
+                    runtime.lastCtxPercent = liveUsage.percent;
+                }
+                if (typeof liveUsage?.contextWindow === "number") {
+                    runtime.lastCtxWindow = liveUsage.contextWindow;
+                }
                 // 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) >= runtime.effectiveThreshold;
+                const overThreshold = liveTokens >= runtime.effectiveThreshold;
                 runtime.diagAgentEndIdle++;
                 runtime.logger.info("agent-end-idle", {
                     sessionId: runtime.rt.sessionId,
@@ -87,11 +109,20 @@ export function registerAgentHandlers(pi, runtime, config) {
                     // synchronous `piCompactWouldNoop` branch check misses a native
                     // compaction that hasn't appended its entry yet — calling
                     // ctx.compact() then races with pi and throws "Already compacted"
-                    // to the user. The `lastCompactAt` cooldown (updated by the
+                    // to the user. The `lastNativeCompactAt` cooldown (updated by the
                     // session_compact listener for EVERY compaction, native or
                     // extension-supplied) closes that race window.
+                    //
+                    // S38.5: strict race guard widens the cooldown 10s -> 30s AND defers
+                    // ctx.compact() via setTimeout(500) with a re-check, so pi's
+                    // about-to-run native _checkCompaction can append its `compaction`
+                    // branch entry first (closes the first-race-in-burst window). Gated
+                    // by MEGACOMPACT_RACE_GUARD_STRICT (default true); false reverts to
+                    // the v0.7.4 synchronous 10s guard. Mirrors the legacy path in
+                    // context-handler.ts:258-287 so both call sites stay in sync.
+                    const cooldownMs = config.raceGuardStrict ? 30_000 : 10_000;
                     const sinceCompact = now - (runtime.rt.lastNativeCompactAt ?? 0);
-                    if (sinceCompact < 10_000) {
+                    if (sinceCompact < cooldownMs) {
                         runtime.diagAgentEndDurableSkipRecent++;
                     }
                     else if (!piCompactWouldNoop(ctx)) {
@@ -103,7 +134,35 @@ export function registerAgentHandlers(pi, runtime, config) {
                             thresholdTokens: config.thresholdTokens,
                             queued,
                         });
-                        ctx.compact({ customInstructions: undefined }); // guardrails-allow PREVENT-PI-004: local ctx.compact() — no network; agent settled so no in-flight abort. Race-guarded by lastCompactAt cooldown above (ctx.compact returns void → throw is surfaced by pi as compaction_end; the cooldown prevents the call entirely).
+                        if (config.raceGuardStrict) {
+                            // Strict: defer ctx.compact() with a re-check so pi's
+                            // about-to-run native _checkCompaction can append its
+                            // `compaction` branch entry first. setTimeout(500) — pi's
+                            // compaction-summary append is async I/O, so queueMicrotask
+                            // would re-check before it lands.
+                            const stamp = runtime.rt.lastNativeCompactAt;
+                            const liveSid = runtime.rt.sessionId;
+                            setTimeout(() => {
+                                try {
+                                    if (runtime.rt.sessionId !== liveSid)
+                                        return; // session reset
+                                    const since2 = now - (runtime.rt.lastNativeCompactAt ?? 0);
+                                    if (runtime.rt.lastNativeCompactAt !== stamp && since2 < cooldownMs)
+                                        return;
+                                    if (piCompactWouldNoop(ctx))
+                                        return;
+                                    ctx.compact({
+                                        customInstructions: undefined,
+                                    }); // guardrails-allow PREVENT-PI-004: local ctx.compact() — no network; deferred + re-validated.
+                                }
+                                catch {
+                                    /* non-fatal */
+                                }
+                            }, 500);
+                        }
+                        else {
+                            ctx.compact({ customInstructions: undefined }); // guardrails-allow PREVENT-PI-004: local ctx.compact() — no network; agent settled so no in-flight abort. Race-guarded by lastNativeCompactAt cooldown above (ctx.compact returns void → throw is surfaced by pi as compaction_end; the cooldown prevents the call entirely).
+                        }
                         didDurableTrim = true;
                     }
                 }
@@ -141,6 +200,7 @@ export function registerAgentHandlers(pi, runtime, config) {
     pi.on("turn_start", async (event, ctx) => {
         runtime.currentTurn = event.turnIndex;
         runtime.rt.lengthStopPending = false; // S28: re-arm defensively each user turn
+        runtime.rt.errorRetryCount = 0; // S38: reset error-retry counter each user turn
         runtime.dashboard.event("turn_start", { turnIndex: event.turnIndex });
         runtime.snapshot(ctx);
     });
@@ -218,5 +278,125 @@ export function registerAgentHandlers(pi, runtime, config) {
             runtime.rt.lengthStopPending = true;
             runtime.dashboard.event("length_stop", { turnIndex: event.turnIndex });
         }
+        // S38: broader error-retry safety net. S28 only catches stopReason==='length';
+        // this catches ALL other error types (provider failure, network timeout, 5xx,
+        // 429, auth, compaction-noop) that surface at turn_end. Non-fatal: wrapped in
+        // try/catch so a classifier/retry failure never breaks the agent loop.
+        // PREVENT-PI-003: retry nudge fires via pi.sendUserMessage (user-role).
+        try {
+            // (1) S28 owns length — skip the classifier entirely for it.
+            const sr = event.message?.stopReason;
+            if (sr === 'length') {
+                // S28 handles; nothing for S38 to do here.
+            }
+            else {
+                const category = classifyError(event.message);
+                if (category === null) {
+                    // (3) success / normal flow / unknown-but-non-retryable — reset.
+                    runtime.rt.errorRetryCount = 0;
+                    runtime.rt.consecutiveErrors = 0; // S38.6: circuit-breaker reset on success
+                }
+                else if (category === 'compaction-noop') {
+                    // (4) pi race / manual compact catch — NOT retryable. The compaction
+                    // already succeeded via pi's native path; retrying would race again
+                    // (FAIL-2026071701). Log a diagnostic, reset the counter, and surface
+                    // the original error WITHOUT firing a retry nudge.
+                    runtime.rt.errorRetryCount = 0;
+                    runtime.rt.consecutiveErrors = 0; // S38.6: circuit-breaker reset
+                    runtime.dashboard.event('compaction_noop_diagnostic', {
+                        turnIndex: event.turnIndex,
+                        sessionId: runtime.rt.sessionId,
+                    });
+                    runtime.logger.info('compaction-noop-diagnostic', {
+                        sessionId: runtime.rt.sessionId,
+                        turnIndex: event.turnIndex,
+                    });
+                }
+                else {
+                    // (5) transient or permanent — retry with exponential backoff.
+                    // S38.7: hard-stop switch — bypass ALL retry logic when set.
+                    if (config.errorRetryHardStop) {
+                        runtime.rt.errorRetryCount = 0;
+                        runtime.dashboard.event('error_retry_disabled', {
+                            category,
+                            turnIndex: event.turnIndex,
+                            reason: 'hard-stop',
+                        });
+                        return; // early exit — no retry
+                    }
+                    // S38.6: circuit-breaker — stop retrying after too many consecutive errors.
+                    runtime.rt.consecutiveErrors++;
+                    if (runtime.rt.consecutiveErrors > config.maxConsecutiveErrors) {
+                        runtime.dashboard.event('error_retry_circuit_open', {
+                            consecutive: runtime.rt.consecutiveErrors,
+                            max: config.maxConsecutiveErrors,
+                            turnIndex: event.turnIndex,
+                        });
+                        runtime.logger.warn('error-retry-circuit-open', {
+                            sessionId: runtime.rt.sessionId,
+                            consecutive: runtime.rt.consecutiveErrors,
+                            max: config.maxConsecutiveErrors,
+                        });
+                        return; // early exit — circuit breaker tripped
+                    }
+                    const max = category === 'transient'
+                        ? config.autoRetryTransientMax
+                        : config.autoRetryPermanentMax;
+                    // max === 0 disables the category entirely (revert to S28-only).
+                    if (max <= 0) {
+                        runtime.rt.errorRetryCount = 0;
+                    }
+                    else {
+                        runtime.rt.errorRetryCount++;
+                        if (runtime.rt.errorRetryCount > max) {
+                            // Exhausted — surface the error, reset for the next burst.
+                            runtime.dashboard.event('error_retry_exhausted', {
+                                category,
+                                count: runtime.rt.errorRetryCount,
+                                max,
+                                turnIndex: event.turnIndex,
+                            });
+                            runtime.logger.info('error-retry-exhausted', {
+                                sessionId: runtime.rt.sessionId,
+                                category,
+                                count: runtime.rt.errorRetryCount,
+                                max,
+                            });
+                            runtime.rt.errorRetryCount = 0;
+                        }
+                        else {
+                            // S38: fire the retry nudge. Each error turn fires its own
+                            // nudge up to `max` — we intentionally do NOT debounce on the
+                            // backoff window (errorRetryUntil) here, because that would
+                            // suppress turns 2..max on a fast-erroring provider (the exact
+                            // scenario this feature targets) and the user could see zero
+                            // retries followed by error_retry_exhausted. The per-turn cap
+                            // (errorRetryCount <= max) plus the session circuit breaker
+                            // (consecutiveErrors > maxConsecutiveErrors) already bound the
+                            // loop, so a tight turn_end storm cannot busy-loop unbounded.
+                            // errorRetryUntil + errorRetryBackoffMs() are retained on the
+                            // runtime for future/optional pacing but are not gating.
+                            runtime.dashboard.event('error_retry', {
+                                category,
+                                count: runtime.rt.errorRetryCount,
+                                max,
+                                turnIndex: event.turnIndex,
+                            });
+                            runtime.logger.info('error-retry', {
+                                sessionId: runtime.rt.sessionId,
+                                category,
+                                count: runtime.rt.errorRetryCount,
+                                max,
+                            });
+                            // PREVENT-PI-003: user-role sendUserMessage only.
+                            pi.sendUserMessage('[mega-compact] the last turn ended with an error; please retry.');
+                        }
+                    }
+                }
+            }
+        }
+        catch {
+            /* non-fatal: a classifier/retry failure never breaks the agent loop */
+        }
     });
 }

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

@@ -208,10 +208,43 @@ export function registerContextHandler(pi, runtime, config) {
             // NATIVE compaction just fired (avoids racing pi and surfacing a spurious
             // "Already compacted" / "Nothing to compact" toast). Uses lastNativeCompactAt
             // (NOT lastCompactAt, which runCompact also stamps for our own checkpoint).
+            // S38.5: strict race guard widens the cooldown 10s -> 30s (gated by
+            // MEGACOMPACT_RACE_GUARD_STRICT; false reverts to v0.7.4 10s).
+            const cooldownMs = config.raceGuardStrict ? 30_000 : 10_000;
             const sinceCompact = Date.now() - (runtime.rt.lastNativeCompactAt ?? 0);
-            if (sinceCompact < 10_000 || piCompactWouldNoop(ctx))
+            if (sinceCompact < cooldownMs || piCompactWouldNoop(ctx))
                 return;
-            ctx.compact({ customInstructions: undefined }); // race-guarded by lastNativeCompactAt cooldown (ctx.compact returns void → not catchable; the cooldown prevents the call)
+            // S38.5: defer ctx.compact() with a re-check so pi's about-to-run native
+            // _checkCompaction can append its `compaction` branch entry first (closes
+            // the first-race-in-burst window). setTimeout(500) — pi's compaction-summary
+            // append is async I/O, so queueMicrotask would re-check before it lands.
+            // Non-strict (v0.7.4) keeps the synchronous call.
+            if (config.raceGuardStrict) {
+                const stamp = runtime.rt.lastNativeCompactAt;
+                const liveSid = runtime.rt.sessionId;
+                setTimeout(() => {
+                    try {
+                        if (runtime.rt.sessionId !== liveSid)
+                            return; // session reset
+                        const since2 = Date.now() - (runtime.rt.lastNativeCompactAt ?? 0);
+                        if (runtime.rt.lastNativeCompactAt !== stamp && since2 < cooldownMs)
+                            return;
+                        if (piCompactWouldNoop(ctx))
+                            return;
+                        ctx.compact({
+                            customInstructions: undefined,
+                        }); // guardrails-allow PREVENT-PI-004: local ctx.compact() — no network; deferred + re-validated.
+                    }
+                    catch {
+                        /* non-fatal */
+                    }
+                }, 500);
+            }
+            else {
+                ctx.compact({
+                    customInstructions: undefined,
+                }); // race-guarded by lastNativeCompactAt cooldown (ctx.compact returns void → not catchable; the cooldown prevents the call)
+            }
             return;
         }
         // S16 LIVE trim: collapse the compacted region to a summary + recent anchor.

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

@@ -0,0 +1,118 @@
+/**
+ * error-classifier.ts — S38.2 error classification for retry logic.
+ *
+ * Classifies turn-end error/stop signals into retry categories.
+ * Ordering matters: compaction-noop is matched BEFORE generic transient
+ * so a pi race / manual compact catch is never misclassified.
+ */
+/** 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
+ * exclusively (its agent_end nudge path is separate and must not be doubled).
+ *
+ * @param message  the event.message (a pi AgentMessage) or an error string
+ * @returns 'transient' | 'permanent' | 'compaction-noop' | null (success/unknown)
+ */
+export function classifyError(message) {
+    // Resolve a searchable text blob from a pi AgentMessage or raw string.
+    let text = '';
+    if (typeof message === 'string') {
+        text = message;
+    }
+    else if (message && typeof message === 'object') {
+        const m = message;
+        const sr = typeof m.stopReason === 'string' ? m.stopReason : '';
+        // S28 guard: length stopReason is handled exclusively by the S28 path.
+        if (sr === 'length')
+            return null;
+        // Success / normal tool flow — not an error, nothing to retry.
+        if (sr === 'stop' || sr === 'toolUse' || sr === 'tool_use')
+            return null;
+        const parts = [];
+        if (sr)
+            parts.push(sr);
+        const c = m.content;
+        if (typeof c === 'string')
+            parts.push(c);
+        else if (Array.isArray(c)) {
+            for (const b of c) {
+                if (b && typeof b === 'object' && 'text' in b) {
+                    parts.push(String(b.text ?? ''));
+                }
+            }
+        }
+        if (m.error) {
+            // Extract message from error objects for pattern matching.
+            const err = m.error;
+            if (typeof err === 'string') {
+                parts.push(err);
+            }
+            else if (err && typeof err === 'object') {
+                const errObj = err;
+                if (typeof errObj.message === 'string') {
+                    parts.push(errObj.message);
+                }
+                else {
+                    parts.push(JSON.stringify(err));
+                }
+            }
+        }
+        // S38: detect mid-response errors where the stream died without a
+        // proper stopReason (empty/undefined) — this catches provider failures
+        // that cut off the response mid-stream, INCLUDING the case where the
+        // provider emitted partial content before dying (a truncated response
+        // with no stop reason is a mid-stream death, not a success).
+        // A genuine success ALWAYS carries stop/tool_use/toolUse (which
+        // short-circuit to null at the top), so any message reaching here with a
+        // falsy stopReason is a stream failure → retryable.
+        if (!sr) {
+            return 'transient';
+        }
+        text = parts.join(' ');
+    }
+    if (!text)
+        return null;
+    const s = text.toLowerCase();
+    // --- compaction-noop (ORDER FIRST: pi race / manual compact catch) ---
+    // FAIL-2026071701: these are NOT retryable — the compaction already
+    // succeeded via pi's native path; retrying would race again.
+    if (/already compacted/.test(s))
+        return 'compaction-noop';
+    if (/compaction failed/.test(s))
+        return 'compaction-noop';
+    if (/nothing to compact/.test(s))
+        return 'compaction-noop';
+    if (/auto[\s-]?compaction failed/.test(s))
+        return 'compaction-noop';
+    // --- transient (retryable) ---
+    if (s.includes('error') && !/\b(permanent|invalid request|malformed|bad request|auth|unauthorized|invalid (api )?key|permission)\b/.test(s)) {
+        return 'transient'; // generic pi stopReason 'error' / 'aborted'
+    }
+    if (s.includes('aborted'))
+        return 'transient';
+    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';
+    if (/network|timeout|connection (lost|refused|reset)|stream (interrupted|closed|ended|failed)|disconnected/.test(s))
+        return 'transient';
+    // --- permanent (NOT retryable beyond 1) ---
+    if (/auth|unauthorized|invalid (api )?key|permission/.test(s))
+        return 'permanent';
+    if (/invalid request|malformed|bad request/.test(s))
+        return 'permanent';
+    // Unknown — do not retry (avoid busy-looping on an unclassified signal).
+    return null;
+}
+/** S38.2: exponential backoff for error-retry nudges (5s,10s,20s,30s,30s cap).
+ *  count is 1-based (the retry about to fire). */
+export function errorRetryBackoffMs(count) {
+    switch (count) {
+        case 1: return 5_000;
+        case 2: return 10_000;
+        case 3: return 20_000;
+        default: return 30_000; // cap from the 4th retry onward
+    }
+}

package/dist/extensions/mega-events.js

@@ -16,3 +16,4 @@ export * from "./mega-events/agent-handlers.js";
 export * from "./mega-events/context-handler.js";
 export * from "./mega-events/compact-handlers.js";
 export * from "./mega-events/perf-handler.js";
+export * from "./mega-events/error-classifier.js";

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

@@ -49,6 +49,9 @@ export class MegaRuntime {
         recallInjections: 0,
         cacheHitTokens: 0,
         lengthStopPending: false,
+        errorRetryCount: 0,
+        errorRetryUntil: 0,
+        consecutiveErrors: 0,
     };
     // v0.8.6 cache-stability: the cached live-trim view for the current
     // compaction epoch. Set after a fresh runCompact + computeLiveTrimCut, and
@@ -486,6 +489,16 @@ export class MegaRuntime {
                 cacheHit: { sessionSec: sec(this.rt.cacheHitTokens), totalSec: sec(cacheHitsTotalTokens) },
             },
             model,
+            // S38.8: error-retry state for the dashboard "retries" tile. The field is
+            // declared on DashboardSnapshot (mega-dashboard.ts) and surfaced here so the
+            // dashboard can render live retry/circuit-breaker status alongside the event
+            // stream (which already carries per-retry events).
+            retries: {
+                errorRetryCount: this.rt.errorRetryCount,
+                consecutiveErrors: this.rt.consecutiveErrors,
+                maxConsecutiveErrors: this.config.maxConsecutiveErrors,
+                errorRetryHardStop: this.config.errorRetryHardStop,
+            },
             diag: {
                 ctxFastGate: this.diagCtxFastGate,
                 liveTrimFires: this.diagLiveTrimFires,
@@ -742,6 +755,9 @@ export class MegaRuntime {
             recallInjections: 0,
             cacheHitTokens: 0,
             lengthStopPending: false,
+            errorRetryCount: 0,
+            errorRetryUntil: 0,
+            consecutiveErrors: 0,
         };
         this.trimCache = null; // v0.8.6: never replay a stale trim into a new session
         this.statusKey = undefined;

package/dist/extensions/mega-teamrun.test.js

@@ -38,6 +38,12 @@ function harness() {
     process.env.MEGACOMPACT_DEBUG = "true";
     process.env.MEGACOMPACT_THRESHOLD_TOKENS = "50";
     process.env.MEGACOMPACT_FAST_GATE_PCT = "1";
+    // Strict race-guard mode double-counts diagAgentEndDurable (sync++ at branch
+    // entry + deferred++ in the setTimeout(500) callback = 6, not 3), lands
+    // compactCalls after the synchronous assertions, and leaks timers that hang
+    // `node --test`. The strict deferred path is covered by the two S38.5 tests
+    // in mega-compact.test.ts. Use the synchronous v0.7.4 path here.
+    process.env.MEGACOMPACT_RACE_GUARD_STRICT = "false";
     process.env.MEGACOMPACT_ANCHOR_USER_MESSAGES = "1";
     process.env.MEGACOMPACT_DURABLE_TRIM_FLOOR = "0"; // piCompactWouldNoop must not skip
     process.env.MEGACOMPACT_MEMORY_AUTO_REVIEW = "false";
@@ -138,6 +144,13 @@ test("control: session_before_compact supplies a durable compaction (parent sett
     assert.equal(res.compaction.firstKeptEntryId, "e2", "reuses pi's boundary (PREVENT-PI-002)");
 });
 test("cleanup", async () => {
-    await closeVectorIndex();
+    // Race closeVectorIndex with a timeout to prevent 40-min hangs.
+    try {
+        await Promise.race([
+            closeVectorIndex(),
+            new Promise((r) => setTimeout(r, 3000)),
+        ]);
+    }
+    catch { /* ignore */ }
     rmSync(baseTmp, { recursive: true, force: true });
 });

package/extensions/dashboard-client/src/styles/base.css

@@ -137,7 +137,8 @@ body {
 	font-size: clamp(12px, 0.8vw, 14px);
 }
 
-.repos th, .repos td {
+.repos th,
+.repos td {
 	padding: 6px 10px;
 	border-bottom: 1px solid var(--border-soft, var(--border));
 	text-align: left;

package/extensions/mega-cache-replay.test.ts

@@ -59,7 +59,7 @@ function harness() {
   // the percent-basis grewEnough (>=10) never trips (no re-compact → pure replay).
   const usage = { tokens: 200000, contextWindow: 200000, percent: 100 as number | null };
 
-  const handlers: Record<string, Function> = {};
+  const handlers: Record<string, Function[]> = {};
   const compactCalls: any[] = [];
 
   function msg(role: string, text: string, toolName?: string): AgentMessage {
@@ -106,7 +106,7 @@ function harness() {
   }
 
   const pi = {
-    on: (ev: string, h: Function) => { handlers[ev] = h; },
+    on: (ev: string, h: Function) => { if (!handlers[ev]) handlers[ev] = []; handlers[ev].push(h); },
     registerCommand: () => {}, registerTool: () => {}, registerShortcut: () => {},
     registerFlag: () => {}, getFlag: () => undefined, registerMessageRenderer: () => {},
     registerEntryRenderer: () => {}, sendMessage: () => {}, sendUserMessage: () => {},
@@ -121,7 +121,7 @@ function harness() {
   mod.default(pi);
   const { lastRuntime } = require("./mega-events.js") as { lastRuntime: any };
 
-  const fire = (ev: string, event: any, ctx: any) => handlers[ev](event, ctx);
+  const fire = async (ev: string, event: any, ctx: any) => { let r: any; for (const h of handlers[ev] || []) r = await h(event, ctx); return r; };
   return {
     stateDir, handlers, compactCalls, fire, ctx: makeCtx, usage, buildSession,
     runtime: lastRuntime, // MegaRuntime with diag* counters + rt + trimCache