pi-mega-compact 0.21.3 → 0.21.4

package/extensions/mega-pipeline/compact/run.ts

@@ -166,6 +166,9 @@ function doCompact(
 		touchSession(sid, root, runtime.currentStateDir);
 		logDaily(sid, "compact", result.checkpointId, saved, runtime.currentStateDir);
 	} catch {
+		// Sprint H (Option A): session-activity / daily-log write is an internal
+		// store-write failure — feed the separate `storeErrorRate` axis.
+		runtime.recordInternalError("store_write");
 		/* non-fatal: stats bookkeeping only */
 	}
 
@@ -183,10 +186,14 @@ function doCompact(
 					if (n > 0) runtime.pushTicker(`${C.green}∫${C.reset} consolidated ${n} memory dup${n === 1 ? "" : "s"}`);
 				},
 				() => {
+					// Sprint H (Option A): memory-consolidation write failure.
+					runtime.recordInternalError("store_write");
 					/* swallow: consolidate failures must never surface to the user */
 				},
 			);
 		} catch {
+			// Sprint H (Option A): memory-consolidation write failure (sync throw).
+			runtime.recordInternalError("store_write");
 			/* non-fatal */
 		}
 	}
@@ -259,6 +266,8 @@ function doCompact(
 				}
 			}
 		} catch {
+			// Sprint H (Option A): RAPTOR tree-refresh write failure.
+			runtime.recordInternalError("vector_index");
 			/* non-fatal: tree refresh never blocks a compaction */
 		}
 	}
@@ -278,6 +287,8 @@ function doCompact(
 					latest.checkpointId,
 					latest.embedding,
 				).catch(() => {
+					// Sprint H (Option A): async global vector-index upsert failure.
+					runtime.recordInternalError("vector_index");
 					/* non-fatal: index refresh never blocks a compaction */
 				});
 			}

package/extensions/mega-runtime/helpers.ts

@@ -9,6 +9,7 @@
 import { join, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
 import { readFileSync } from "node:fs";
+import { normalizeSessionId } from "../../src/store.js";
 
 // ── Public string constants ────────────────────────────────────────────────
 // Exported via the barrel — consumers (mega-events.ts, mega-pipeline.ts) use
@@ -111,3 +112,48 @@ export function ownVersion(): string {
 	CACHED_VERSION = v;
 	return v;
 }
+
+/**
+ * createSessionRuntime() — the default per-session runtime state.
+ *
+ * Extracted from runtime.ts (delegate-shell split) so the MegaRuntime class
+ * stays a field-declarations + 1-line-delegate shell. Returns a fresh
+ * SessionRuntime for each session (reset on session_start / session_tree).
+ * Mirrors the neuralwatt-mcr per-session closure.
+ */
+export function createSessionRuntime(): SessionRuntime {
+	return {
+		sessionId: normalizeSessionId(undefined),
+		persistedThisSession: false,
+		lastCheckpointId: undefined,
+		lastCompactedFrom: 0,
+		lastCompactedTokens: 0,
+		dedupSkips: 0,
+		dedupAttempts: 0,
+		tokensSaved: 0,
+		lastCompactAt: null,
+		lastRecallAt: null,
+		lastInjectAt: null,
+		_prevCacheHitPct: null,
+		_lastCacheHealthScore: undefined,
+		lastNativeCompactAt: null,
+		compactCount: 0,
+		recallInjections: 0,
+		cacheHitTokens: 0,
+		lengthStopPending: false,
+		errorRetryCount: 0,
+		errorRetryUntil: 0,
+		consecutiveErrors: 0,
+		lastErrorRetryAt: 0,
+		retryNudgePending: false,
+		errorRetrySessionCount: 0,
+		lastErrorText: undefined,
+		errorTextRepeatCount: 0,
+		poisonedAdviseSent: false,
+		providerOutageAdvised: false,
+		poisonedCompactSignatures: new Set(),
+		recallInjectedThisTurn: false,
+		poisonedCount: 0,
+		extensionInitiatedTurn: false,
+	};
+}

package/extensions/mega-runtime/internal-errors.ts

@@ -0,0 +1,30 @@
+/**
+ * internal-errors.ts — Sprint H (Finding 3 / Option A) instrumentation.
+ *
+ * Free-function + context-interface sibling of `runtime.ts` (delegate-shell
+ * pattern). Holds the body of `recordInternalError(category)` so the
+ * `MegaRuntime` class stays a field-declarations + 1-line-delegate shell.
+ *
+ * Pushes a store/service-write failure category into the `recentInternalErrors`
+ * ring (capped at RING_MAX, shift when over). Called AT each failure emit site
+ * (see the §2.3a audit in docs/specs/c2-resume-and-health-fixes.md) — never by
+ * a central events.log filter. Feeds the distinct `storeErrorRate` 6th health
+ * axis (committed separately in Sprint H axis work).
+ */
+import type { MegaRuntime } from "./runtime.js";
+
+/**
+ * RING_MAX — the cap for the rolling health ring buffers
+ * (`recentTurnEmbeddings`, `recentErrorCategories`, `recentInternalErrors`).
+ * Defined here (with the ring writer) and re-exported from runtime.ts so the
+ * ring + its writer live together; health-handler.ts imports it.
+ */
+export const RING_MAX = 5;
+
+/** Push a category into the internal-error ring. Mirrors `recentErrorCategories`. */
+export function recordInternalErrorImpl(rt: MegaRuntime, category: string): void {
+	rt.recentInternalErrors.push(category);
+	if (rt.recentInternalErrors.length > RING_MAX) {
+		rt.recentInternalErrors.shift();
+	}
+}

package/extensions/mega-runtime/runtime-instrumentation.ts

@@ -0,0 +1,195 @@
+/**
+ * runtime-instrumentation.ts — base class holding MegaRuntime's field
+ * declarations (diagnostic counters + context-health ring buffers + the Sprint-H
+ * internal-error ring + live display/cache-stability state).
+ *
+ * Extracted from runtime.ts (delegate-shell split) so the MegaRuntime class
+ * stays a field-declarations + 1-line-delegate shell. As a base class, the
+ * field NAMES are unchanged (`this.diagLiveTrimFires`, `this.trimCache`, etc.) —
+ * call sites across the codebase and tests need no edits.
+ */
+import type { AgentMessage } from "@earendil-works/pi-agent-core";
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { ModelSnapshot, GameState } from "../../src/store/sqlite.js";
+import type { TickerEntry, WidgetData } from "./widget.js";
+import type { FSWatcher } from "node:fs";
+
+/**
+ * DIAG counters for the "team run doesn't relieve context" investigation.
+ * Plain integers, incremented at the three compaction decision points. They
+ * let a headless test drive the real event handlers and assert the firing
+ * cadence without scraping log files. Inert in production (the live-trim and
+ * before-compact probes also emit logger.info, but these counters are always
+ * updated and cost nothing).
+ */
+export class RuntimeInstrumentation {
+	diagLiveTrimFires = 0; // context handler returned a trimmed view
+	diagLiveTrimReplays = 0; // v0.8.6: trim view returned via cached replay (skipped re-compact)
+	diagBeforeCompactFires = 0; // session_before_compact handler entered
+	diagBeforeCompactSupplied = 0; // session_before_compact supplied our trim
+	diagAgentEndIdle = 0; // agent_end with activeAgents===0
+	diagAgentEndDurable = 0; // agent_end fired ctx.compact() (mid-run durable trim)
+	diagAgentEndDurableSkipRecent = 0; // agent_end skipped ctx.compact() — compaction in last 10s (race guard)
+	// Per-skip-path counters for the team-run diagnosis.
+	diagCtxFastGate = 0; // returned at token fast-gate (below threshold)
+	diagCtxNoCompact = 0; // autoCompactCheck().shouldCompact === false
+	diagCtxDebounce = 0; // debounceUntil not yet elapsed
+	diagCtxRunSkipped = 0; // runCompact() returned skipped
+	diagCtxCutNull = 0; // computeLiveTrimCut returned null (anchor/boundary)
+	diagCtxThrown = 0; // live-trim try threw (caught)
+
+	// Context health instrumentation (v0.12): rolling ring buffers for
+	// drift detection + cache poison Layer 1 hash baseline.
+	recentTurnEmbeddings: number[][] = [];
+	recentErrorCategories: (string | null)[] = [];
+	lastPrefixHash: string | null = null;
+	lastErrorCategory: string | null = null;
+
+	// Sprint H (Finding 3): a SEPARATE internal-error ring fed by explicit
+	// `recordInternalError(category)` calls at each store/service-write failure
+	// emit site (Option A — NOT a central events.log filter). This captures
+	// internal store-write failures which the API-error `errorRate` ring never
+	// sees. The health-handler computes a distinct `storeErrorRate` 6th axis.
+	// Mirrors `recentErrorCategories` / `lastErrorCategory` exactly (cap = RING_MAX).
+	recentInternalErrors: string[] = [];
+
+	/**
+	 * S26 capture instrumentation: the "model_snapshots empty → $0.00 cost card"
+	 * bug was invisible because captureModel swallowed the DB write in a silent
+	 * `catch {}`. These always-updated counters (zero cost) let a headless test or
+	 * a live capture tell whether captureModel ran and whether the snapshot landed.
+	 */
+	diagCaptureModelCalls = 0; // captureModel entered with a populated ctx.model
+	diagCaptureModelFails = 0; // recordModelSnapshot threw → model_snapshots stays empty
+
+	// ── Live display / cache-stability state (moved from runtime.ts shell) ────
+
+	// v0.8.6 cache-stability: the cached live-trim view for the current
+	// compaction epoch. Set after a fresh runCompact + computeLiveTrimCut, and
+	// replayed verbatim on subsequent gated context events in the SAME epoch
+	// (same checkpointId) so the provider KV-cache prefix stays stable instead
+	// of being invalidated by a freshly regenerated summary + sentinel every
+	// fire. Invalidated on session restart (resetRuntime) and on any native
+	// durable compaction (session_compact) that truncates the transcript.
+	trimCache: {
+		checkpointId: string;
+		cut: number;
+		summaryAgentMsg: AgentMessage;
+		ctxPct: number | null;
+		ctxTokens: number | null;
+	} | null = null;
+	debounceUntil = 0;
+	// S16: debounce for the agent_end resume nudge (avoid busy-loops).
+	resumeNudgeUntil = 0;
+	// Agent tracking for real-time widget updates
+	activeAgents = 0;
+	currentTurn = 0;
+	// S33: transient MEGA CACHE flare flag (armed by the turn_end scoring hook
+	// when cachePct > 100). Copied into widgetData.megaCacheFlare on the next
+	// snapshot() so the widget renders the oopsie gag, then reset (one cycle).
+	megaCacheFlare = false;
+	/** v0.8.3: ambient effect state for animated panel borders keyed off
+	 *  status transitions (level-up, mega-cache overshoot, achievement unlock,
+	 *  compaction start). Threaded into widgetData as `activeEffect`; the widget
+	 *  computes the per-frame phase from startedAt vs Date.now() (non-expired).
+	 *  Null when idle/expired. */
+	activeEffect: { type: "pulse" | "flash"; role: "accent" | "mega" | "red"; startedAt: number; durationMs: number } | null = null;
+	megaCacheFlarePct = 0;
+	levelUpFlare = false;
+	lastLevel = 0;
+	// S35: transient achievement-unlock flare (armed by the scoring hooks after
+	// evaluateAndUnlockAchievements returns newly-unlocked titles). Copied into
+	// widgetData.achievementFlare on the next snapshot() so the widget renders the
+	// unlock toast, then reset (one cycle — mirrors megaCacheFlare/levelUpFlare).
+	achievementFlare = false;
+	achievementFlareTitles: string[] = [];
+	// S33: last cumulative dedup-collapsed count seen by the session_compact
+	// hook, so we only record the DELTA as the dedupe score (leaderboard sums).
+	lastDedupCollapsed = 0;
+	// Recall block produced by auto-inline (resume/branch) that the next
+	// before_agent_start should prepend to the system prompt. Unset after use.
+	pendingRecallBlock: string | undefined;
+	// S21: memory recall block, parallel to pendingRecallBlock. Same one-shot
+	// semantics; composed with the checkpoint block in before_agent_start.
+	pendingMemoryRecallBlock: string | undefined;
+	statusKey: string | undefined; // current status text for dashboard
+	// Active model/provider (for real cost estimation). Captured from ctx.model
+	// on model_select + session_start; persisted to SQL so cost + the dashboard
+	// can read it without a live ctx.
+	currentModel: ModelSnapshot | undefined;
+	// Live "what it's doing right now" timestamp, used for the fresh-window.
+	lastActivityAt = 0;
+	// Live per-tier dedup trace (Phase 1): e.g. "L0 ✓ → L1 ✓ → L2 0.91 → stored".
+	// Built from the store's sync onTier callback during a compaction so the user
+	// watches each tier evaluate in real time. Cleared once the outcome settles.
+	tierTrace: string | undefined;
+	// Phase 3 — standout toolbar state.
+	// Recall/activity ticker: a small ring buffer (≤5) of recent compact/recall
+	// events so the widget shows a live history instead of a single last action.
+	ticker: TickerEntry[] = [];
+	readonly TICKER_MAX = 5;
+	// Pulsing status: set true while a compaction is in flight, cleared on result.
+	pulsing = false;
+	// S21.2: set by `applyMemoryOps` when a memory add/replace/remove lands in
+	// the current compaction. The pipeline reads this after a successful compact
+	// to decide whether to fire `consolidateMemories` (skip the work entirely
+	// when no memory rows changed).
+	memoriesTouchedThisCompaction = 0;
+	// Rolling "saved" goal for the progress bar — grows as we save more, so the
+	// bar always has a meaningful denominator (never sits at 100% forever).
+	savedGoal = 50_000;
+	// Last explain-why line (dedup reason / anchor-kept / superseded), surfaced
+	// while fresh.
+	lastWhy: string | undefined = undefined;
+	// v0.8.8 Perf dashboard instrumentation: turn/provider start timestamps +
+	// the 5s cpu/mem interval handle (one per MegaRuntime, cleared in dispose()).
+	perfTurnStart = 0;
+	perfProviderStart = 0;
+	perfCpuInterval: ReturnType<typeof setInterval> | null = null;
+	perfCpuBaseline: { user: number; sys: number } | undefined;
+
+	// Context tracking for the dashboard (updated in the context handler).
+	lastCtxTokens: number | null = null;
+	lastCtxPercent: number | null = null;
+	lastCtxWindow = 0;
+
+	// Latest computed widget payload (recomputed per snapshot, rendered per frame).
+	widgetData: WidgetData | null = null;
+	// v0.8.5: material-change signature from the last full snapshot() body. When
+	// the next snapshot()'s signature matches, the expensive recompute (6 sync
+	// SQLite opens) + writeFileSync(dashboard.json) are skipped — only the
+	// (already-registered) widget factory is refreshed. Kills the per-event
+	// main-thread block during typing/idle streaming with no material change.
+	lastSnapshotSig: string | null = null;
+	lastHeartbeatAt: number = 0;
+	// v0.8.5: bumped whenever the cached game-state memo is evicted (bumpGameState
+	// for in-process /mega-game writes, the fs.watch callback for cross-process
+	// dashboard-server writes, and bindRepo on repo switch) so the snapshot gate
+	// invalidates and the widget re-reads theme/mode after the change.
+	gameStateBump = 0;
+	// Cached cross-repo drift status (recomputed at most every 30s — it opens the
+	// machine-wide registry DB, so we don't want to do it on every render frame).
+	driftCache: { at: number; status: "ok" | "warn" } | null = null;
+	// S31: cached game-mode state (game_mode_on/theme/tui_display_mode). Lazily
+	// read from the game_state SQLite row on the first widget render, then
+	// memoized until bumpGameState() evicts it (called by /mega-game after a
+	// write) so the widget picks up theme/mode/level changes live without
+	// re-querying the DB on every render frame.
+	cachedGameState: GameState | undefined;
+	// S32: fs.watch on the current repo's sqlite.db so cross-process writes
+	// (e.g. the dashboard server's PUT /api/game-state, which runs as a detached
+	// child with no MegaRuntime ref) evict the cached game-state memo. Without
+	// this, /mega-game's in-process bumpGameState() is the only eviction trigger
+	// and the widget would keep showing stale theme/mode/toggle after a dashboard
+	// edit until a restart. The watcher tracks currentStateDir — closed + re-opened
+	// by ensureGameStateWatcher() on every bindRepo repo switch. Non-fatal: any
+	// fs.watch failure (missing file / platform issue) is swallowed; the next
+	// getCachedGameState() snapshot re-queries the DB anyway.
+	gameStateWatcher?: FSWatcher;
+	gameStateWatchDir?: string;
+	// P2: the last ExtensionContext handed to snapshot()/renderWidget(), stashed
+	// so the fs.watch game-state callback can force a widget re-render without
+	// a context event (cross-process dashboard edits while pi is idle). Cleared
+	// implicitly on construction (undefined → watcher skips until first snap).
+	lastWidgetCtx?: ExtensionContext;
+}

package/extensions/mega-runtime/runtime.ts

@@ -15,13 +15,12 @@
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 import type { AgentMessage } from "@earendil-works/pi-agent-core";
 import { join } from "node:path";
-import type { FSWatcher } from "node:fs";
 import { VectorStore } from "../../src/vectorStore.js";
 import type { toEngineMessages } from "../../src/adapt.js";
-import { normalizeSessionId } from "../../src/store.js";
 import { Logger } from "../../src/log.js";
+
+export { RING_MAX } from "./internal-errors.js";
 import type {
-	ModelSnapshot,
 	GameState,
 } from "../../src/store/sqlite.js";
 import type {
@@ -32,10 +31,7 @@ import { Dashboard } from "../mega-dashboard.js";
 import type {
 	SessionRuntime,
 } from "./helpers.js";
-import type {
-	TickerEntry,
-	WidgetData,
-} from "./widget.js";
+import { createSessionRuntime } from "./helpers.js";
 import {
 	ensureGameStateWatcherImpl,
 	getCachedGameStateImpl,
@@ -61,12 +57,14 @@ import {
 } from "./pressure-getters.js";
 import { resetRuntimeImpl } from "./reset-runtime.js";
 import { appendEventImpl } from "./append-event.js";
+import { recordInternalErrorImpl } from "./internal-errors.js";
+import { RuntimeInstrumentation } from "./runtime-instrumentation.js";
 import { getStateDirImpl } from "./get-state-dir.js";
 import { renderWidgetImpl } from "./render-widget.js";
 import { setStatusImpl } from "./status.js";
 import { engineViewImpl } from "./engine-view.js";
 
-export class MegaRuntime {
+export class MegaRuntime extends RuntimeInstrumentation {
 	config: MegaConfig;
 	// Store/dashboard/logger are rebound per-repo by bindRepo() so each git repo
 	// gets its own isolated state dir. They start bound to the global default.
@@ -77,208 +75,14 @@ export class MegaRuntime {
 	currentStateDir: string;
 
 	// The only mutable per-session state. Reset on session_start / session_tree.
-	rt: SessionRuntime = {
-		sessionId: normalizeSessionId(undefined),
-		persistedThisSession: false,
-		lastCheckpointId: undefined,
-		lastCompactedFrom: 0,
-		lastCompactedTokens: 0,
-		dedupSkips: 0,
-		dedupAttempts: 0,
-		tokensSaved: 0,
-		lastCompactAt: null,
-		lastRecallAt: null,
-		lastInjectAt: null,
-		_prevCacheHitPct: null,
-		_lastCacheHealthScore: undefined,
-		lastNativeCompactAt: null,
-		compactCount: 0,
-		recallInjections: 0,
-		cacheHitTokens: 0,
-		lengthStopPending: false,
-		errorRetryCount: 0,
-		errorRetryUntil: 0,
-		consecutiveErrors: 0,
-		lastErrorRetryAt: 0,
-		retryNudgePending: false,
-		errorRetrySessionCount: 0,
-		lastErrorText: undefined,
-		errorTextRepeatCount: 0,
-		poisonedAdviseSent: false,
-		providerOutageAdvised: false,
-		poisonedCompactSignatures: new Set(),
-		// S53: tracks whether withRecallTail injected this turn (consumed at turn_end).
-		recallInjectedThisTurn: false,
-		poisonedCount: 0,
-		extensionInitiatedTurn: false,
-	};
-	// v0.8.6 cache-stability: the cached live-trim view for the current
-	// compaction epoch. Set after a fresh runCompact + computeLiveTrimCut, and
-	// replayed verbatim on subsequent gated context events in the SAME epoch
-	// (same checkpointId) so the provider KV-cache prefix stays stable instead
-	// of being invalidated by a freshly regenerated summary + sentinel every
-	// fire. Invalidated on session restart (resetRuntime) and on any native
-	// durable compaction (session_compact) that truncates the transcript.
-	trimCache: {
-		checkpointId: string;
-		cut: number;
-		summaryAgentMsg: AgentMessage;
-		ctxPct: number | null;
-		ctxTokens: number | null;
-	} | null = null;
-	debounceUntil = 0;
-	// S16: debounce for the agent_end resume nudge (avoid busy-loops).
-	resumeNudgeUntil = 0;
-	// Agent tracking for real-time widget updates
-	activeAgents = 0;
-	currentTurn = 0;
-	// S33: transient MEGA CACHE flare flag (armed by the turn_end scoring hook
-	// when cachePct > 100). Copied into widgetData.megaCacheFlare on the next
-	// snapshot() so the widget renders the oopsie gag, then reset (one cycle).
-	megaCacheFlare = false;
-	/** v0.8.3: ambient effect state for animated panel borders keyed off
-	 *  status transitions (level-up, mega-cache overshoot, achievement unlock,
-	 *  compaction start). Threaded into widgetData as `activeEffect`; the widget
-	 *  computes the per-frame phase from startedAt vs Date.now() (non-expired).
-	 *  Null when idle/expired. */
-	activeEffect: { type: "pulse" | "flash"; role: "accent" | "mega" | "red"; startedAt: number; durationMs: number } | null = null;
-	megaCacheFlarePct = 0;
-	levelUpFlare = false;
-	lastLevel = 0;
-	// S35: transient achievement-unlock flare (armed by the scoring hooks after
-	// evaluateAndUnlockAchievements returns newly-unlocked titles). Copied into
-	// widgetData.achievementFlare on the next snapshot() so the widget renders the
-	// unlock toast, then reset (one cycle — mirrors megaCacheFlare/levelUpFlare).
-	achievementFlare = false;
-	achievementFlareTitles: string[] = [];
-	// S33: last cumulative dedup-collapsed count seen by the session_compact
-	// hook, so we only record the DELTA as the dedupe score (leaderboard sums).
-	lastDedupCollapsed = 0;
-	// Recall block produced by auto-inline (resume/branch) that the next
-	// before_agent_start should prepend to the system prompt. Unset after use.
-	pendingRecallBlock: string | undefined;
-	// S21: memory recall block, parallel to pendingRecallBlock. Same one-shot
-	// semantics; composed with the checkpoint block in before_agent_start.
-	pendingMemoryRecallBlock: string | undefined;
-	statusKey: string | undefined; // current status text for dashboard
-	// Active model/provider (for real cost estimation). Captured from ctx.model
-	// on model_select + session_start; persisted to SQL so cost + the dashboard
-	// can read it without a live ctx.
-	currentModel: ModelSnapshot | undefined;
-	// Live "what it's doing right now" timestamp, used for the fresh-window.
-	lastActivityAt = 0;
-	// Live per-tier dedup trace (Phase 1): e.g. "L0 ✓ → L1 ✓ → L2 0.91 → stored".
-	// Built from the store's sync onTier callback during a compaction so the user
-	// watches each tier evaluate in real time. Cleared once the outcome settles.
-	tierTrace: string | undefined;
-	// Phase 3 — standout toolbar state.
-	// Recall/activity ticker: a small ring buffer (≤5) of recent compact/recall
-	// events so the widget shows a live history instead of a single last action.
-	ticker: TickerEntry[] = [];
-	readonly TICKER_MAX = 5;
-	// Pulsing status: set true while a compaction is in flight, cleared on result.
-	pulsing = false;
-	// S21.2: set by `applyMemoryOps` when a memory add/replace/remove lands in
-	// the current compaction. The pipeline reads this after a successful compact
-	// to decide whether to fire `consolidateMemories` (skip the work entirely
-	// when no memory rows changed).
-	memoriesTouchedThisCompaction = 0;
-	// Rolling "saved" goal for the progress bar — grows as we save more, so the
-	// bar always has a meaningful denominator (never sits at 100% forever).
-	savedGoal = 50_000;
-	// Last explain-why line (dedup reason / anchor-kept / superseded), surfaced
-	// while fresh.
-	lastWhy: string | undefined = undefined;
-	// v0.8.8 Perf dashboard instrumentation: turn/provider start timestamps +
-	// the 5s cpu/mem interval handle (one per MegaRuntime, cleared in dispose()).
-	perfTurnStart = 0;
-	perfProviderStart = 0;
-	perfCpuInterval: ReturnType<typeof setInterval> | null = null;
-	perfCpuBaseline: { user: number; sys: number } | undefined;
-
-	// Context tracking for the dashboard (updated in the context handler).
-	lastCtxTokens: number | null = null;
-	lastCtxPercent: number | null = null;
-	lastCtxWindow = 0;
-
-	// Latest computed widget payload (recomputed per snapshot, rendered per frame).
-	widgetData: WidgetData | null = null;
-	// v0.8.5: material-change signature from the last full snapshot() body. When
-	// the next snapshot()'s signature matches, the expensive recompute (6 sync
-	// SQLite opens) + writeFileSync(dashboard.json) are skipped — only the
-	// (already-registered) widget factory is refreshed. Kills the per-event
-	// main-thread block during typing/idle streaming with no material change.
-	lastSnapshotSig: string | null = null;
-	lastHeartbeatAt: number = 0;
-	// v0.8.5: bumped whenever the cached game-state memo is evicted (bumpGameState
-	// for in-process /mega-game writes, the fs.watch callback for cross-process
-	// dashboard-server writes, and bindRepo on repo switch) so the snapshot gate
-	// invalidates and the widget re-reads theme/mode after the change.
-	gameStateBump = 0;
-	// Cached cross-repo drift status (recomputed at most every 30s — it opens the
-	// machine-wide registry DB, so we don't want to do it on every render frame).
-	driftCache: { at: number; status: "ok" | "warn" } | null = null;
-	// S31: cached game-mode state (game_mode_on/theme/tui_display_mode). Lazily
-	// read from the game_state SQLite row on the first widget render, then
-	// memoized until bumpGameState() evicts it (called by /mega-game after a
-	// write) so the widget picks up theme/mode/level changes live without
-	// re-querying the DB on every render frame.
-	cachedGameState: GameState | undefined;
-	// S32: fs.watch on the current repo's sqlite.db so cross-process writes
-	// (e.g. the dashboard server's PUT /api/game-state, which runs as a detached
-	// child with no MegaRuntime ref) evict the cached game-state memo. Without
-	// this, /mega-game's in-process bumpGameState() is the only eviction trigger
-	// and the widget would keep showing stale theme/mode/toggle after a dashboard
-	// edit until a restart. The watcher tracks currentStateDir — closed + re-opened
-	// by ensureGameStateWatcher() on every bindRepo repo switch. Non-fatal: any
-	// fs.watch failure (missing file / platform issue) is swallowed; the next
-	// getCachedGameState() snapshot re-queries the DB anyway.
-	gameStateWatcher?: FSWatcher;
-	gameStateWatchDir?: string;
-	// P2: the last ExtensionContext handed to snapshot()/renderWidget(), stashed
-	// so the fs.watch game-state callback can force a widget re-render without
-	// a context event (cross-process dashboard edits while pi is idle). Cleared
-	// implicitly on construction (undefined → watcher skips until first snap).
-	lastWidgetCtx?: ExtensionContext;
-
-	/**
-	 * DIAG counters for the "team run doesn't relieve context" investigation.
-	 * Plain integers, incremented at the three compaction decision points. They
-	 * let a headless test drive the real event handlers and assert the firing
-	 * cadence without scraping log files. Inert in production (the live-trim and
-	 * before-compact probes also emit logger.info, but these counters are always
-	 * updated and cost nothing).
-	 */
-	diagLiveTrimFires = 0; // context handler returned a trimmed view
-	diagLiveTrimReplays = 0; // v0.8.6: trim view returned via cached replay (skipped re-compact)
-	diagBeforeCompactFires = 0; // session_before_compact handler entered
-	diagBeforeCompactSupplied = 0; // session_before_compact supplied our trim
-	diagAgentEndIdle = 0; // agent_end with activeAgents===0
-	diagAgentEndDurable = 0; // agent_end fired ctx.compact() (mid-run durable trim)
-	diagAgentEndDurableSkipRecent = 0; // agent_end skipped ctx.compact() — compaction in last 10s (race guard)
-	// Per-skip-path counters for the team-run diagnosis.
-	diagCtxFastGate = 0; // returned at token fast-gate (below threshold)
-	diagCtxNoCompact = 0; // autoCompactCheck().shouldCompact === false
-	diagCtxDebounce = 0; // debounceUntil not yet elapsed
-	diagCtxRunSkipped = 0; // runCompact() returned skipped
-	diagCtxCutNull = 0; // computeLiveTrimCut returned null (anchor/boundary)
-	diagCtxThrown = 0; // live-trim try threw (caught)
-
-	// Context health instrumentation (v0.12): rolling ring buffers for
-	// drift detection + cache poison Layer 1 hash baseline.
-	recentTurnEmbeddings: number[][] = [];
-	recentErrorCategories: (string | null)[] = [];
-	lastPrefixHash: string | null = null;
-	lastErrorCategory: string | null = null;
+	// Initialized via createSessionRuntime() (helpers.ts delegate-shell split).
+	rt: SessionRuntime = createSessionRuntime();
 
-	/**
-	 * S26 capture instrumentation: the "model_snapshots empty → $0.00 cost card"
-	 * bug was invisible because captureModel swallowed the DB write in a silent
-	 * `catch {}`. These always-updated counters (zero cost) let a headless test or
-	 * a live capture tell whether captureModel ran and whether the snapshot landed.
-	 */
-	diagCaptureModelCalls = 0; // captureModel entered with a populated ctx.model
-	diagCaptureModelFails = 0; // recordModelSnapshot threw → model_snapshots stays empty
+	// All other field declarations (instrumentation counters, context-health
+	// rings, the Sprint-H internal-error ring, live display / cache-stability
+	// state) live on the RuntimeInstrumentation base class — see
+	// runtime-instrumentation.ts. Field names are unchanged (this.diagXxx,
+	// this.trimCache, this.recentInternalErrors, etc).
 
 	// ---- pressure accessors (bodies in pressure-getters.ts) -------------------
 
@@ -301,6 +105,7 @@ export class MegaRuntime {
 	}
 
 	constructor(config: MegaConfig) {
+		super();
 		this.config = config;
 		this.store = new VectorStore({
 			dedupSim: config.dedupSim,
@@ -362,6 +167,21 @@ export class MegaRuntime {
 		appendEventImpl(this, event, fields);
 	}
 
+	/**
+	 * Sprint H (Finding 3 / Option A): record an internal store/service-write
+	 * failure category into the `recentInternalErrors` ring. Called AT each
+	 * failure emit site (see the §2.3a audit in
+	 * docs/specs/c2-resume-and-health-fixes.md) — never by a central log filter.
+	 * Mirrors `recentErrorCategories` (cap = RING_MAX, shift when over).
+	 *
+	 * NOTE (process boundary): the ring is per-runtime / in-memory. A child
+	 * subprocess's failures do NOT reach the parent's ring; the parent-side
+	 * dashboard already aggregates events.log cross-process, so nothing is lost.
+	 */
+	recordInternalError(category: string): void {
+		recordInternalErrorImpl(this, category);
+	}
+
 	/** S21: state dir of the currently bound repo (where memories live) — thin
 	 *  delegate to `getStateDirImpl` (get-state-dir.ts). */
 	getStateDir(): string {

package/extensions/mega-runtime/state.ts

@@ -5,4 +5,4 @@
  * every existing `import { MegaRuntime } from "./state.js"` continues to
  * resolve without changes.
  */
-export { MegaRuntime } from "./runtime.js";
+export { MegaRuntime, RING_MAX } from "./runtime.js";

package/extensions/mega-runtime/widget.ts

@@ -129,7 +129,7 @@ export function buildWidgetLines(
 		`${C.gray}all-time${C.reset} ${fmtTokens(wd.repoIn)}→${fmtTokens(wd.repoKept)} kept ${C.blue}(${wd.rTxt}% freed)${C.reset}`,
 		`${wd.repoChk} chk/${wd.repoSess} sess`,
 		`${C.gray}mem${C.reset} ${wd.embedderName} · ${wd.chk} chunks · ${C.blue}comp ${wd.compStr}${C.reset}`,
-		`${C.gray}drift${C.reset} ${wd.driftStatus === "ok" ? C.green : C.amber}${wd.driftStatus}${C.reset}`,
+		`${C.gray}comp lag${C.reset} ${wd.driftStatus === "ok" ? C.green : C.amber}${wd.driftStatus}${C.reset}`,
 		`${C.gray}compact${C.reset} ${sinceCompactStr(wd.sinceCompact)}`,
 		...(wd.perTurnCacheHitPct != null
 			? [

package/extensions/mega-turn-store.ts

@@ -12,6 +12,7 @@
 import {
 	createTurnStore,
 	type TurnStore,
+	type TurnReader,
 	type TurnEntry,
 	type TurnRecallEntry,
 	type TurnHydeTelemetry,
@@ -40,6 +41,11 @@ function storeFor(stateDir: string): TurnStore {
 	return s;
 }
 
+/** Read-only view of the turn store for a state dir (e.g. nextTurnIndexFor). */
+export function turnReaderFor(stateDir: string): TurnReader {
+	return storeFor(stateDir).asReader();
+}
+
 /** Map a legacy RecallSource onto the contract `TurnRecallEntry.source` enum. */
 function mapSource(s: string): TurnRecallEntry["source"] {
 	switch (s) {
@@ -77,6 +83,8 @@ export function recordTurnWrite(
 		conversationId: string;
 		sessionId: string;
 		turnIndex: number;
+		/** S49R: pi's per-session counter, carried for the raw_transcript join. */
+		sessionTurnIndex?: number;
 		role: string;
 		startedAt?: number;
 		endedAt?: number;
@@ -100,6 +108,7 @@ export function recordTurnWrite(
 		conversationId: input.conversationId,
 		sessionId: input.sessionId,
 		turnIndex: input.turnIndex,
+		sessionTurnIndex: input.sessionTurnIndex,
 		role: input.role as TurnEntry["role"],
 		endedAt: input.endedAt ?? input.startedAt ?? Date.now(),
 		ctxTokens: input.ctxTokens,