pi-mega-compact 0.20.23 → 0.20.25

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

@@ -26,6 +26,7 @@ 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 { deriveVcStatus } from "./vc-status.js";
 import type { VectorCortexRepairView } from "./api-contracts/vector-cortex.js";
 
 // Actual event names emitted by src/vector-cortex/heal/repair-emit.ts.
@@ -75,6 +76,10 @@ export function handleVectorCortexRepair(
     lastBackoffMs: null,
     lastFailure: null,
     updatedAt: new Date().toISOString(),
+    status: deriveVcStatus({
+      enabled,
+      hasData: vcCount(counts, "vector_cortex_repair_planned") > 0,
+    }),
   };
   sendJson(res, 200, body);
   return true;

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

@@ -24,6 +24,7 @@ import type { RouteContext } from "./routes-core.js";
 import { VC4B_ENABLED } from "../../src/config.js";
 import { sendJson } from "./routes-vector-cortex-shared.js";
 import type { VectorCortexResidualView } from "./api-contracts/vector-cortex.js";
+import { deriveVcStatus } from "./vc-status.js";
 
 /**
  * Reader-only GET /api/vector-cortex/residual (VC4B).
@@ -54,6 +55,7 @@ export function handleVectorCortexResidual(
     encodedByteTotal: 0,
     exactByteTotal: 0,
     updatedAt: new Date().toISOString(),
+    status: deriveVcStatus({ enabled, hasData: false, structuralOnly: true }),
   };
   sendJson(res, 200, body);
   return true;

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

@@ -13,17 +13,29 @@
  */
 
 import type { IncomingMessage, ServerResponse } from "node:http";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
 import type { RouteContext } from "./routes-core.js";
 import { VC5C_ENABLED } from "../../src/config.js";
 import { ROLLOUT_GATES, ROLLOUT_BUCKETS } from "../../src/vector-cortex/rollout/types.js";
 import { sendJson } from "./routes-vector-cortex-shared.js";
+import { countVcEvents, vcCount } from "./vc-event-counts.js";
+import { deriveVcStatus } from "./vc-status.js";
 import type { VectorCortexRolloutView } from "./api-contracts/vector-cortex.js";
 
+// Rollout events: assigned/promotion-blocked from rollout/emit.ts, plus the
+// explicit decision event appended by pipelineRun.ts:79 after decideLivePath.
+const ROLLOUT_EVENTS = [
+  "vector_cortex_rollout_assigned",
+  "vector_cortex_rollout_promotion_blocked",
+  "vector_cortex_rollout_decision",
+] as const;
+
 /** Reader-only GET /api/vector-cortex/rollout (VC5C). */
 export function handleVectorCortexRollout(
   req: IncomingMessage,
   res: ServerResponse,
-  _ctx: RouteContext,
+  ctx: RouteContext,
 ): boolean {
   const url = req.url ?? "";
   const path = url.split("?")[0] ?? url;
@@ -34,6 +46,12 @@ export function handleVectorCortexRollout(
   }
 
   const enabled = VC5C_ENABLED();
+  const counts = countVcEvents(ctx.stateDir, ROLLOUT_EVENTS);
+  const eventCount =
+    vcCount(counts, "vector_cortex_rollout_assigned") +
+    vcCount(counts, "vector_cortex_rollout_promotion_blocked") +
+    vcCount(counts, "vector_cortex_rollout_decision");
+  const sessionCount = enabled ? distinctRolloutSessions(ctx.stateDir) : 0;
   const gateIndex = 0; // Ephemeral rollout state: no durable gate in this sprint.
   const gatePct = ROLLOUT_GATES[gateIndex]!;
   const body: VectorCortexRolloutView = {
@@ -42,11 +60,48 @@ export function handleVectorCortexRollout(
     gatePct: enabled ? gatePct : 0,
     buckets: ROLLOUT_BUCKETS,
     bucketCount: enabled ? gatePct * 100 : 0,
-    events: 0,
-    sessions: 0,
+    events: enabled ? eventCount : 0,
+    sessions: enabled ? sessionCount : 0,
     promotionBlocked: false,
     updatedAt: new Date().toISOString(),
+    status: deriveVcStatus({ enabled, hasData: eventCount > 0 }),
   };
   sendJson(res, 200, body);
   return true;
 }
+
+/**
+ * Count distinct session ids among rollout_assigned events in the tail of
+ * events.log. Best-effort: a missing/unreadable log or malformed lines yield 0.
+ * Only the `sessionId` field of rollout_assigned lines is inspected (aggregate
+ * only, never session payloads/prompts).
+ */
+function distinctRolloutSessions(stateDir: string): number {
+  const seen = new Set<string>();
+  let raw: string;
+  try {
+    raw = readFileSync(join(stateDir, "events.log"), "utf-8");
+  } catch {
+    return 0;
+  }
+  const lines = raw.split("\n");
+  const start = Math.max(0, lines.length - 10000);
+  for (let i = start; i < lines.length; i++) {
+    const line = lines[i] as string;
+    if (line.length === 0) continue;
+    let ev: { event?: unknown; sessionId?: unknown } | null = null;
+    try {
+      ev = JSON.parse(line) as { event?: unknown; sessionId?: unknown };
+    } catch {
+      continue;
+    }
+    if (
+      ev?.event === "vector_cortex_rollout_assigned" &&
+      typeof ev.sessionId === "string" &&
+      ev.sessionId.length > 0
+    ) {
+      seen.add(ev.sessionId);
+    }
+  }
+  return seen.size;
+}

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

@@ -24,6 +24,7 @@ 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";
+import { deriveVcStatus } from "./vc-status.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
@@ -60,6 +61,10 @@ export function handleVectorCortexShards(
     byteTotal: 0,
     protectedByteTotal: 0,
     updatedAt: new Date().toISOString(),
+    status: deriveVcStatus({
+      enabled,
+      hasData: vcCount(counts, "vector_cortex_shard_manifest_built") > 0,
+    }),
   };
   sendJson(res, 200, body);
   return true;

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

@@ -32,6 +32,7 @@ import type { TopologyCandidate, TopologyEmit } from "../../src/vector-cortex/to
 import type { CortexRecordV1 } from "../../src/vector-cortex/cortex/types.js";
 import { sendJson } from "./routes-vector-cortex-shared.js";
 import type { VectorCortexTopologyView } from "./api-contracts/vector-cortex.js";
+import { deriveVcStatus } from "./vc-status.js";
 
 /** Well-known cortex record kind that carries a canonical candidate payload. */
 const TOPOLOGY_RECORD_KIND = "topology";
@@ -112,6 +113,7 @@ export function handleVectorCortexTopology(
       ? { nodes, edges, generationDigest }
       : {}),
     updatedAt: new Date().toISOString(),
+    status: deriveVcStatus({ enabled: active, hasData: summary.recordCount > 0 }),
   };
   sendJson(res, 200, body);
   return true;

package/extensions/dashboard-server/vc-status.ts

@@ -0,0 +1,22 @@
+/**
+ * dashboard-server/vc-status.ts — shared status derivation for Vector Cortex
+ * dashboard routes. Every VC route computes a status field so the client can
+ * show meaningful state (live / awaiting data / deferred / structural) instead
+ * of bare zeros.
+ *
+ * Guardrails: PREVENT-011 (no `any`).
+ */
+
+export type VcStatus = "live" | "awaiting_data" | "deferred" | "structural" | "off";
+
+export function deriveVcStatus(opts: {
+  enabled: boolean;
+  deferredReason?: string;
+  hasData: boolean;
+  structuralOnly?: boolean;
+}): VcStatus {
+  if (!opts.enabled) return "off";
+  if (opts.deferredReason) return "deferred";
+  if (opts.structuralOnly) return "structural";
+  return opts.hasData ? "live" : "awaiting_data";
+}

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

@@ -50,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()}`;
@@ -67,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.
@@ -74,7 +93,7 @@ export async function persistEpochAndMaintain(
 				stampTurnsEpochFor(
 					config,
 					runtime.rt.sessionId,
-					epoch.epochId,
+					epochId,
 					runtime.currentStateDir,
 				);
 			} catch {
@@ -290,9 +309,9 @@ export async function persistEpochAndMaintain(
 					runtime.appendEvent(name, payload as Record<string, unknown>),
 				{
 					subsystem: "post_compact",
-					generation: 1,
+					generation: runtime.rt.compactCount,
 					backoffMs: 0,
-					gapSize: 0,
+					gapSize: ran.result.compactedFrom,
 				},
 			);
 		} catch {

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

@@ -21,6 +21,7 @@ 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 { defaultClock, type RolloutEvidence } from "../../../src/vector-cortex/rollout/gate.js";
 import { VC5C_ENABLED } from "../../../src/config/vector-cortex.js";
 
 /** The non-skipped variant of the runCompact result. */
@@ -53,13 +54,27 @@ export function invokePipeline(
 	// rollout shapes. Best-effort + non-fatal; decision does NOT gate behavior yet.
 	if (VC5C_ENABLED()) {
 		try {
+			const clock = defaultClock();
+			// Conservative evidence: fresh in-memory window (elapsed=0), not
+			// powered, so the gate can't advance — but events/sessions carry real
+			// values so the decision events reflect actual runtime activity rather
+			// than degrading every epoch to an empty mode-C read.
+			const evidence: RolloutEvidence = {
+				windowStartMs: clock.now(),
+				powered: false,
+				events: runtime.rt.compactCount,
+				sessions: 1,
+				hardFaults:
+					(runtime.rt as { vcHardFaults?: import("../../../src/vector-cortex/rollout/types.js").RolloutHardFault[] })
+						.vcHardFaults ?? [],
+			};
 			const decision = decideLivePath(runtime.rt.sessionId, {
 				emit: runtime.appendEvent.bind(runtime),
+				clock,
 				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 ?? [],
+				evidence,
+				hardFaults: evidence.hardFaults,
 			});
 			runtime.appendEvent("vector_cortex_rollout_decision", {
 				sessionId: runtime.rt.sessionId,

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-events/register.ts

@@ -5,7 +5,7 @@
  * `registerEventHandlers` which delegates to the focused sub-registration
  * functions in session/agent/context/compact handlers.
  */
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import type { MegaRuntime } from "../mega-runtime.js";
 import type { MegaConfig } from "../mega-config.js";
 import { registerSessionHandlers } from "./session-handlers.js";
@@ -13,6 +13,7 @@ import { registerAgentHandlers } from "./agent-handlers.js";
 import { registerContextHandler } from "./context-handler.js";
 import { registerCompactHandlers } from "./compact-handlers.js";
 import { registerPerfHandler } from "./perf-handler.js";
+import { registerVectorCortexRender } from "../mega-context/vector-cortex.js";
 
 /**
  * DIAG accessor for the headless test harness: the most recently constructed
@@ -30,6 +31,18 @@ export function registerEventHandlers(
 	config: MegaConfig,
 ): void {
 	lastRuntime = runtime;
+	// VC5B: wire the render+validate seam into the before_agent_start lifecycle.
+	// Registered FIRST so its no-op return (no render input on ctx) doesn't
+	// clobber a systemPrompt that a later before_agent_start handler (e.g. the
+	// legacy recall prepend in session-handlers) returns. When VC5B does
+	// prepend, it returns a new systemPrompt; the later handlers run on the
+	// recallTailInject=ON path and return undefined, so VC5B's return survives.
+	// The _ctx param is unused by the seam; pass empty for the registered seam.
+	try {
+		registerVectorCortexRender(pi, undefined as unknown as ExtensionContext, (event, fields) => {
+			try { runtime.appendEvent(event, fields); } catch { /* non-fatal */ }
+		});
+	} catch { /* non-fatal: VC5B registration never breaks startup */ }
 	// ---- Session lifecycle (state reset points) -------------------------------
 	registerSessionHandlers(pi, runtime, config);
 	registerAgentHandlers(pi, runtime, config);

package/extensions/mega-pipeline/recall.ts

@@ -26,6 +26,7 @@ import {
 	recordRecallWrite,
 } from "../mega-turn-store.js";
 import { type MegaRuntime, C } from "../mega-runtime.js";
+import { recordRecallLatency } from "../mega-runtime/vc-observer.js";
 import type { MegaConfig } from "../mega-config.js";
 
 /**
@@ -46,6 +47,7 @@ export function doRecall(
 	// are already resident in the session, so recall never re-injects context the
 	// model can already see. Best-effort — an empty window just skips dedupe.
 	const liveWindow = config.windowDedupe ? extractLiveWindow(ctx) : undefined;
+	const recallStartMs = Date.now();
 	const result = recallAndInline(
 		{
 			sessionId: sid,
@@ -165,6 +167,14 @@ export function doRecall(
 			/* non-fatal: recall provenance never breaks the recall path */
 		}
 	}
+	// VC0A: record recall latency on the eval observer (mode A) so the dashboard
+	// histogram reflects real data. No-op when the observer is absent (flag off /
+	// construction failure).
+	try {
+		recordRecallLatency(runtime, Date.now() - recallStartMs, sid, 0);
+	} catch {
+		/* non-fatal: latency recording never breaks recall */
+	}
 	return result;
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-mega-compact",
-  "version": "0.20.23",
+  "version": "0.20.25",
   "description": "Layered, local, vector-backed context compressor for pi — supersede/collapse/cluster compaction with deduped inline recall.",
   "type": "module",
   "license": "BSD-3-Clause",