pi-mega-compact 0.20.22 → 0.20.23

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

@@ -8,16 +8,14 @@
  * Resolution order (the launch dir is the OWNer of this dashboard):
  * 1. The launch stateDir's OWN dashboard.json — the pi process that launched
  *    this dashboard server is the session you are coding in, so its snapshot
- *    is "this session" by definition. This must win over any other repo
- *    regardless of last_seen freshness; otherwise a more-recently-active
- *    OTHER repo steals the "this session" slot and your actual session gets
- *    demoted to an "other" gauge, producing the exact duplicate-gauge bug
- *    (this session + pi-<launchrepo> both showing the same active session
- *    split across two boxes).
- * 2. Most recently seen OTHER repo (by last_seen in repo_registry) whose
- *    dashboard.json exists and has a non-null updatedAt — fallback for when
- *    the launch dir has no live snapshot yet (e.g. dashboard launched before
- *    any compaction wrote dashboard.json).
+ *    is "this session" by definition. It must be fresh (updatedAt within
+ *    STALE_MS) to win; otherwise the launch dir's pi process has exited or
+ *    stopped snapshotting, and showing its stale data as "this session" is
+ *    misleading. When stale, fall through to the most-recently-active repo.
+ * 2. Most recently seen repo (by last_seen in repo_registry) whose
+ *    dashboard.json exists and has a non-null updatedAt — this includes the
+ *    launch dir via the registry, so an exited-but-recent launch session
+ *    still appears.
  * 3. The static launch stateDir's dashboard.json (original behavior).
  */
 import { existsSync } from "node:fs";
@@ -25,14 +23,29 @@ import { join } from "node:path";
 import { createRequire } from "node:module";
 import { readSnapshot } from "./snapshot.js";
 import { getIndexDir } from "./index-reader.js";
+/** Snapshots older than this are stale — the owning pi session has exited or
+ *  stopped snapshotting. 5 minutes covers the slowest possible context event
+ *  cadence + debounce + snapshot throttle. */
+const STALE_MS = 5 * 60 * 1000;
+/** Age of a snapshot's updatedAt in ms. Returns Infinity for invalid dates. */
+function snapshotAgeMs(updatedAt) {
+    if (!updatedAt)
+        return Infinity;
+    const t = Date.parse(updatedAt);
+    if (Number.isNaN(t))
+        return Infinity;
+    return Date.now() - t;
+}
 const require = createRequire(import.meta.url);
 /**
- * Find the most recently active OTHER repo's stateDir (excluding the launch
- * dir, which is handled by the caller) by scanning the repo registry for the
- * repo with the highest last_seen whose dashboard.json exists and has a
- * non-null updatedAt. Returns null if no suitable repo is found.
+ * Find the most recently active repo's stateDir by scanning the repo registry
+ * for the repo with the highest last_seen whose dashboard.json exists and has
+ * a non-null updatedAt. Unlike the old `mostRecentOtherRepoStateDir`, this
+ * does NOT exclude the launch dir — when the launch dir's snapshot is stale
+ * but its registry entry has a recent last_seen (e.g. session just exited),
+ * it should still be eligible.
  */
-function mostRecentOtherRepoStateDir(launchStateDir) {
+function mostRecentActiveRepoStateDir(_launchStateDir) {
     const indexPath = join(getIndexDir(), "index.sqlite");
     if (!existsSync(indexPath))
         return null;
@@ -43,9 +56,8 @@ function mostRecentOtherRepoStateDir(launchStateDir) {
         const rows = db
             .prepare(`SELECT state_dir, last_seen FROM repo_registry
 				 WHERE state_dir IS NOT NULL AND last_seen IS NOT NULL
-				   AND state_dir != @launch
 				 ORDER BY last_seen DESC`)
-            .all({ launch: launchStateDir });
+            .all();
         for (const r of rows) {
             const dashPath = join(r.state_dir, "dashboard.json");
             if (!existsSync(dashPath))
@@ -70,24 +82,26 @@ function mostRecentOtherRepoStateDir(launchStateDir) {
     }
 }
 /**
- * Resolve the best snapshot to serve. Tries the most recently active repo's
- * dashboard.json first, then falls back to the static launch path.
+ * Resolve the best snapshot to serve. The launch dir wins when its snapshot is
+ * fresh; when stale (or missing) the most recently active repo wins instead.
  */
 export function resolveSnapshot(staticSnapshotPath, staticStateDir) {
-    // 1. The launch dir's OWN snapshot is "this session" — the pi process that
-    //    launched this dashboard is the session you are coding in. It wins over
-    //    any other repo regardless of last_seen, so a more-recently-active OTHER
-    //    repo can't steal the "this session" slot and demote your actual session
-    //    to a duplicate "other" gauge.
+    // 1. The launch dir's OWN snapshot is "this session" — but only when it's
+    //    fresh (updated within STALE_MS). A stale launch-dir snapshot means
+    //    the pi process that owned it has exited or stopped snapshotting; serving
+    //    its frozen data as "this session" is misleading. Fall through to the
+    //    most-recently-active repo so the user sees the session that is actually
+    //    running.
     if (existsSync(staticSnapshotPath)) {
         const launchSnap = readSnapshot(staticSnapshotPath);
-        if (launchSnap.updatedAt) {
+        if (launchSnap.updatedAt && snapshotAgeMs(launchSnap.updatedAt) < STALE_MS) {
             return { snapshot: launchSnap, stateDir: staticStateDir };
         }
     }
-    // 2. Fall back to the most recently active OTHER repo (launch dir had no
-    //    live snapshot yet).
-    const activeDir = mostRecentOtherRepoStateDir(staticStateDir);
+    // 2. Fall back to the most recently active OTHER repo (launch dir stale or
+    //    had no live snapshot yet). The registry includes the launch dir too,
+    //    so a recently-exited launch session can still appear.
+    const activeDir = mostRecentActiveRepoStateDir(staticStateDir);
     if (activeDir) {
         const activePath = join(activeDir, "dashboard.json");
         const snap = readSnapshot(activePath);

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

@@ -193,6 +193,7 @@ export function handleSetupDetect(req, res, _ctx) {
 // ---------------------------------------------------------------------------
 const OLLAMA_DEFAULT_URL = "http://localhost:11434/api/embeddings"; // guardrails-allow PREVENT-PI-004: localhost-only config string, not a runtime fetch
 const LLAMA_DEFAULT_URL = "http://localhost:8080/v1/embeddings"; // guardrails-allow PREVENT-PI-004: localhost-only config string, not a runtime fetch
+const ONNX_DEFAULT_URL = "http://localhost:8081/v1/embeddings"; // guardrails-allow PREVENT-PI-004: localhost-only config string, not a runtime fetch — TEI / ONNX embedding server
 function readJsonBody(req, cb) {
     let body = "";
     let tooBig = false;
@@ -237,7 +238,7 @@ export function handleSetupConfigure(req, res, ctx) {
         }
         const body = parsed.value;
         const embedder = body.embedder;
-        if (embedder !== "ollama" && embedder !== "llama" && embedder !== "trigram" && embedder !== "custom") {
+        if (embedder !== "ollama" && embedder !== "llama" && embedder !== "trigram" && embedder !== "custom" && embedder !== "onnx") {
             res.writeHead(400, { "Content-Type": "application/json" });
             res.end(JSON.stringify({ error: "invalid_embedder" }));
             return;
@@ -249,6 +250,8 @@ export function handleSetupConfigure(req, res, ctx) {
             resolvedUrl = typeof url === "string" && url ? url : OLLAMA_DEFAULT_URL;
         else if (embedder === "llama")
             resolvedUrl = typeof url === "string" && url ? url : LLAMA_DEFAULT_URL;
+        else if (embedder === "onnx")
+            resolvedUrl = typeof url === "string" && url ? url : ONNX_DEFAULT_URL;
         else if (embedder === "custom") {
             // Third-party / remote endpoint. Requires a URL; opts in to the
             // non-loopback allowlist so embeddingConfigFromEnv() accepts it.

package/dist/extensions/dashboard-server/routes-vector-cortex-crystals.js

@@ -25,13 +25,19 @@
  */
 import { VC7A_ENABLED } from "../../src/config.js";
 import { sendJson } from "./routes-vector-cortex-shared.js";
+import { countVcEvents, vcCount } from "./vc-event-counts.js";
+// Actual events emitted by src/vector-cortex/cache/crystal-emit.ts.
+const CRYSTAL_EVENTS = [
+    "vector_cortex_crystal_written",
+    "vector_cortex_crystal_collision",
+];
 /**
  * Reader-only GET /api/vector-cortex/cache-crystals (VC7A).
  *
  * Counts, byte volumes, and CRY_* codes only — a static reader-only aggregate
  * seam with the same shape as the VC6A/VC6B/VC6C handlers.
  */
-export function handleVectorCortexCrystals(req, res, _ctx) {
+export function handleVectorCortexCrystals(req, res, ctx) {
     const url = req.url ?? "";
     const path = url.split("?")[0] ?? url;
     if (path !== "/api/vector-cortex/cache-crystals")
@@ -41,6 +47,7 @@ export function handleVectorCortexCrystals(req, res, _ctx) {
         return true;
     }
     const enabled = VC7A_ENABLED();
+    const counts = countVcEvents(ctx.stateDir, CRYSTAL_EVENTS);
     // Flag-off routes to mode C: with VC7A off nothing is served from the crystal
     // cache, which is exactly the spec's "cache bypass" outcome. Reporting A (hit)
     // or B (fresh render forced by a miss) would imply a cache path that is not
@@ -49,16 +56,17 @@ export function handleVectorCortexCrystals(req, res, _ctx) {
     const body = {
         enabled,
         mode,
-        crystalCount: 0,
+        crystalCount: vcCount(counts, "vector_cortex_crystal_written"),
         totalBytes: 0,
         hits: 0,
         misses: 0,
         hitBytes: 0,
         writes: 0,
         duplicateWrites: 0,
-        collisions: 0,
+        collisions: vcCount(counts, "vector_cortex_crystal_collision"),
         lastFailure: null,
         updatedAt: new Date().toISOString(),
+        deferredReason: "crystal_store_not_instantiated_v0_20_23",
     };
     sendJson(res, 200, body);
     return true;

package/dist/extensions/dashboard-server/routes-vector-cortex-diagnostics.js

@@ -27,13 +27,16 @@
  */
 import { VC7C_ENABLED } from "../../src/config.js";
 import { sendJson } from "./routes-vector-cortex-shared.js";
+import { countVcEvents, vcCount } from "./vc-event-counts.js";
+// Actual events emitted by src/vector-cortex/cache/diagnostics-emit.ts.
+const DIAGNOSTICS_EVENTS = ["vector_cortex_cache_serve_blocked"];
 /**
  * Reader-only GET /api/vector-cortex/cache-diagnostics (VC7C).
  *
  * Per-miss-class counts, breaker state, and CACHE and M5 codes only — a static
  * reader-only aggregate seam with the same shape as the VC7B economics handler.
  */
-export function handleVectorCortexDiagnostics(req, res, _ctx) {
+export function handleVectorCortexDiagnostics(req, res, ctx) {
     const url = req.url ?? "";
     const path = url.split("?")[0] ?? url;
     if (path !== "/api/vector-cortex/cache-diagnostics")
@@ -43,6 +46,7 @@ export function handleVectorCortexDiagnostics(req, res, _ctx) {
         return true;
     }
     const enabled = VC7C_ENABLED();
+    const counts = countVcEvents(ctx.stateDir, DIAGNOSTICS_EVENTS);
     // Flag-off routes to mode C: with VC7C off the diagnostics/breaker reporter is
     // suppressed, so no cache serve is attested here and the surface reports the
     // all-cache bypass outcome. Reporting A (crystal served) or B (fresh render
@@ -58,10 +62,11 @@ export function handleVectorCortexDiagnostics(req, res, _ctx) {
         requestMisses: 0,
         generationMisses: 0,
         unknownMisses: 0,
-        serveBlocked: 0,
+        serveBlocked: vcCount(counts, "vector_cortex_cache_serve_blocked"),
         breakerState: "closed",
         lastFailure: null,
         updatedAt: new Date().toISOString(),
+        deferredReason: "cache_classifier_not_wired_v0_20_23",
     };
     sendJson(res, 200, body);
     return true;

package/dist/extensions/dashboard-server/routes-vector-cortex-economics.js

@@ -53,6 +53,7 @@ export function handleVectorCortexEconomics(req, res, _ctx) {
         unprovenExclusions: 0,
         lastFailure: null,
         updatedAt: new Date().toISOString(),
+        deferredReason: "economics_not_computed_v0_20_23",
     };
     sendJson(res, 200, body);
     return true;

package/dist/extensions/dashboard-server/routes-vector-cortex-heal.js

@@ -21,8 +21,18 @@
  */
 import { VC6A_ENABLED, VC6B_ENABLED } from "../../src/config.js";
 import { sendJson } from "./routes-vector-cortex-shared.js";
+import { countVcEvents, vcCount } from "./vc-event-counts.js";
+// Actual event names emitted by src/vector-cortex/heal/emit.ts + restore-emit.ts.
+const CLOSURE_EVENTS = [
+    "vector_cortex_closure_optimized",
+    "vector_cortex_closure_proof_rejected",
+];
+const RESTORE_EVENTS = [
+    "vector_cortex_source_restored",
+    "vector_cortex_restore_digest_rejected",
+];
 /** Reader-only GET /api/vector-cortex/closure-proof (VC6A). */
-export function handleVectorCortexClosureProof(req, res, _ctx) {
+export function handleVectorCortexClosureProof(req, res, ctx) {
     const url = req.url ?? "";
     const path = url.split("?")[0] ?? url;
     if (path !== "/api/vector-cortex/closure-proof")
@@ -32,13 +42,14 @@ export function handleVectorCortexClosureProof(req, res, _ctx) {
         return true;
     }
     const enabled = VC6A_ENABLED();
+    const counts = countVcEvents(ctx.stateDir, CLOSURE_EVENTS);
     // Flag-off routes to mode B (conservative closure, no reduction) per spec.
     const mode = enabled ? "A" : "B";
     const body = {
         enabled,
         mode,
-        optimizations: 0,
-        proofRejections: 0,
+        optimizations: vcCount(counts, "vector_cortex_closure_optimized"),
+        proofRejections: vcCount(counts, "vector_cortex_closure_proof_rejected"),
         retainedEdgeTotal: 0,
         removedEdgeTotal: 0,
         conservativeTraversalTotal: 0,
@@ -56,7 +67,7 @@ export function handleVectorCortexClosureProof(req, res, _ctx) {
  * seam (same shape as the VC6A handler): there is no payload endpoint and never
  * will be, so no restored bytes/span ids/node ids/ledger text can leak here.
  */
-export function handleVectorCortexRestore(req, res, _ctx) {
+export function handleVectorCortexRestore(req, res, ctx) {
     const url = req.url ?? "";
     const path = url.split("?")[0] ?? url;
     if (path !== "/api/vector-cortex/restore")
@@ -66,6 +77,7 @@ export function handleVectorCortexRestore(req, res, _ctx) {
         return true;
     }
     const enabled = VC6B_ENABLED();
+    const counts = countVcEvents(ctx.stateDir, RESTORE_EVENTS);
     // Flag-off routes to mode C: with VC6B off there is no exact-restoration path
     // at all, so the honest OFF view is the disclose-loss mode (old context is
     // omitted rather than inferred) — mirroring how VC6A's OFF view reports the
@@ -74,10 +86,10 @@ export function handleVectorCortexRestore(req, res, _ctx) {
     const body = {
         enabled,
         mode,
-        restoreAttempts: 0,
+        restoreAttempts: vcCount(counts, "vector_cortex_source_restored"),
         restoredCount: 0,
         missingCount: 0,
-        digestRejections: 0,
+        digestRejections: vcCount(counts, "vector_cortex_restore_digest_rejected"),
         lastRejection: null,
         updatedAt: new Date().toISOString(),
     };

package/dist/extensions/dashboard-server/routes-vector-cortex-policy.js

@@ -39,6 +39,7 @@ export function handleVectorCortexPolicy(req, res, _ctx) {
         pressureVersion: 1,
         lastFailure: null,
         updatedAt: new Date().toISOString(),
+        deferredReason: "shadow_controller_not_instantiated_v0_20_23",
     };
     sendJson(res, 200, body);
     return true;

package/dist/extensions/dashboard-server/routes-vector-cortex-reconstruct.js

@@ -8,7 +8,13 @@
  */
 import { VC4C_ENABLED } from "../../src/config.js";
 import { sendJson } from "./routes-vector-cortex-shared.js";
-export function handleVectorCortexReconstruct(req, res, _ctx) {
+import { countVcEvents, vcCount } from "./vc-event-counts.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",
+];
+export function handleVectorCortexReconstruct(req, res, ctx) {
     const url = req.url ?? "";
     const path = url.split("?")[0] ?? url;
     if (path !== "/api/vector-cortex/reconstruct")
@@ -18,10 +24,11 @@ export function handleVectorCortexReconstruct(req, res, _ctx) {
         return true;
     }
     const enabled = VC4C_ENABLED();
+    const counts = countVcEvents(ctx.stateDir, RECONSTRUCT_EVENTS);
     const body = {
         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/dist/extensions/dashboard-server/routes-vector-cortex-repair.js

@@ -22,6 +22,13 @@
  */
 import { VC6C_ENABLED } from "../../src/config.js";
 import { sendJson } from "./routes-vector-cortex-shared.js";
+import { countVcEvents, vcCount } from "./vc-event-counts.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",
+];
 /**
  * Reader-only GET /api/vector-cortex/repair (VC6C).
  *
@@ -30,7 +37,7 @@ import { sendJson } from "./routes-vector-cortex-shared.js";
  * never will be, so no subsystem bytes, gap ranges, high-water marks, or root
  * digests can leak here.
  */
-export function handleVectorCortexRepair(req, res, _ctx) {
+export function handleVectorCortexRepair(req, res, ctx) {
     const url = req.url ?? "";
     const path = url.split("?")[0] ?? url;
     if (path !== "/api/vector-cortex/repair")
@@ -40,6 +47,7 @@ export function handleVectorCortexRepair(req, res, _ctx) {
         return true;
     }
     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
@@ -50,10 +58,10 @@ export function handleVectorCortexRepair(req, res, _ctx) {
     const body = {
         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/dist/extensions/dashboard-server/routes-vector-cortex-shards.js

@@ -19,10 +19,16 @@
  */
 import { VC4A_ENABLED } from "../../src/config.js";
 import { sendJson } from "./routes-vector-cortex-shared.js";
+import { countVcEvents, vcCount } from "./vc-event-counts.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"];
 /**
  * Reader-only GET /api/vector-cortex/shards (VC4A).
  */
-export function handleVectorCortexShards(req, res, _ctx) {
+export function handleVectorCortexShards(req, res, ctx) {
     const url = req.url ?? "";
     const path = url.split("?")[0] ?? url;
     if (path !== "/api/vector-cortex/shards")
@@ -33,11 +39,13 @@ export function handleVectorCortexShards(req, res, _ctx) {
         return true;
     }
     const enabled = VC4A_ENABLED();
+    const counts = countVcEvents(ctx.stateDir, SHARD_EVENTS);
     const body = {
         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/dist/extensions/dashboard-server/vc-event-counts.js

@@ -0,0 +1,63 @@
+/**
+ * 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, eventNames, maxLines = 10000) {
+    const counts = new Map();
+    let raw;
+    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];
+        if (line.length === 0)
+            continue;
+        let ev = null;
+        try {
+            ev = JSON.parse(line);
+        }
+        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, name) {
+    return counts.get(name) ?? 0;
+}

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

@@ -15,6 +15,9 @@ import { openTurnStore } from "../../../src/store/turns/connection.js";
 import { buildTopicModel, createTopicStore, bumpWikiCompactCounter, applyOverridesAfterRebuild, applyFullOverridesAfterRebuild, } from "../../../src/topics/index.js";
 import { assignNewMemoriesIncremental } from "../../../src/wiki/index.js";
 import { TrigramEmbedder } from "../../../src/embedder.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";
 /**
  * Persist the checkpoint_epoch, stamp turns, rebuild the auto-wiki, seed the
  * topic model, and dedup — gated on dbMirror. Non-fatal end-to-end.
@@ -193,4 +196,35 @@ export async function persistEpochAndMaintain(runtime, config, ran) {
             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), {
+                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), {
+                subsystem: "post_compact",
+                generation: 1,
+                backoffMs: 0,
+                gapSize: 0,
+            });
+        }
+        catch {
+            /* non-fatal: VC6C heal emit never breaks compaction */
+        }
+    }
 }

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

@@ -1,11 +1,39 @@
 import { runCompact } from "../../mega-pipeline.js";
 import { pressureFromPct, pressureRatio } from "../../mega-config.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";
 /**
  * Invoke the compaction pipeline with adaptive pressure. Returns a tailed view
  * ("return") when compaction skipped, or "proceed" with the non-skipped result
  * and the computed pressure (consumed by live-trim's critical-over hatch).
  */
 export function invokePipeline(pi, runtime, config, ctx, opts) {
+    // 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.vcGate ?? 0,
+                hardFaults: runtime.rt
+                    .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
@@ -13,9 +41,14 @@ export function invokePipeline(pi, runtime, config, ctx, opts) {
     const pressure = 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/dist/extensions/mega-runtime/dashboard-snapshot.js

@@ -17,6 +17,7 @@ export function buildDashboardSnapshot(ctx) {
         tier: ctx.pressureBand,
         presetTier: ctx.config.tier,
         pressure: ctx.pressure,
+        vcObserverSamples: ctx.vcObserverSamples ?? 0,
         config: {
             fastGatePct: ctx.config.fastGatePct,
             thresholdTokens: ctx.effectiveThreshold,
@@ -73,17 +74,17 @@ export function buildDashboardSnapshot(ctx) {
         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,
             },
         },
@@ -96,7 +97,9 @@ export function buildDashboardSnapshot(ctx) {
             // 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,
@@ -109,7 +112,7 @@ export function buildDashboardSnapshot(ctx) {
             },
             cacheHit: {
                 sessionSec: ctx.rt.cacheHitTokens / 1000,
-                totalSec: (ctx.repo.dedupCollapsed * 100) / 1000,
+                totalSec: ctx.repo.tokensSaved / 1000,
             },
         },
         model: ctx.currentModel