pi-mega-compact 0.21.2 → 0.21.4

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

@@ -13,9 +13,10 @@
  */
 import { join } from "node:path";
 import { VectorStore } from "../../src/vectorStore.js";
-import { normalizeSessionId } from "../../src/store.js";
 import { Logger } from "../../src/log.js";
+export { RING_MAX } from "./internal-errors.js";
 import { Dashboard } from "../mega-dashboard.js";
+import { createSessionRuntime } from "./helpers.js";
 import { ensureGameStateWatcherImpl, getCachedGameStateImpl, refreshWidgetGameStateImpl, bumpGameStateImpl, disposeRuntimeImpl, } from "./game-state.js";
 import { setEffectImpl, armMegaCacheFlareImpl, armAchievementFlareImpl, makeTierCallbackImpl, pushTickerImpl, } from "./effects.js";
 import { ensurePerfIntervalImpl } from "./perf.js";
@@ -25,11 +26,13 @@ import { snapshotImpl } from "./runtime-snapshot.js";
 import { pressureImpl, effectiveThresholdImpl, pressureBandImpl, } 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;
     // 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.
@@ -39,197 +42,13 @@ export class MegaRuntime {
     activeRepoRoot = null;
     currentStateDir;
     // The only mutable per-session state. Reset on session_start / session_tree.
-    rt = {
-        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 = 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 = 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 = [];
-    // 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;
-    // S21: memory recall block, parallel to pendingRecallBlock. Same one-shot
-    // semantics; composed with the checkpoint block in before_agent_start.
-    pendingMemoryRecallBlock;
-    statusKey; // 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;
-    // 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;
-    // 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 = [];
-    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 = 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 = null;
-    perfCpuBaseline;
-    // Context tracking for the dashboard (updated in the context handler).
-    lastCtxTokens = null;
-    lastCtxPercent = null;
-    lastCtxWindow = 0;
-    // Latest computed widget payload (recomputed per snapshot, rendered per frame).
-    widgetData = 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 = null;
-    lastHeartbeatAt = 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 = 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;
-    // 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;
-    gameStateWatchDir;
-    // 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;
-    /**
-     * 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 = [];
-    recentErrorCategories = [];
-    lastPrefixHash = null;
-    lastErrorCategory = null;
-    /**
-     * 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
+    // Initialized via createSessionRuntime() (helpers.ts delegate-shell split).
+    rt = createSessionRuntime();
+    // 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) -------------------
     /** Live 0–1 pressure — see `pressureImpl` in pressure-getters.ts for the
      *  dual-basis (percent vs token) reconciliation notes. Thin delegate. */
@@ -247,6 +66,7 @@ export class MegaRuntime {
         return pressureBandImpl(this);
     }
     constructor(config) {
+        super();
         this.config = config;
         this.store = new VectorStore({
             dedupSim: config.dedupSim,
@@ -299,6 +119,20 @@ export class MegaRuntime {
     appendEvent(event, fields) {
         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) {
+        recordInternalErrorImpl(this, category);
+    }
     /** S21: state dir of the currently bound repo (where memories live) — thin
      *  delegate to `getStateDirImpl` (get-state-dir.ts). */
     getStateDir() {

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

@@ -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/dist/extensions/mega-runtime/widget.js

@@ -85,7 +85,7 @@ export function buildWidgetLines(wd, width, activeAgents) {
         `${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/dist/extensions/mega-turn-store.js

@@ -24,6 +24,10 @@ function storeFor(stateDir) {
     }
     return s;
 }
+/** Read-only view of the turn store for a state dir (e.g. nextTurnIndexFor). */
+export function turnReaderFor(stateDir) {
+    return storeFor(stateDir).asReader();
+}
 /** Map a legacy RecallSource onto the contract `TurnRecallEntry.source` enum. */
 function mapSource(s) {
     switch (s) {
@@ -52,6 +56,7 @@ export function recordTurnWrite(config, input, stateDir) {
         conversationId: input.conversationId,
         sessionId: input.sessionId,
         turnIndex: input.turnIndex,
+        sessionTurnIndex: input.sessionTurnIndex,
         role: input.role,
         endedAt: input.endedAt ?? input.startedAt ?? Date.now(),
         ctxTokens: input.ctxTokens,

package/dist/src/bridge/factory.js

@@ -0,0 +1,195 @@
+/**
+ * bridge/factory.ts — `createMegaBridge(opts)` implementation.
+ *
+ * A thin, pi-agnostic wrapper over the engine's compaction / recall / memory /
+ * fork / vector APIs. Stores are constructed lazily on first use (a consumer
+ * that only calls recallMemories pays no VectorStore cost). Exceptions
+ * propagate from every method except `fork` (catches ForkError by design) and
+ * `close` (swallows best-effort cleanup), so failures surface in tests.
+ */
+import { compactSession } from "../engine.js";
+import { recallAndInline, recallAndInlineAsync, recallMemoriesAndInline, } from "../recall.js";
+import { forkFromConversation, ForkError } from "../fork.js";
+import { createTurnStore } from "../store/turns/index.js";
+import { addMemory } from "../store/sqlite/memories.js";
+import { VectorStore, vectorSearch } from "../vectorStore.js";
+import { repoKey } from "../store/repoKey.js";
+/** Map a RecallInjectResult to the bridge's slimmer result contract. */
+function mapRecallResult(r) {
+    return {
+        block: r.block,
+        report: r.report,
+        hitCount: r.toInject.length,
+        empty: r.empty,
+    };
+}
+/** Map the memoryRecallAndInline tuple result to the bridge contract. */
+function mapMemoryResult(r) {
+    return {
+        block: r.block,
+        report: r.report,
+        hitCount: r.report.length,
+        empty: r.empty,
+    };
+}
+/** Map vectorSearch hits to the cortex result contract. */
+function mapCortexHits(hits, limit) {
+    const top = hits.slice(0, limit);
+    return {
+        results: top.map((h) => ({
+            checkpointId: h.checkpoint.checkpointId,
+            score: h.score,
+            summary: h.checkpoint.summary,
+        })),
+        hitCount: top.length,
+    };
+}
+/**
+ * Create a MegaBridge over a single stateDir.
+ *
+ * The VectorStore and TurnStore are lazy: constructed on first use and cached
+ * in closures. The stateDir is retained for memory recall, which needs it
+ * directly.
+ */
+export function createMegaBridge(opts) {
+    const stateDir = opts.stateDir;
+    let vectorStore;
+    let turnStore;
+    const getVectorStore = () => {
+        if (!vectorStore)
+            vectorStore = new VectorStore({ stateDir });
+        return vectorStore;
+    };
+    const getTurnStore = () => {
+        if (!turnStore)
+            turnStore = createTurnStore({ stateDir });
+        return turnStore;
+    };
+    return {
+        compact(input) {
+            const result = compactSession({
+                sessionId: input.sessionId,
+                messages: input.messages,
+                keepFrom: input.keepFrom,
+                summary: input.summary,
+                keyDecisions: input.keyDecisions,
+                nextSteps: input.nextSteps,
+                filesModified: input.filesModified,
+                compressionPressure: input.compressionPressure,
+            }, getVectorStore());
+            return {
+                skipped: result.skipped,
+                deduped: result.deduped,
+                summary: result.summary,
+                checkpointId: result.checkpointId,
+                tokenEstimate: result.tokenEstimate,
+                originalTokenEstimate: result.originalTokenEstimate,
+                compactedFrom: result.compactedFrom,
+            };
+        },
+        recallCheckpoints(opts) {
+            const recallOpts = {
+                sessionId: opts.sessionId,
+                query: opts.query,
+                limit: opts.limit ?? 3,
+                source: "command",
+                skipInjected: opts.skipInjected,
+                recallMaxTokens: opts.recallMaxTokens,
+            };
+            return mapRecallResult(recallAndInline(recallOpts, getVectorStore()));
+        },
+        async recallMemories(opts) {
+            const memOpts = {
+                query: opts.query,
+                stateDir,
+                limit: opts.limit,
+                minSimilarity: opts.minSimilarity,
+                crossRepo: opts.crossRepo,
+                crossRepoCosine: opts.crossRepoCosine,
+                recallMaxTokens: opts.recallMaxTokens,
+            };
+            const r = await recallMemoriesAndInline(memOpts);
+            return mapMemoryResult(r);
+        },
+        async recallAndInlineAsync(opts) {
+            const recallOpts = {
+                sessionId: opts.sessionId,
+                query: opts.query,
+                limit: opts.limit ?? 3,
+                source: "command",
+                skipInjected: opts.skipInjected,
+                recallMaxTokens: opts.recallMaxTokens,
+            };
+            const r = await recallAndInlineAsync(recallOpts, getVectorStore());
+            return mapRecallResult(r);
+        },
+        fork(opts) {
+            try {
+                const outcome = forkFromConversation(getTurnStore(), opts.parentConversationId, opts.turnIndex);
+                return {
+                    childConversationId: outcome.childConversationId,
+                    checkpointIds: outcome.checkpointIds,
+                    forkTurnIndex: opts.turnIndex,
+                };
+            }
+            catch (e) {
+                if (e instanceof ForkError) {
+                    return { error: e.code };
+                }
+                // The bridge is pi-agnostic (no runtime handle) — the host-side adapter
+                // (ithacus) owns the internal-error ring for fork failures, so this
+                // re-thrown non-ForkError is recorded there, not here.
+                // guardrails-allow INTERNAL-ERR: bridge is pi-agnostic; no runtime handle — host adapter records fork failures
+                throw e;
+            }
+        },
+        cortexQuery(opts) {
+            const limit = opts.limit ?? 3;
+            const scope = opts.repo ?? repoKey(stateDir);
+            const hits = vectorSearch(getVectorStore(), scope, opts.query, limit);
+            return mapCortexHits(hits, limit);
+        },
+        addMemory(input) {
+            // repo === null ⇒ stateDir-scoped durable memory (matches recallMemories).
+            return addMemory({
+                kind: input.kind,
+                content: input.content,
+                tags: input.tags,
+                category: input.category,
+            }, null, stateDir);
+        },
+        recordTurn(input) {
+            // S49R: child turns get the conversation-monotonic index (MAX+1) so a
+            // re-dispatched child (same conversation, restarted session counter) never
+            // collides with UNIQUE(conversation_id, turn_index). Carry the child's
+            // session counter as sessionTurnIndex for the raw_transcript join.
+            const turnIndex = getTurnStore().asReader().nextTurnIndexFor(input.conversationId);
+            const turn = {
+                conversationId: input.conversationId,
+                sessionId: input.sessionId,
+                turnIndex,
+                sessionTurnIndex: input.turnIndex,
+                role: input.role ?? "assistant",
+                endedAt: input.endedAt ?? Date.now(),
+                ctxTokens: input.ctxTokens,
+                ctxPercent: input.ctxPercent,
+                model: input.model,
+            };
+            // The bridge is pi-agnostic (no runtime handle); the host-side adapter
+            // (ithacus) owns the internal-error ring for appendTurn failures. The
+            // recordTurn child-path twin of Finding 2 is recorded there, not here.
+            // guardrails-allow INTERNAL-ERR: bridge is pi-agnostic; no runtime handle — host adapter records appendTurn failures
+            getTurnStore().asWriter().appendTurn(turn);
+        },
+        close() {
+            if (turnStore) {
+                try {
+                    turnStore.close();
+                }
+                catch {
+                    /* best-effort */
+                }
+            }
+        },
+    };
+}

package/dist/src/bridge/types.js

@@ -0,0 +1,10 @@
+/**
+ * bridge/types.ts — contract types for the bidirectional mega-compact bridge.
+ *
+ * A pi-agnostic, unit-testable adapter surface that wraps the engine's
+ * compaction / recall / memory / fork / vector APIs behind one factory so an
+ * external host (ithacus) can drive them without importing pi-runtime types.
+ * Every type here mirrors a real engine signature (see factory.ts for the
+ * wiring).
+ */
+export {};

package/dist/src/bridge.js

@@ -0,0 +1 @@
+export { createMegaBridge } from "./bridge/factory.js";

package/dist/src/contextHealth.js

@@ -15,14 +15,21 @@
  */
 import { openStore } from "./store/sqlite/utils.js";
 /**
- * Weighted composite health score from five sub-dimensions.
+ * Weighted composite health score from six sub-dimensions (Sprint H — B2).
  *
  * Weights:
  *   output quality  22% — primary measure of model output health
  *   drift           22% — session-level coherence
  *   cache poison    20% — prompt-cache integrity
  *   cache health    18% — cache hit rate stability
- *   error rate      18% — error frequency
+ *   error rate       9% — API-retry error frequency (split from 18%)
+ *   store error      9% — internal store-write failure frequency (NEW 6th axis)
+ *
+ * The 0.18 `errorRate` budget was split into `errorRate 0.09` +
+ * `storeErrorRate 0.09` so a silent store-write failure is as visible as a
+ * retryable API error. Weights sum to 1.0. NOTE (step-change): historical
+ * context_health rows keep their stored composite (point-in-time snapshots — no
+ * backfill), so the trend line shows a boundary step where weights change.
  *
  * Returns 0–1: 1 = fully healthy, 0 = severely degraded.
  */
@@ -31,7 +38,8 @@ export function computeHealthScore(sub) {
         sub.drift * 0.22 +
         sub.cachePoison * 0.20 +
         sub.cacheHealth * 0.18 +
-        sub.errorRate * 0.18;
+        sub.errorRate * 0.09 +
+        sub.storeErrorRate * 0.09;
     return Math.max(0, Math.min(1, raw));
 }
 /**
@@ -47,9 +55,9 @@ export function recordContextHealth(stateDir, row) {
         const db = openStore(stateDir);
         db.prepare(`INSERT INTO context_health
        (ts, session_id, turn_index, drift_score, output_quality,
-        error_score, cache_health, cache_poison, composite,
+        error_score, cache_health, cache_poison, composite, store_error_score,
         model_id, repetition_ratio, coherence_score, prefix_hash)
-     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(row.ts, row.sessionId, row.turnIndex, row.driftScore, row.outputQuality, row.errorScore, row.cacheHealth, row.cachePoison, row.composite, row.modelId ?? null, row.repetitionRatio ?? null, row.coherenceScore ?? null, row.prefixHash ?? null);
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(row.ts, row.sessionId, row.turnIndex, row.driftScore, row.outputQuality, row.errorScore, row.cacheHealth, row.cachePoison, row.composite, row.storeErrorScore ?? null, row.modelId ?? null, row.repetitionRatio ?? null, row.coherenceScore ?? null, row.prefixHash ?? null);
     }
     catch {
         /* non-fatal: context health instrumentation never blocks the agent loop */

package/dist/src/metrics/turns.js

@@ -50,7 +50,12 @@ export function turnMetrics(store, mainDb, conversationId) {
     }
     return turns.map((t) => {
         const recall = store.listRecallByIndex(conversationId, t.turnIndex);
-        const agg = rawAggBySessionTurn.get(`${t.sessionId}::${t.turnIndex}`);
+        // S49R: raw_transcript is keyed by pi's per-session counter. Pre-migration
+        // turn rows have NULL sessionTurnIndex and their turnIndex IS the session
+        // counter, so fall back to turnIndex (COALESCE). Post-migration rows join
+        // on sessionTurnIndex so resume doesn't zero the raw message count.
+        const sessionKey = t.sessionTurnIndex ?? t.turnIndex;
+        const agg = rawAggBySessionTurn.get(`${t.sessionId}::${sessionKey}`);
         const rawCount = agg?.raw_count ?? 0;
         const uniqueCount = agg?.unique_count ?? 0;
         return {

package/dist/src/store/sqlite/context-health-cache-poison.js

@@ -0,0 +1,60 @@
+/**
+ * context-health-cache-poison.ts — `cache_poison_events` table accessors.
+ *
+ * Extracted from context-health.ts (Sprint H split — context-health.ts crossed
+ * the soft limit when storeErrorScore was added). Records cache-poison advisory
+ * events when cache corruption/inconsistency is detected at a given cache layer.
+ *
+ * PREVENT-PI-004: local SQLite only, zero network.
+ * PREVENT-002: all SQL uses ? placeholders, no string-concatenated values.
+ * Pi-agnostic: no pi runtime types.
+ */
+import { getStateDir } from "../../store.js";
+import { openStore } from "./utils.js";
+/**
+ * Record one cache-poison advisory event. All values are fully parameterized
+ * (PREVENT-002). Non-fatal: any write error is logged to stderr and silently
+ * swallowed so advisory logging never blocks the agent loop.
+ */
+export function recordCachePoisonEvent(stateDir = getStateDir(), event) {
+    try {
+        const db = openStore(stateDir);
+        db.prepare(`INSERT INTO cache_poison_events
+			   (ts, turn_index, session_id, layer, detail, severity)
+			 VALUES (?, ?, ?, ?, ?, ?)`).run(event.ts, event.turnIndex, event.sessionId, event.layer, event.detail, event.severity);
+    }
+    catch (err) {
+        // Non-fatal: advisory logging must never block the agent loop.
+        const msg = err instanceof Error ? err.message : String(err);
+        process.stderr.write(`[context-health] recordCachePoisonEvent error: ${msg}\n`);
+    }
+}
+/**
+ * Read cache poison events since `sinceTs`, ordered descending by ts (most
+ * recent first), capped at 100 rows. Returns an empty array on any error
+ * (non-fatal). SQL is fully parameterized (PREVENT-002).
+ */
+export function readCachePoisonEvents(stateDir = getStateDir(), sinceTs) {
+    try {
+        const db = openStore(stateDir);
+        const rows = db
+            .prepare(`SELECT id, ts, turn_index, session_id, layer, detail, severity
+				 FROM cache_poison_events
+				 WHERE ts >= ?
+				 ORDER BY ts DESC
+				 LIMIT 100`)
+            .all(sinceTs);
+        return rows.map((r) => ({
+            id: r.id,
+            ts: r.ts,
+            turnIndex: r.turn_index,
+            sessionId: r.session_id,
+            layer: r.layer,
+            detail: r.detail,
+            severity: r.severity,
+        }));
+    }
+    catch {
+        return [];
+    }
+}