pi-mega-compact 0.20.22 → 0.20.24

package/extensions/dashboard-server/routes-vector-cortex-reconstruct.ts

@@ -11,12 +11,19 @@ import type { IncomingMessage, ServerResponse } from "node:http";
 import type { RouteContext } from "./routes-core.js";
 import { VC4C_ENABLED } from "../../src/config.js";
 import { sendJson } from "./routes-vector-cortex-shared.js";
+import { countVcEvents, vcCount } from "./vc-event-counts.js";
 import type { VectorCortexReconstructView } from "./api-contracts/vector-cortex.js";
 
+// Closure attempt/rejection events emitted by src/vector-cortex/heal/emit.ts.
+const RECONSTRUCT_EVENTS = [
+  "vector_cortex_closure_optimized",
+  "vector_cortex_closure_proof_rejected",
+] as const;
+
 export function handleVectorCortexReconstruct(
   req: IncomingMessage,
   res: ServerResponse,
-  _ctx: RouteContext,
+  ctx: RouteContext,
 ): boolean {
   const url = req.url ?? "";
   const path = url.split("?")[0] ?? url;
@@ -26,10 +33,11 @@ export function handleVectorCortexReconstruct(
     return true;
   }
   const enabled = VC4C_ENABLED();
+  const counts = countVcEvents(ctx.stateDir, RECONSTRUCT_EVENTS);
   const body: VectorCortexReconstructView = {
     enabled,
-    closureAttempts: 0,
-    closureRejections: 0,
+    closureAttempts: vcCount(counts, "vector_cortex_closure_optimized"),
+    closureRejections: vcCount(counts, "vector_cortex_closure_proof_rejected"),
     validatedCount: 0,
     invalidatedCount: 0,
     spanTotal: 0,

package/extensions/dashboard-server/routes-vector-cortex-repair.ts

@@ -25,8 +25,16 @@ import type { IncomingMessage, ServerResponse } from "node:http";
 import type { RouteContext } from "./routes-core.js";
 import { VC6C_ENABLED } from "../../src/config.js";
 import { sendJson } from "./routes-vector-cortex-shared.js";
+import { countVcEvents, vcCount } from "./vc-event-counts.js";
 import type { VectorCortexRepairView } from "./api-contracts/vector-cortex.js";
 
+// Actual event names emitted by src/vector-cortex/heal/repair-emit.ts.
+const REPAIR_EVENTS = [
+  "vector_cortex_repair_planned",
+  "vector_cortex_repair_pointer_switched",
+  "vector_cortex_repair_backoff",
+] as const;
+
 /**
  * Reader-only GET /api/vector-cortex/repair (VC6C).
  *
@@ -38,7 +46,7 @@ import type { VectorCortexRepairView } from "./api-contracts/vector-cortex.js";
 export function handleVectorCortexRepair(
   req: IncomingMessage,
   res: ServerResponse,
-  _ctx: RouteContext,
+  ctx: RouteContext,
 ): boolean {
   const url = req.url ?? "";
   const path = url.split("?")[0] ?? url;
@@ -49,6 +57,7 @@ export function handleVectorCortexRepair(
   }
 
   const enabled = VC6C_ENABLED();
+  const counts = countVcEvents(ctx.stateDir, REPAIR_EVENTS);
   // Flag-off routes to mode C: with VC6C off no self-healing controller runs at
   // all, so neither the targeted rebuild (mode A) nor the full deterministic
   // rebuild (mode B) path is available. Mode C is exactly the spec's "derived
@@ -59,10 +68,10 @@ export function handleVectorCortexRepair(
   const body: VectorCortexRepairView = {
     enabled,
     mode,
-    repairAttempts: 0,
-    repairsPlanned: 0,
-    pointersSwitched: 0,
-    backoffs: 0,
+    repairAttempts: vcCount(counts, "vector_cortex_repair_planned"),
+    repairsPlanned: vcCount(counts, "vector_cortex_repair_planned"),
+    pointersSwitched: vcCount(counts, "vector_cortex_repair_pointer_switched"),
+    backoffs: vcCount(counts, "vector_cortex_repair_backoff"),
     lastBackoffMs: null,
     lastFailure: null,
     updatedAt: new Date().toISOString(),

package/extensions/dashboard-server/routes-vector-cortex-shards.ts

@@ -22,15 +22,22 @@ import type { IncomingMessage, ServerResponse } from "node:http";
 import type { RouteContext } from "./routes-core.js";
 import { VC4A_ENABLED } from "../../src/config.js";
 import { sendJson } from "./routes-vector-cortex-shared.js";
+import { countVcEvents, vcCount } from "./vc-event-counts.js";
 import type { VectorCortexShardsView } from "./api-contracts/vector-cortex.js";
 
+// Actual events emitted by src/vector-cortex/shards/manifest.ts. VC4A has no
+// per-tier (semantic/exact) write event — the manifest build is the single
+// shard-write signal — so semanticCount is wired to it and exactCount stays 0
+// until a per-tier write event exists.
+const SHARD_EVENTS = ["vector_cortex_shard_manifest_built"] as const;
+
 /**
  * Reader-only GET /api/vector-cortex/shards (VC4A).
  */
 export function handleVectorCortexShards(
   req: IncomingMessage,
   res: ServerResponse,
-  _ctx: RouteContext,
+  ctx: RouteContext,
 ): boolean {
   const url = req.url ?? "";
   const path = url.split("?")[0] ?? url;
@@ -42,11 +49,13 @@ export function handleVectorCortexShards(
   }
 
   const enabled = VC4A_ENABLED();
+  const counts = countVcEvents(ctx.stateDir, SHARD_EVENTS);
   const body: VectorCortexShardsView = {
     enabled,
-    // No durable shard manifest is staged yet in this sprint (pure in-memory
-    // partition), so the aggregates are truthfully zero.
-    semanticCount: 0,
+    // The manifest-build event is the only VC4A shard-write signal; semanticCount
+    // reflects manifests built and exactCount stays 0 (no per-tier write event
+    // distinguishes exact shards in events.log yet).
+    semanticCount: vcCount(counts, "vector_cortex_shard_manifest_built"),
     exactCount: 0,
     byteTotal: 0,
     protectedByteTotal: 0,

package/extensions/dashboard-server/vc-event-counts.ts

@@ -0,0 +1,67 @@
+/**
+ * dashboard-server/vc-event-counts.ts — lightweight events.log tail reader for
+ * the Vector Cortex dashboard routes.
+ *
+ * The VC event reporters in `src/vector-cortex/*` emit structured JSON events
+ * (one per line) into the per-repo `events.log`. Instead of the dashboard
+ * hardcoding zero for aggregate counters, this module reads the event tail and
+ * counts real occurrences of named events. It is the single shared seam so every
+ * route stays a small, thin consumer and the counting logic lives in one place
+ * (extensions/ 400-line soft-as-hard split trigger).
+ *
+ * NEVER throws: a missing/unreadable file degrades to an empty Map, malformed
+ * lines are skipped silently, and only the `.event` string field is inspected —
+ * no payload, bytes, span ids, digests, or ledger text ever leaves this module
+ * (SECURITY_PRIVACY, reader-only aggregate).
+ *
+ * Guardrails: PREVENT-PI-004 (local in-process file read only), PREVENT-011
+ * (no `any`).
+ */
+
+import { join } from "node:path";
+import { readFileSync } from "node:fs";
+
+/**
+ * Count occurrences of the given named events within the last `maxLines` of the
+ * per-repo events.log adjacent to `stateDir`. Returns a Map keyed by event name;
+ * a missing/unreadable log or zero matching lines yields an empty Map. Best-effort
+ * and non-fatal by construction (matches the non-fatal-stores invariant).
+ */
+export function countVcEvents(
+  stateDir: string,
+  eventNames: readonly string[],
+  maxLines = 10000,
+): Map<string, number> {
+  const counts = new Map<string, number>();
+  let raw: string;
+  try {
+    raw = readFileSync(join(stateDir, "events.log"), "utf-8");
+  } catch {
+    // Missing or unreadable log → nothing to count, never throw.
+    return counts;
+  }
+  // Walk only the tail: split into lines and keep the last `maxLines`.
+  const lines = raw.split("\n");
+  const start = Math.max(0, lines.length - maxLines);
+  const wanted = new Set(eventNames);
+  for (let i = start; i < lines.length; i++) {
+    const line = lines[i] as string;
+    if (line.length === 0) continue;
+    let ev: { event?: unknown } | null = null;
+    try {
+      ev = JSON.parse(line) as { event?: unknown };
+    } catch {
+      // Malformed line — skip silently, never break the reader.
+      continue;
+    }
+    if (typeof ev?.event === "string" && wanted.has(ev.event)) {
+      counts.set(ev.event, (counts.get(ev.event) ?? 0) + 1);
+    }
+  }
+  return counts;
+}
+
+/** Read a value from an event-count map, defaulting to 0 when absent. */
+export function vcCount(counts: Map<string, number>, name: string): number {
+  return counts.get(name) ?? 0;
+}

package/extensions/mega-dashboard.ts

@@ -25,6 +25,8 @@ export interface DashboardSnapshot {
   presetTier: string;
   /** Live 0–1 pressure ratio (currentTokens / thresholdTokens). */
   pressure: number;
+  /** VC0A: count of eval-observer latency samples (0 when disabled/absent). */
+  vcObserverSamples: number;
   config: {
     fastGatePct: number;
     thresholdTokens: number;

package/extensions/mega-events/agent-handlers/turnEndHandler/cacheStripe.ts

@@ -28,12 +28,21 @@ export function cacheStripe(
 			const embedder = defaultEmbedder();
 
 			// (a) Extract text from the assistant's response for topic embedding.
+			// pi's assistant content may be a plain string OR an array of parts.
+			// Discriminate by type and only reach into `.text` after confirming the
+			// part is an object carrying a string `.text` — never assume shape.
 			let textToEmbed = "";
 			const msg = event.message;
-			if (msg.role === "assistant" && Array.isArray(msg.content)) {
-				for (const part of msg.content) {
-					if ("text" in part && typeof part.text === "string") {
-						textToEmbed += part.text + " ";
+			if (msg.role === "assistant") {
+				const c = msg.content;
+				if (typeof c === "string") {
+					textToEmbed = c;
+				} else if (Array.isArray(c)) {
+					for (const part of c) {
+						if (part && typeof part === "object" && "text" in part) {
+							const t = (part as { text?: unknown }).text;
+							if (typeof t === "string") textToEmbed += t + " ";
+						}
 					}
 				}
 			}

package/extensions/mega-events/context-handler/afterCompact.ts

@@ -28,12 +28,17 @@ import { assignNewMemoriesIncremental } from "../../../src/wiki/index.js";
 import { TrigramEmbedder } from "../../../src/embedder.js";
 import type { EmbeddedChunk } from "../../../src/topics/types.js";
 import type { MegaConfig } from "../../mega-config.js";
+import { reportClosureOptimized } from "../../../src/vector-cortex/heal/emit.js";
+import { reportRepairPlanned } from "../../../src/vector-cortex/heal/repair-emit.js";
+import { VC6A_ENABLED, VC6C_ENABLED } from "../../../src/config/vector-cortex.js";
 
 /** Shape of the compact result consumed by the epoch/maintenance writes. */
 interface CompactResult {
 	checkpointId?: string;
 	compactedFrom: number;
 	summary: string;
+	tokenEstimate?: number;
+	originalTokenEstimate?: number;
 }
 
 /**
@@ -45,9 +50,12 @@ export async function persistEpochAndMaintain(
 	config: MegaConfig,
 	ran: { result: CompactResult },
 ): Promise<void> {
-	// S27 DB-mirror: write checkpoint_epoch with deterministic nonce.
-	// This makes the cache key stable across identical compactions.
-	if (config.dbMirror) {
+	// PLAN_V2 cache-striping epoch row. buildCacheOptimizedPrompt's stripe
+	// lookup reads the most-recent checkpoint_epochs row, so emit it whenever
+	// PLAN_V2 flags are live. Separate from the legacy dbMirror block below so
+	// PLAN_V2 can run with dbMirror OFF (flag-on is a genuine additive; flag-OFF
+	// = byte-identical to the predecessor, since this block no-ops then).
+	if (config.dbMirror || config.messageSeparation || config.cacheStriping) {
 		try {
 			const db = openStore(runtime.currentStateDir);
 			const cpId = ran.result.checkpointId ?? `epoch-${Date.now()}`;
@@ -62,6 +70,22 @@ export async function persistEpochAndMaintain(
 				createdAt: Date.now(),
 			};
 			writeCheckpointEpoch(db, epoch);
+		} catch (e) {
+			runtime.logger.warn("planv2-epoch-fail", { error: String(e) });
+		}
+	}
+
+	// S27 DB-mirror downstream: stamp turns, rebuild wiki, seed topics, dedup.
+	// Remains on `config.dbMirror` only — these are DB-mirror maintenance and
+	// must NOT run for PLAN_V2-only configurations.
+	if (config.dbMirror) {
+		try {
+			const db = openStore(runtime.currentStateDir);
+			const cpId = ran.result.checkpointId ?? `epoch-${Date.now()}`;
+			// epoch + writeCheckpointEpoch moved to the PLAN_V2 block above (it
+			// gates the wider set of flags); reuse epochIdFor(cpId) here so the
+			// stamps below land in the same epoch row.
+			const epochId = epochIdFor(cpId);
 			// S50B: link this session's turns to the epoch that just compacted
 			// them (compression-by-conversation-epoch metrics). Isolated-store
 			// only; best-effort + non-fatal.
@@ -69,7 +93,7 @@ export async function persistEpochAndMaintain(
 				stampTurnsEpochFor(
 					config,
 					runtime.rt.sessionId,
-					epoch.epochId,
+					epochId,
 					runtime.currentStateDir,
 				);
 			} catch {
@@ -253,4 +277,45 @@ export async function persistEpochAndMaintain(
 			runtime.logger.warn("db-mirror-epoch-fail", { error: String(e) });
 		}
 	}
+
+	// VC6 Heal lifecycle emits (post-compact). Wiring stubs — dashboard graph +
+	// event counts move; real gap detection/rebuild is a future sprint.
+	// VC6A: closure-optimization savings from the compact token delta.
+	const savings = Math.max(
+		0,
+		(ran.result.originalTokenEstimate ?? 0) - (ran.result.tokenEstimate ?? 0),
+	);
+	if (VC6A_ENABLED()) {
+		try {
+			reportClosureOptimized(
+				(name, payload) =>
+					runtime.appendEvent(name, payload as Record<string, unknown>),
+				{
+					sessionId: runtime.rt.sessionId,
+					removed: 0,
+					retained: ran.result.compactedFrom,
+					savings,
+				},
+			);
+		} catch {
+			/* non-fatal: VC6A heal emit never breaks compaction */
+		}
+	}
+	// VC6C: repair-planner placeholder (no real gap detection yet).
+	if (VC6C_ENABLED()) {
+		try {
+			reportRepairPlanned(
+				(name, payload) =>
+					runtime.appendEvent(name, payload as Record<string, unknown>),
+				{
+					subsystem: "post_compact",
+					generation: 1,
+					backoffMs: 0,
+					gapSize: 0,
+				},
+			);
+		} catch {
+			/* non-fatal: VC6C heal emit never breaks compaction */
+		}
+	}
 }

package/extensions/mega-events/context-handler/dbMirrorAppend.ts

@@ -16,6 +16,21 @@ import type { MegaRuntime } from "../../mega-runtime.js";
 import type { MegaConfig } from "../../mega-config.js";
 import { messageContentText } from "./messageText.js";
 
+/**
+ * Best-effort tool_call_id for the tool_results insert. The toolResult variant
+ * carries a top-level toolCallId (read via an `unknown`-narrowed cast — never
+ * reach into `.content`, which is variant-specific and requires narrowing).
+ * bashExecution has no toolCallId, so fall back to a stable synthetic id keyed
+ * on (turn, index) to satisfy the NOT NULL column. No `any` (PREVENT-011).
+ */
+function toolCallIdOf(m: AgentMessage, fallback: string): string {
+	if (m.role === "toolResult") {
+		const id = (m as unknown as { toolCallId?: unknown }).toolCallId;
+		if (typeof id === "string" && id.length > 0) return id;
+	}
+	return fallback;
+}
+
 /**
  * Append incoming messages to the DB mirror (raw_transcript + thread/tool
  * tables) and the v2 ledger. Gated on config.dbMirror for the mirror; the VC1B
@@ -49,25 +64,42 @@ export function appendMirrorAndLedger(
 			// separation (buildSeparatedPrompt / buildCacheOptimizedPrompt in
 			// tailResult) is sufficient for the prompt-construction path;
 			// these DB writes persist the split for post-hoc analysis, dashboard
-			// queries, and future readers. Non-fatal — failure here never breaks
-			// the agent loop (PREVENT-PI-004: zero network, local SQLite only).
-			{
+			// queries, and future readers. Gated on (messageSeparation ||
+			// cacheStriping) so flag-OFF remains byte-identical to the
+			// predecessor — when both flags are OFF the live prompt is never
+			// separated, and growing these tables would be dead state.
+			// Non-fatal — failure here never breaks the agent loop
+			// (PREVENT-PI-004: zero network, local SQLite only).
+			if (config.messageSeparation || config.cacheStriping) {
 				const sid = runtime.rt.sessionId;
 				const turn = runtime.currentTurn;
 				const now = Date.now();
 				const threadStmt = db.prepare(
 					"INSERT OR IGNORE INTO conversation_thread (conversation_id, role, content, turn_index, timestamp) VALUES (?, ?, ?, ?, ?)",
 				);
+				// Schema (plan-v2.ts) is (conversation_id, tool_call_id,
+				// tool_result, turn_index, timestamp) — NOT role/content.
 				const toolStmt = db.prepare(
-					"INSERT OR IGNORE INTO tool_results (conversation_id, role, content, turn_index, timestamp) VALUES (?, ?, ?, ?, ?)",
+					"INSERT OR IGNORE INTO tool_results (conversation_id, tool_call_id, tool_result, turn_index, timestamp) VALUES (?, ?, ?, ?, ?)",
+				);
+				const toolHas = db.prepare(
+					"SELECT 1 FROM tool_results WHERE conversation_id = ? AND turn_index = ? AND tool_call_id = ? AND tool_result = ? LIMIT 1",
+				);
+				const threadHas = db.prepare(
+					"SELECT 1 FROM conversation_thread WHERE conversation_id = ? AND turn_index = ? AND role = ? AND content = ? LIMIT 1",
 				);
-				for (const m of messages) {
+				for (const [idx, m] of messages.entries()) {
 					const role = m.role;
 					const content = messageContentText(m);
 					if (role === "user" || role === "assistant") {
-						threadStmt.run(sid, role, content, turn, now);
+						if (threadHas.get(sid, turn, role, content) == null) {
+							threadStmt.run(sid, role, content, turn, now);
+						}
 					} else if (role === "toolResult" || role === "bashExecution") {
-						toolStmt.run(sid, role, content, turn, now);
+						const toolCallId = toolCallIdOf(m, `bash:${turn}:${idx}`);
+						if (toolHas.get(sid, turn, toolCallId, content) == null) {
+							toolStmt.run(sid, toolCallId, content, turn, now);
+						}
 					}
 				}
 			}

package/extensions/mega-events/context-handler/pipelineRun.ts

@@ -19,6 +19,9 @@ import { pressureFromPct, pressureRatio } from "../../mega-config.js";
 import type { MegaRuntime } from "../../mega-runtime.js";
 import type { MegaConfig } from "../../mega-config.js";
 import type { TailResultFn } from "./gateCheck.js";
+import { recordCompactLatency } from "../../mega-runtime/vc-observer.js";
+import { decideLivePath } from "../../mega-runtime/vector-cortex-live.js";
+import { VC5C_ENABLED } from "../../../src/config/vector-cortex.js";
 
 /** The non-skipped variant of the runCompact result. */
 export type RanResult = Extract<RunCompactResult, { skipped: false }>;
@@ -45,6 +48,32 @@ export function invokePipeline(
 		tailResult: TailResultFn;
 	},
 ): PipelineOutcome {
+	// VC5C: emit the rollout decision per compact event (observability seam).
+	// vcGate/vcHardFaults are not yet declared on MegaRuntime.rt — cast to the
+	// rollout shapes. Best-effort + non-fatal; decision does NOT gate behavior yet.
+	if (VC5C_ENABLED()) {
+		try {
+			const decision = decideLivePath(runtime.rt.sessionId, {
+				emit: runtime.appendEvent.bind(runtime),
+				currentGate:
+					(runtime.rt as { vcGate?: 0 | 1 | 2 | 3 | 4 }).vcGate ?? 0,
+				hardFaults:
+					(runtime.rt as { vcHardFaults?: import("../../../src/vector-cortex/rollout/types.js").RolloutHardFault[] })
+						.vcHardFaults ?? [],
+			});
+			runtime.appendEvent("vector_cortex_rollout_decision", {
+				sessionId: runtime.rt.sessionId,
+				vcActive: decision.vcActive,
+				forcedPreVc: decision.forcedPreVc,
+				mode: decision.mode,
+				bucket: decision.bucket,
+				gateIndex: decision.gateIndex,
+				promotionBlocked: decision.promotionBlocked,
+			});
+		} catch {
+			/* non-fatal: rollout decision emission never breaks compaction */
+		}
+	}
 	// Adaptive compression (Fix E): scale compression strength + keepFrom depth
 	// with how close we are to the model context limit. Null-safe: when the
 	// token-fallback path ran (pct unavailable) use the token-basis pressure
@@ -53,9 +82,19 @@ export function invokePipeline(
 		opts.pct != null
 			? pressureFromPct(opts.pct)
 			: pressureRatio(opts.currentTokens, runtime.effectiveThreshold);
+	const t0 = Date.now();
 	const ran = runCompact(pi, runtime, config, ctx, opts.messages, {
 		compressionPressure: pressure,
 	});
+	// VC0A: record compact latency on the eval observer (mode A) on every
+	// outcome so the dashboard histogram reflects real data. No-op when the
+	// observer is absent (flag off / construction failure).
+	recordCompactLatency(
+		runtime,
+		Date.now() - t0,
+		runtime.rt.sessionId,
+		runtime.rt.compactCount,
+	);
 	// D.3: skip paths fall back to replay instead of returning empty.
 	// If runCompact skipped and we have a valid trimCache, replay it
 	// (free stability win) — otherwise defer to the next event.

package/extensions/mega-events/context-handler/tailResult.ts

@@ -12,6 +12,16 @@ import type { MegaConfig } from "../../mega-config.js";
 import { stagedForTail, withRecallTail } from "../recall-tail.js";
 import { buildSeparatedPrompt, buildCacheOptimizedPrompt } from "../separated-prompt.js";
 import { messageContentText } from "./messageText.js";
+import { computeContentDigest } from "../../../src/dedup/digest.js";
+
+// P2.5: per-runtime cross-turn prompt-prefix footprints for stable-prefix
+// measurement. WeakMap keyed by MegaRuntime so the entry dies with the runtime
+// (same lifecycle as a session boundary in practice — a new session re-creates
+// the pipeline over the same runtime, but the prior turn's fingerprints must
+// still be visible for cross-turn compare; a fresh runtime has an empty map and
+// the sessionId guard below blocks cross-session compare).
+type TurnPrefix = { sessionId: string; turn: number; fingerprints: string[] };
+const lastTurnPrefix = new WeakMap<MegaRuntime, TurnPrefix>();
 
 /**
  * Build the tail injection closure. Returns undefined when nothing is staged
@@ -39,23 +49,54 @@ export function buildTailResult(
 		} else if (config.messageSeparation) {
 			result = buildSeparatedPrompt(result);
 		}
-		// P2.5: log prefix stability (fire-and-forget, non-fatal).
-		// tailResult is sync, so use .then().catch() on the dynamic import.
+		// P2.5: log cross-turn stable-prefix length (cache-hit proxy). After the
+		// prompt is built (separated or cache-optimized), fingerprint each leading
+		// message and count how many are byte-identical to the previous turn's
+		// prompt, in order. A high stablePrefix = the provider KV-cache prefix is
+		// re-used (cache hit). Fire-and-forget + non-fatal.
+		//
+		// tailResult may run several times per turn (gate return / replay /
+		// debounce / live-trim), so the sessionId+turn guard measures once per
+		// turn — compare against the PREVIOUS turn's stored footprint, then store
+		// this turn's for the next comparison. Cross-session compares are skipped
+		// via the stored sessionId check (belt-and-suspenders; the WeakMap entry
+		// is scoped to this runtime, which owns the session).
 		if (result.length > 1) {
-			import("../../../src/cache-stripe-impl.js").then(({ computeStabilityScore }) => {
-				const stableScore = computeStabilityScore(
-					{ content: messageContentText(result[0] ?? result[0]), chunkId: "prefix", accessCount: 0, lastAccessedAt: 0 },
-					result.slice(0, 2).map((m) => ({ content: messageContentText(m), chunkId: "prefix", accessCount: 0, lastAccessedAt: 0 })),
-				);
-				runtime.logger.info("prefix_stability", {
-					stableScore: Number.isFinite(stableScore) ? stableScore : 0,
-					prefixMessages: result.length,
-					separation: config.messageSeparation ? "v2" : "off",
-					striping: config.cacheStriping ? "v3" : "off",
-				});
-			}).catch(() => {
+			try {
+				const sessionId = runtime.rt.sessionId;
+				const turn = runtime.currentTurn;
+				const prev = lastTurnPrefix.get(runtime);
+				const isNewTurn =
+					!prev || prev.sessionId !== sessionId || prev.turn !== turn;
+				if (isNewTurn) {
+					const fingerprints = result.map((m) =>
+						// Role prefix disambiguates identical text across variants
+						// (roles are a fixed enum — no realistic fingerprint collision).
+						computeContentDigest(`${m.role}|${messageContentText(m)}`).contentHash,
+					);
+					let stablePrefix = 0;
+					if (prev && prev.sessionId === sessionId) {
+						for (let i = 0; i < fingerprints.length; i++) {
+							if (
+								i >= prev.fingerprints.length ||
+								prev.fingerprints[i] !== fingerprints[i]
+							) {
+								break;
+							}
+							stablePrefix++;
+						}
+					}
+					lastTurnPrefix.set(runtime, { sessionId, turn, fingerprints });
+					runtime.logger.info("prefix_stability", {
+						stablePrefix,
+						totalMessages: result.length,
+						separation: config.messageSeparation ? "v2" : "off",
+						striping: config.cacheStriping ? "v3" : "off",
+					});
+				}
+			} catch {
 				// Non-fatal: stability logging is best-effort.
-			});
+			}
 		}
 		return { messages: result };
 	};

package/extensions/mega-runtime/dashboard-snapshot.ts

@@ -39,6 +39,9 @@ export interface SnapshotBuildContext {
 	readonly pressureBand: string;
 	readonly pressure: number;
 	readonly effectiveThreshold: number;
+	/** VC0A: count of latency samples the eval observer histogram should show
+	 *  (0 when the observer is absent / flag off). */
+	readonly vcObserverSamples?: number;
 	readonly statusKey: string | undefined;
 	readonly lastCtxTokens: number | null;
 	readonly lastCtxPercent: number | null;
@@ -76,6 +79,7 @@ export function buildDashboardSnapshot(ctx: SnapshotBuildContext): DashboardSnap
 		tier: ctx.pressureBand,
 		presetTier: ctx.config.tier,
 		pressure: ctx.pressure,
+		vcObserverSamples: ctx.vcObserverSamples ?? 0,
 		config: {
 			fastGatePct: ctx.config.fastGatePct,
 			thresholdTokens: ctx.effectiveThreshold,
@@ -132,17 +136,17 @@ export function buildDashboardSnapshot(ctx: SnapshotBuildContext): DashboardSnap
 		repo: ctx.repo,
 		compression: {
 			session: {
-				tokensIn: ctx.rt.tokensSaved + (ctx.st.totalTokenEstimate - ctx.st.originalTokens),
+				tokensIn: ctx.st.originalTokens,
 				tokensOut: ctx.st.totalTokenEstimate,
 				tokensFreed: ctx.rt.tokensSaved,
-				compressionPct: ctx.rt.tokensSaved / Math.max(1, ctx.rt.tokensSaved + (ctx.st.totalTokenEstimate - ctx.st.originalTokens)),
+				compressionPct: ctx.rt.tokensSaved / Math.max(1, ctx.st.originalTokens),
 				dedupPct: ctx.rt.dedupAttempts > 0 ? ctx.rt.dedupSkips / ctx.rt.dedupAttempts : 0,
 			},
 			repo: {
-				tokensIn: ctx.repo.tokensSaved + (ctx.repo.totalTokenEstimate - ctx.repo.originalTokens),
+				tokensIn: ctx.repo.originalTokens,
 				tokensOut: ctx.repo.totalTokenEstimate,
 				tokensFreed: ctx.repo.tokensSaved,
-				compressionPct: ctx.repo.tokensSaved / Math.max(1, ctx.repo.tokensSaved + (ctx.repo.totalTokenEstimate - ctx.repo.originalTokens)),
+				compressionPct: ctx.repo.tokensSaved / Math.max(1, ctx.repo.originalTokens),
 				dedupPct: ctx.repo.dedupAttempts > 0 ? ctx.repo.dedupCollapsed / ctx.repo.dedupAttempts : 0,
 			},
 		},
@@ -155,7 +159,9 @@ export function buildDashboardSnapshot(ctx: SnapshotBuildContext): DashboardSnap
 			// per-session in rt and there's no cumulative counter yet.
 			total: ctx.repo.dedupCollapsed,
 			sessionTokensSaved: ctx.rt.cacheHitTokens,
-			totalTokensSaved: ctx.repo.dedupCollapsed > 0 ? ctx.repo.dedupCollapsed * 100 : 0,
+			// Cumulative tokens saved across all sessions in this repo —
+			// was a placeholder (dedupCollapsed * 100).
+			totalTokensSaved: ctx.repo.tokensSaved,
 		},
 		compacts: {
 			session: ctx.rt.compactCount,
@@ -168,7 +174,7 @@ export function buildDashboardSnapshot(ctx: SnapshotBuildContext): DashboardSnap
 			},
 			cacheHit: {
 				sessionSec: ctx.rt.cacheHitTokens / 1000,
-				totalSec: (ctx.repo.dedupCollapsed * 100) / 1000,
+				totalSec: ctx.repo.tokensSaved / 1000,
 			},
 		},
 		model: ctx.currentModel

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

@@ -42,6 +42,7 @@ import type { Dashboard } from "../mega-dashboard.js";
 import type { WidgetData } from "./widget.js";
 import { computeMegaSnapshot } from "./snapshot.js";
 import { buildDashboardSnapshot } from "./dashboard-snapshot.js";
+import { getVcObserver } from "./vc-observer.js";
 import {
 	type RuntimeHelpersContext,
 	materialSigImpl,
@@ -65,6 +66,10 @@ export interface RuntimeSnapshotContext extends RuntimeHelpersContext {
 	store: VectorStore;
 	config: MegaConfig;
 	dashboard: Dashboard;
+	// VC0A: appendEvent + currentStateDir are consumed by getVcObserver()
+	// (vc-observer.ts WeakMap cache) to surface how many latency samples the
+	// dashboard histogram should expect.
+	appendEvent(event: string, fields: Record<string, unknown>): void;
 	currentStateDir: string;
 	widgetData: WidgetData | null;
 	/** v0.8.5: material-change signature; read + written by snapshot(). Public so
@@ -164,6 +169,7 @@ export function snapshotImpl(
 			pressureBand: self.pressureBand,
 			pressure: self.pressure,
 			effectiveThreshold: self.effectiveThreshold,
+			vcObserverSamples: getVcObserver(self)?.rows().length ?? 0,
 			statusKey: self.statusKey,
 			lastCtxTokens: self.lastCtxTokens,
 			lastCtxPercent: self.lastCtxPercent,