pi-mega-compact 0.20.22 → 0.20.24

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-rag-settings-helpers.js

@@ -50,6 +50,8 @@ export const SETTINGS = [
             boolFlag("MEGACOMPACT_MEMORY_GRAPH", "Memory Graph", "Dashboard-oriented memory graph traversal", true),
             boolFlag("MEGACOMPACT_HYDE", "HyDE", "Generate hypothetical answer via LLM, embed it, RRF-fuse", true, true),
             boolFlag("MEGACOMPACT_NEW_UI", "New Dashboard UI", "Tailwind + shadcn visual design (sidebar, glass panels)", true),
+            boolDirect("MEGACOMPACT_MESSAGE_SEPARATION", "Message Separation (P2)", "PLAN_V2: split conversation thread from tool results to grow stable cache prefix", false),
+            boolDirect("MEGACOMPACT_CACHE_STRIPING", "Cache Striping (P3)", "PLAN_V2: order stable context by stability score so durable chunks lead the prompt", false),
         ],
     },
     {

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/agent-handlers/turnEndHandler/cacheStripe.js

@@ -10,12 +10,23 @@ export function cacheStripe(event, runtime, config) {
             const currentTurn = event.turnIndex;
             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.text;
+                            if (typeof t === "string")
+                                textToEmbed += t + " ";
+                        }
                     }
                 }
             }

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

@@ -15,14 +15,20 @@ 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.
  */
 export async function persistEpochAndMaintain(runtime, config, ran) {
-    // 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()}`;
@@ -37,11 +43,27 @@ export async function persistEpochAndMaintain(runtime, config, ran) {
                 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.
             try {
-                stampTurnsEpochFor(config, runtime.rt.sessionId, epoch.epochId, runtime.currentStateDir);
+                stampTurnsEpochFor(config, runtime.rt.sessionId, epochId, runtime.currentStateDir);
             }
             catch {
                 /* non-fatal: epoch stamping never breaks compaction */
@@ -193,4 +215,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 */
+        }
+    }
 }