pi-mega-compact 0.11.12 → 0.12.0

package/dist/extensions/dashboard-server/dashboard-client-repos.js

@@ -63,7 +63,7 @@ function renderByModel(repos) {
   var rows = document.getElementById('bm-rows');
   if (!rows) return;
   if (!repos || !repos.length) {
-    rows.innerHTML = '<tr><td colspan="14" class="repo-none">No repositories registered yet.</td></tr>';
+    rows.innerHTML = '<tr><td colspan="16" class="repo-none">No repositories registered yet.</td></tr>';
     return;
   }
   var groups = {};
@@ -106,11 +106,35 @@ function renderByModel(repos) {
     var fmt = function(v) { return '$' + v.toFixed(6); };
     return lo === hi ? fmt(lo) : fmt(lo) + '–' + fmt(hi);
   }
+  // Helper: compute cache hit % from providerCacheRead/Write tokens
+  function cacheHitPct(cr, cw, inp) {
+    var denom = cr + cw + (inp || 0);
+    return denom > 0 ? ((cr / denom) * 100).toFixed(1) + '%' : '—';
+  }
+  // Helper: compute cache $ saved (read = 0.9 * inputRate, write = 0.25 * inputRate)
+  function cacheDollar(cr, cw, rate) {
+    if (!cr || !rate) return '—';
+    var saved = cr * rate * 0.9 - cw * rate * 0.25;
+    return '$' + saved.toFixed(4);
+  }
+  // Aggregate providerCacheRead/Write across repos in this group
+  var groupCacheRead = 0, groupCacheWrite = 0, groupTokensIn = 0;
+  for (var ii = 0; ii < repos.length; ii++) {
+    var rr = repos[ii];
+    var key2 = (rr.modelName && String(rr.modelName).trim()) || '(unknown)';
+    if (key2 === g.model) {
+      groupCacheRead += (rr.providerCacheRead || 0);
+      groupCacheWrite += (rr.providerCacheWrite || 0);
+      groupTokensIn += (rr.tokensDropped || 0);
+    }
+  }
   rows.innerHTML = arr.map(function(g) {
     var freed = (g.tokensIn || 0) - (g.tokensOut || 0);
-    var usd = g.usd > 0 ? '$' + g.usd.toFixed(4) : '—';
+    // B: always show a dollar value (including $0.0000) — do not use '—' when usd is 0
+    var usd = '$' + (g.usd || 0).toFixed(4);
     var when = g.lastAt ? new Date(g.lastAt).toLocaleString() : '—';
     var reas = g.reasoning == null ? '—' : (g.reasoning ? 'yes' : 'no');
+    var rate0 = g.inRates && g.inRates.length ? g.inRates[0] : 0;
     return '<tr>' +
       '<td><span class="repo-model">' + sanitize(g.model) + '</span></td>' +
       '<td>' + sanitize(g.provider) + '</td>' +
@@ -125,6 +149,8 @@ function renderByModel(repos) {
       '<td class="num">' + collapseRate(g.inRates) + '</td>' +
       '<td class="num">' + collapseRate(g.outRates) + '</td>' +
       '<td class="num">' + sanitize(usd) + '</td>' +
+      '<td class="num">' + cacheHitPct(groupCacheRead, groupCacheWrite, groupTokensIn) + '</td>' +
+      '<td class="num">' + cacheDollar(groupCacheRead, groupCacheWrite, rate0) + '</td>' +
       '<td class="num">' + sanitize(when) + '</td>' +
     '</tr>';
   }).join('');

package/dist/extensions/dashboard-server/index-reader.js

@@ -12,6 +12,7 @@ import { existsSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
 import { DatabaseSync } from "node:sqlite";
+import { readProviderCacheForRepo, } from "../../src/store/sqlite/perf-samples.js";
 export function getIndexDir() {
     const override = process.env.MEGACOMPACT_INDEX_DIR;
     if (override && override.trim() !== "")
@@ -89,21 +90,21 @@ export function readIndex() {
                             repo.maxTokens = Number(mrow.max_tokens ?? 0) || null;
                             repo.reasoning = Number(mrow.reasoning ?? 0) === 1;
                         }
-                        // Provider prompt-cache stats (E.3)
+                        // Provider prompt-cache stats (E.3 / F4)
+                        // Use readProviderCacheForRepo which correctly reads cache token
+                        // counts from the meta JSON column (cacheRead/cacheWrite), not
+                        // from non-existent table columns cache_read/cache_write.
                         try {
-                            const pRow = sdb
-                                .prepare(`SELECT
-                    SUM(cache_read) AS totalRead,
-                    SUM(cache_write) AS totalWrite,
-                    SUM(cache_read + cache_write) * 1.0 / MAX(SUM(cache_read + cache_write + tokens_in), 1) AS hitPct
-                   FROM perf_samples
-                   WHERE cache_read > 0 OR cache_write > 0`)
-                                .get();
-                            if (pRow && pRow.totalRead > 0) {
-                                repo.providerCacheRead = Number(pRow.totalRead);
-                                repo.providerCacheWrite = Number(pRow.totalWrite);
-                                repo.providerCachePct = Number((pRow.hitPct * 100).toFixed(1));
+                            const pc = readProviderCacheForRepo(repo.stateDir);
+                            if (pc.totalCacheRead > 0) {
+                                repo.providerCacheRead = pc.totalCacheRead;
+                                repo.providerCacheWrite = pc.totalCacheWrite;
+                                repo.providerCachePct = Number(pc.avgHitPct.toFixed(1));
                             }
+                            // Also enrich contextWindow/maxTokens/reasoning from the
+                            // latest model_snapshots row (was already read above, but
+                            // when latestModelSnapshot was used above we get the same
+                            // data from the per-repo store — keep as-is).
                         }
                         catch {
                             /* best-effort — perf_samples may not exist */

package/dist/extensions/dashboard-server/routes-health.js

@@ -0,0 +1,81 @@
+/**
+ * routes-health.ts — Context Health + KV Cache Poison route handlers.
+ *
+ * GET /api/context-health — recent health rows, latest composite, trend,
+ *   per-model averages, alert flags. Accepts ?minutes=N (default 30).
+ * GET /api/cache-poison — recent cache poison events (last 30 min).
+ *
+ * Guardrails: PREVENT-PI-004 (loopback-only), PREVENT-001 (null-safe),
+ * PREVENT-002 (parameterized SQL via accessors). Localhost dashboard.
+ */
+import { createRequire } from "node:module";
+export function handleContextHealth(req, res, ctx) {
+    if (!req.url?.startsWith("/api/context-health"))
+        return false;
+    try {
+        if (req.method !== "GET") {
+            res.writeHead(405, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ error: "method_not_allowed" }));
+            return true;
+        }
+        const url = new URL(req.url, "http://localhost");
+        const minutes = Math.max(1, Number(url.searchParams.get("minutes") ?? 30));
+        const sinceTs = Date.now() - minutes * 60_000;
+        const pfReq = createRequire(import.meta.url);
+        const { readLatestContextHealth, readContextHealthTrend, readContextHealthRows, } = pfReq("../../src/store/sqlite.js");
+        const latest = readLatestContextHealth(ctx.stateDir);
+        const trend = readContextHealthTrend(ctx.stateDir, 50);
+        const rows = readContextHealthRows(ctx.stateDir, sinceTs);
+        const perModel = new Map();
+        for (const r of rows) {
+            const mid = r.modelId ?? "(unknown)";
+            const entry = perModel.get(mid) ?? { sum: 0, count: 0 };
+            entry.sum += r.composite;
+            entry.count += 1;
+            perModel.set(mid, entry);
+        }
+        const perModelAverages = [...perModel.entries()].map(([modelId, v]) => ({
+            modelId,
+            avgComposite: v.count > 0 ? v.sum / v.count : 0,
+            sampleCount: v.count,
+        }));
+        const alerts = rows.filter((r) => r.composite < 0.5 || r.cachePoison < 0.3);
+        const body = {
+            updatedAt: new Date().toISOString(),
+            latest,
+            trend,
+            rows: rows.slice(-200),
+            perModel: perModelAverages,
+            alerts,
+        };
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify(body));
+    }
+    catch (e) {
+        res.writeHead(500, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: String(e) }));
+    }
+    return true;
+}
+export function handleCachePoison(req, res, ctx) {
+    if (!req.url?.startsWith("/api/cache-poison"))
+        return false;
+    try {
+        if (req.method !== "GET") {
+            res.writeHead(405, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ error: "method_not_allowed" }));
+            return true;
+        }
+        const sinceTs = Date.now() - 30 * 60_000;
+        const pfReq = createRequire(import.meta.url);
+        const { readCachePoisonEvents } = pfReq("../../src/store/sqlite.js");
+        const events = readCachePoisonEvents(ctx.stateDir, sinceTs);
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ updatedAt: new Date().toISOString(), events }));
+    }
+    catch (e) {
+        res.writeHead(500, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: String(e) }));
+    }
+    return true;
+}

package/dist/extensions/dashboard-server/routes-topics.js

@@ -7,6 +7,8 @@
  */
 import { openTurnStore } from "../../src/store/turns/connection.js";
 import { createTopicStore } from "../../src/topics/store.js";
+import { openStore } from "../../src/store/sqlite.js";
+import { buildTopicModel } from "../../src/topics/cluster.js";
 export function handleTopics(req, res, ctx) {
     const url = req.url ?? "";
     // ── GET /api/topics/:topicId/memories — wiki topic drill-down (S52) ──
@@ -42,6 +44,22 @@ export function handleTopics(req, res, ctx) {
         return false;
     try {
         const tdb = openTurnStore(ctx.stateDir);
+        // Lazy build: when the topics table is empty, attempt a one-shot build
+        // from available context_chunks embeddings so the wiki is useful even
+        // before the first compaction fires.
+        const topicCount = tdb.prepare("SELECT COUNT(*) AS c FROM topics").get().c;
+        if (topicCount === 0) {
+            try {
+                const mainDb = openStore(ctx.stateDir);
+                const model = buildTopicModel(mainDb);
+                if (model.k > 0 && model.totalChunks > 0) {
+                    createTopicStore(ctx.stateDir).replaceTopicModel(model);
+                }
+            }
+            catch {
+                /* non-fatal: lazy wiki build is best-effort */
+            }
+        }
         const topics = tdb
             .prepare(`SELECT id, label, term_scores, memory_count, last_updated
            FROM topics ORDER BY memory_count DESC, id ASC`)

package/dist/extensions/dashboard-server/routes.js

@@ -16,3 +16,4 @@ export { handleMemoryStatus } from "./routes-memory.js";
 export { handleSetupStatus, handleSetupDetect, handleSetupConfigure } from "./routes-setup.js";
 export { handleMemoryMap } from "./routes-memory-map.js";
 export { handleCacheStripes } from "./routes-cache.js";
+export { handleContextHealth, handleCachePoison } from "./routes-health.js";

package/dist/extensions/dashboard-server/server.js

@@ -12,7 +12,7 @@ import { join, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
 import { createRequire } from "node:module";
 import { log, setLogPath, setDashboardServerVersion } from "./state.js";
-import { buildRouteContext, handleIndex, handleRepoIndex, handleEvents, handleGameState, handleGameScores, handlePerf, handleAchievements, handleSessions, handleTopics, handleTurns, handleMaintenance, handleProviderCache, handleCacheStripes, handleMemoryStatus, handleSetupStatus, handleSetupDetect, handleSetupConfigure, handleMemoryMap, handleStatic, } from "./routes.js";
+import { buildRouteContext, handleIndex, handleRepoIndex, handleEvents, handleGameState, handleGameScores, handlePerf, handleAchievements, handleSessions, handleTopics, handleTurns, handleMaintenance, handleProviderCache, handleCacheStripes, handleMemoryStatus, handleSetupStatus, handleSetupDetect, handleSetupConfigure, handleMemoryMap, handleContextHealth, handleCachePoison, handleStatic, } from "./routes.js";
 export async function launchDashboardServer(stateDir) {
     // Our own package version — exposed at /api/version so the launcher can
     // detect a stale server (started by an older build) and replace it on
@@ -207,6 +207,10 @@ export async function launchDashboardServer(stateDir) {
             return;
         if (handleMemoryMap(req, res, ctx))
             return;
+        if (handleContextHealth(req, res, ctx))
+            return;
+        if (handleCachePoison(req, res, ctx))
+            return;
         handleStatic(req, res, ctx);
     });
     // Bind base + range are env-configurable so tests can use a private,

package/dist/extensions/mega-config.js

@@ -180,6 +180,11 @@ export function loadConfig() {
         memoryGraphSeedMemories: envBool("MEGACOMPACT_MEMORY_GRAPH_SEED_MEMORIES", true),
         memoryGraphCrossTypeThreshold: envFlag("MEGACOMPACT_MEMORY_GRAPH_CROSS_TYPE_THRESHOLD", 0.85),
         memoryGraphWithinTypeThreshold: envFlag("MEGACOMPACT_MEMORY_GRAPH_WITHIN_TYPE_THRESHOLD", 0.7),
+        contextHealth: envBool("MEGACOMPACT_CONTEXT_HEALTH", true),
+        contextHealthDrift: envBool("MEGACOMPACT_CONTEXT_HEALTH_DRIFT", true),
+        contextHealthOutputQuality: envBool("MEGACOMPACT_CONTEXT_HEALTH_OUTPUT_QUALITY", true),
+        contextHealthCachePoison: envBool("MEGACOMPACT_CONTEXT_HEALTH_CACHE_POISON", true),
+        contextHealthMitigate: envBool("MEGACOMPACT_CONTEXT_HEALTH_MITIGATE", false),
         // 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),

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

@@ -12,6 +12,7 @@ import { vectorStats } from "../../src/vectorStore.js";
 import { defaultEmbedder } from "../../src/embedder.js";
 import { storeTopicEmbedding, loadTopicEmbedding, detectTopicShift, } from "./separated-prompt.js";
 import { refreshStripeAssignments as writeStripeAssignments, } from "../../src/cache-stripe-impl.js";
+import { handleTurnEndHealth } from "./health-handler.js";
 /** Register agent/turn tracking event handlers. */
 export function registerAgentHandlers(pi, runtime, config) {
     // ---- Agent tracking for real-time widget + status-line updates ---------
@@ -252,6 +253,7 @@ export function registerAgentHandlers(pi, runtime, config) {
     pi.on("turn_end", async (event, ctx) => {
         runtime.dashboard.event("turn_end", { turnIndex: event.turnIndex });
         runtime.snapshot(ctx);
+        runtime.lastErrorCategory = null;
         // S53: consume staged recall blocks ONLY if they were actually injected
         // into a view this turn. If no context event fired (edge: turn ended
         // before any LLM call), recallInjectedThisTurn stays false and the blocks
@@ -372,6 +374,7 @@ export function registerAgentHandlers(pi, runtime, config) {
             else {
                 const category = classifyError(event.message);
                 const detail = classifyErrorDetailed(event.message);
+                runtime.lastErrorCategory = category;
                 // R3: stateful poisoned-context signal — repeated identical error text
                 // across consecutive turns. The classifier is stateless, so this
                 // upgrade happens here. A 'transient' (or 'poisoned-context') turn
@@ -781,5 +784,7 @@ export function registerAgentHandlers(pi, runtime, config) {
                 /* non-fatal: stripe refresh never breaks the agent loop */
             }
         }
+        // v0.12: Context Health — compute + persist health score. Non-fatal.
+        handleTurnEndHealth(event, runtime, config);
     });
 }

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

@@ -278,6 +278,11 @@ export function registerContextHandler(pi, runtime, config) {
                 // S51B: auto-categorizing wiki rebuild — every Nth compaction, derived
                 // from real context_chunks embeddings. Isolated-store only, gated on
                 // AUTO_WIKI_ENABLED; best-effort + non-fatal (never breaks compaction).
+                // Fire regardless of dbMirror — context_chunks is the isolated store.
+                // Uses the already-open db when inside the dbMirror block; opens its own
+                // connection otherwise.
+                // from real context_chunks embeddings. Isolated-store only, gated on
+                // AUTO_WIKI_ENABLED; best-effort + non-fatal (never breaks compaction).
                 try {
                     if (config.autoWikiEnabled && config.turnsDbEnabled) {
                         const every = Math.max(1, TurnsConfig.WIKI_REBUILD_EVERY_N_COMPACTS);
@@ -323,11 +328,11 @@ export function registerContextHandler(pi, runtime, config) {
                         if (chunkCount < floor) {
                             const transcriptRows = db
                                 .prepare(`SELECT DISTINCT content_bytes
-			       FROM raw_transcript
-			       WHERE session_id = ?
-			         AND length(content_bytes) > 10
-			       ORDER BY seq ASC
-			       LIMIT 200`)
+	       FROM raw_transcript
+	       WHERE session_id = ?
+	         AND length(content_bytes) > 10
+	       ORDER BY seq ASC
+	       LIMIT 200`)
                                 .all(runtime.rt.sessionId);
                             if (transcriptRows.length > 0) {
                                 const embedder = new TrigramEmbedder();

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

@@ -0,0 +1,156 @@
+/**
+ * health-handler.ts — Context Health turn_end hook (v0.12).
+ *
+ * Computes a composite 0-1 health score per turn from five sub-scores
+ * (drift, output quality, error rate, cache health, cache poison),
+ * persists it to the context_health SQLite table, and emits a dashboard
+ * event. All paths non-fatal — health monitoring never breaks the agent loop.
+ *
+ * PREVENT-PI-004: zero network (local TrigramEmbedder + SQLite only).
+ */
+import { defaultEmbedder } from "../../src/embedder.js";
+import { computeOutputQuality } from "../../src/contextHealth/outputQuality.js";
+import { computeTopicDrift, computeErrorEscalation, computePrefixInstability, computeDriftScore, } from "../../src/contextHealth/drift.js";
+import { computePrefixHash, checkPrefixHash, evaluateCachePoison, } from "../../src/contextHealth/cachePoison.js";
+import { computeHealthScore, recordContextHealth, } from "../../src/contextHealth.js";
+import { recordCachePoisonEvent, } from "../../src/store/sqlite/context-health.js";
+const RING_MAX = 5;
+/** Extract assistant text from the turn_end event message. */
+function extractAssistantText(event) {
+    const msg = event.message;
+    if (!msg || msg.role !== "assistant")
+        return "";
+    const c = msg.content;
+    if (typeof c === "string")
+        return c;
+    if (Array.isArray(c)) {
+        return c
+            .map((p) => (p && typeof p === "object" && "text" in p ? String(p.text ?? "") : ""))
+            .join(" ");
+    }
+    return "";
+}
+/** Extract messages as string array for prefix hash (cache poison Layer 1). */
+function extractMessageTexts(event) {
+    const c = event?.message?.content;
+    if (typeof c === "string")
+        return [c];
+    if (Array.isArray(c)) {
+        return c.map((p) => (p && typeof p === "object" && "text" in p ? String(p.text ?? "") : ""));
+    }
+    return [];
+}
+/** Handle turn_end: compute + persist context health. Non-fatal. */
+export function handleTurnEndHealth(event, runtime, config) {
+    if (!config.contextHealth)
+        return;
+    try {
+        const text = extractAssistantText(event);
+        const embedder = defaultEmbedder();
+        const emb = text.length > 0 ? embedder.embed(text) : [];
+        // Output quality sub-score
+        let outputQuality = 1.0;
+        let repetitionRatio = 0;
+        let coherenceScore = 1.0;
+        if (config.contextHealthOutputQuality && text.length > 0) {
+            const oq = computeOutputQuality(text, embedder);
+            outputQuality = oq.score;
+            repetitionRatio = oq.repetitionRatio;
+            coherenceScore = oq.coherenceScore;
+        }
+        // Drift sub-score
+        let drift = 1.0;
+        if (config.contextHealthDrift) {
+            const topic = computeTopicDrift(emb, runtime.recentTurnEmbeddings);
+            const error = computeErrorEscalation(runtime.recentErrorCategories);
+            const prefix = computePrefixInstability(0, 5);
+            drift = computeDriftScore(topic, error, prefix);
+        }
+        // Error rate sub-score (1 = no errors)
+        const errorScore = computeErrorEscalation(runtime.recentErrorCategories);
+        // Cache health (from perf-handler)
+        const cacheHealth = runtime.rt._lastCacheHealthScore ?? 1.0;
+        // Cache poison sub-score
+        let cachePoison = 1.0;
+        if (config.contextHealthCachePoison) {
+            const msgTexts = extractMessageTexts(event);
+            const currentHash = computePrefixHash(msgTexts);
+            const cacheRead = event.message?.usage?.cacheRead ?? 0;
+            const l1 = checkPrefixHash(currentHash, runtime.lastPrefixHash, cacheRead);
+            const result = evaluateCachePoison({
+                currentHash,
+                storedHash: runtime.lastPrefixHash,
+                cacheRead,
+                qualityByCacheHit: [],
+                qualityByCacheMiss: [],
+                errorRateCacheHit: 0,
+                errorRateCacheMiss: 0,
+                sampleCount: 0,
+            });
+            cachePoison = result.score;
+            if (l1.poisoned) {
+                try {
+                    recordCachePoisonEvent(runtime.currentStateDir, {
+                        ts: Date.now(),
+                        turnIndex: event.turnIndex,
+                        sessionId: runtime.rt.sessionId,
+                        layer: 1,
+                        detail: l1.detail,
+                        severity: "warn",
+                    });
+                }
+                catch { /* non-fatal */ }
+            }
+            runtime.lastPrefixHash = currentHash;
+        }
+        // Composite
+        const sub = {
+            drift,
+            outputQuality,
+            errorRate: errorScore,
+            cacheHealth,
+            cachePoison,
+        };
+        const composite = computeHealthScore(sub);
+        // Persist
+        recordContextHealth(runtime.currentStateDir, {
+            ts: Date.now(),
+            turnIndex: event.turnIndex,
+            sessionId: runtime.rt.sessionId,
+            driftScore: drift,
+            outputQuality,
+            errorScore,
+            cacheHealth,
+            cachePoison,
+            composite,
+            modelId: runtime.currentModel?.modelId,
+            repetitionRatio,
+            coherenceScore,
+            prefixHash: runtime.lastPrefixHash ?? undefined,
+        });
+        // Emit dashboard event
+        runtime.dashboard.event("context_health", {
+            composite,
+            drift,
+            outputQuality,
+            errorRate: errorScore,
+            cacheHealth,
+            cachePoison,
+            turnIndex: event.turnIndex,
+        });
+        // Update ring buffers
+        runtime.recentTurnEmbeddings.push(emb);
+        if (runtime.recentTurnEmbeddings.length > RING_MAX) {
+            runtime.recentTurnEmbeddings.shift();
+        }
+        runtime.recentErrorCategories.push(runtime.lastErrorCategory);
+        if (runtime.recentErrorCategories.length > RING_MAX) {
+            runtime.recentErrorCategories.shift();
+        }
+    }
+    catch (e) {
+        runtime.logger?.error("context_health_failed", {
+            error: String(e instanceof Error ? e.message : e),
+        });
+    }
+}

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

@@ -11,7 +11,11 @@
 import { normalizeSessionId } from "../../src/store.js";
 // --------------------------------------------------------------- resetRuntime
 export function resetRuntimeImpl(self, sessionId) {
-    const sid = normalizeSessionId(sessionId);
+    // Only call normalizeSessionId when a real sessionId string is passed.
+    // When undefined, keep the existing self.rt.sessionId (set by the real
+    // session-start / compact pipeline) so the early-return guard can fire and
+    // dashboard stats keyed by sessionId are not silently orphaned.
+    const sid = sessionId ? normalizeSessionId(sessionId) : self.rt.sessionId;
     if (self.rt.sessionId === sid && self.rt.persistedThisSession)
         return; // same session, keep checkpoint memory
     self.rt = {

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

@@ -215,6 +215,12 @@ export class MegaRuntime {
     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