pi-mega-compact 0.20.24 → 0.20.26

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

@@ -26,6 +26,7 @@
 import { VC7A_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";
 // Actual events emitted by src/vector-cortex/cache/crystal-emit.ts.
 const CRYSTAL_EVENTS = [
     "vector_cortex_crystal_written",
@@ -67,6 +68,11 @@ export function handleVectorCortexCrystals(req, res, ctx) {
         lastFailure: null,
         updatedAt: new Date().toISOString(),
         deferredReason: "crystal_store_not_instantiated_v0_20_23",
+        status: deriveVcStatus({
+            enabled,
+            deferredReason: "crystal_store_not_instantiated_v0_20_23",
+            hasData: vcCount(counts, "vector_cortex_crystal_written") > 0,
+        }),
     };
     sendJson(res, 200, body);
     return true;

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

@@ -28,6 +28,7 @@
 import { VC7C_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";
 // Actual events emitted by src/vector-cortex/cache/diagnostics-emit.ts.
 const DIAGNOSTICS_EVENTS = ["vector_cortex_cache_serve_blocked"];
 /**
@@ -67,6 +68,11 @@ export function handleVectorCortexDiagnostics(req, res, ctx) {
         lastFailure: null,
         updatedAt: new Date().toISOString(),
         deferredReason: "cache_classifier_not_wired_v0_20_23",
+        status: deriveVcStatus({
+            enabled,
+            deferredReason: "cache_classifier_not_wired_v0_20_23",
+            hasData: vcCount(counts, "vector_cortex_cache_serve_blocked") > 0,
+        }),
     };
     sendJson(res, 200, body);
     return true;

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

@@ -24,6 +24,7 @@
  */
 import { VC7B_ENABLED } from "../../src/config.js";
 import { sendJson } from "./routes-vector-cortex-shared.js";
+import { deriveVcStatus } from "./vc-status.js";
 /**
  * Reader-only GET /api/vector-cortex/cache-economics (VC7B).
  *
@@ -54,6 +55,11 @@ export function handleVectorCortexEconomics(req, res, _ctx) {
         lastFailure: null,
         updatedAt: new Date().toISOString(),
         deferredReason: "economics_not_computed_v0_20_23",
+        status: deriveVcStatus({
+            enabled,
+            deferredReason: "economics_not_computed_v0_20_23",
+            hasData: false,
+        }),
     };
     sendJson(res, 200, body);
     return true;

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

@@ -13,6 +13,7 @@ import { VC0A_ENABLED } from "../../src/config.js";
 import { readEvalRows } from "../../src/vector-cortex/eval/persist.js";
 import { summarizeEvalRows } from "../../src/vector-cortex/eval/reader.js";
 import { sendJson } from "./routes-vector-cortex-shared.js";
+import { deriveVcStatus } from "./vc-status.js";
 /** Reader-only aggregate GET /api/vector-cortex/evaluation. */
 export function handleVectorCortexEvaluation(req, res, ctx) {
     const url = req.url ?? "";
@@ -43,6 +44,7 @@ export function handleVectorCortexEvaluation(req, res, ctx) {
         },
         rejects: [], // VC0C wires live breaker/reject telemetry here
         updatedAt: new Date().toISOString(),
+        status: deriveVcStatus({ enabled, hasData: summary.samples > 0 }),
     };
     sendJson(res, 200, body);
     return true;

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

@@ -22,6 +22,7 @@
 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";
+import { deriveVcStatus } from "./vc-status.js";
 // Actual event names emitted by src/vector-cortex/heal/emit.ts + restore-emit.ts.
 const CLOSURE_EVENTS = [
     "vector_cortex_closure_optimized",
@@ -56,6 +57,10 @@ export function handleVectorCortexClosureProof(req, res, ctx) {
         optimizedTraversalTotal: 0,
         lastRejection: null,
         updatedAt: new Date().toISOString(),
+        status: deriveVcStatus({
+            enabled,
+            hasData: vcCount(counts, "vector_cortex_closure_optimized") > 0,
+        }),
     };
     sendJson(res, 200, body);
     return true;
@@ -92,6 +97,10 @@ export function handleVectorCortexRestore(req, res, ctx) {
         digestRejections: vcCount(counts, "vector_cortex_restore_digest_rejected"),
         lastRejection: null,
         updatedAt: new Date().toISOString(),
+        status: deriveVcStatus({
+            enabled,
+            hasData: vcCount(counts, "vector_cortex_source_restored") > 0,
+        }),
     };
     sendJson(res, 200, body);
     return true;

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

@@ -16,6 +16,7 @@ import { VC0C_ENABLED, VC2C_ENABLED } from "../../src/config.js";
 import { createVectorCortexSafety } from "../mega-runtime/vector-cortex-safety.js";
 import { readEncoderManifest, verifyEncoderAsset, detectPlatform } from "../../src/vector-cortex/encoder/asset.js";
 import { sendJson, readJsonBody } from "./routes-vector-cortex-shared.js";
+import { deriveVcStatus } from "./vc-status.js";
 /** Resolve the committed encoder-v1 asset dir by walking up to the repo root. */
 function encoderAssetDir() {
     let dir = dirname(fileURLToPath(import.meta.url));
@@ -137,6 +138,7 @@ export function handleVectorCortexHealth(req, res, ctx) {
         stateSource: "ephemeral",
         encoderAssetDigest: enc.assetDigest,
         encoderMode: enc.mode,
+        status: deriveVcStatus({ enabled: false, hasData: false }),
     };
     if (!card) {
         sendJson(res, 200, fallback);
@@ -174,6 +176,7 @@ export function handleVectorCortexHealth(req, res, ctx) {
         stateSource: card.stateSource,
         encoderAssetDigest: enc.assetDigest,
         encoderMode: enc.mode,
+        status: deriveVcStatus({ enabled, hasData: true, structuralOnly: true }),
     };
     sendJson(res, 200, body);
     return true;
@@ -222,6 +225,7 @@ export function handleVectorCortexBreakersReset(req, res, ctx) {
                 probeCount: rec.probeCount,
                 manualReason: rec.manualReason,
                 updatedAt: rec.updatedAt,
+                status: deriveVcStatus({ enabled: true, hasData: true }),
             };
             sendJson(res, 200, body);
         }

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

@@ -14,6 +14,7 @@
 import { VC1B_ENABLED } from "../../src/config.js";
 import { createLedgerStore } from "../../src/vector-cortex/ledger/store.js";
 import { sendJson } from "./routes-vector-cortex-shared.js";
+import { deriveVcStatus } from "./vc-status.js";
 /**
  * Reader-only GET /api/vector-cortex/ledger (VC1B).
  */
@@ -76,6 +77,7 @@ export function handleVectorCortexLedger(req, res, ctx) {
         count,
         occurrences,
         updatedAt: new Date().toISOString(),
+        status: deriveVcStatus({ enabled: active, hasData: count > 0 }),
     };
     sendJson(res, 200, body);
     return true;

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

@@ -18,11 +18,16 @@
  */
 import { VC8A_ENABLED } from "../../src/config.js";
 import { sendJson, readJsonBody } from "./routes-vector-cortex-shared.js";
+import { countVcEvents, vcCount } from "./vc-event-counts.js";
+import { deriveVcStatus } from "./vc-status.js";
+// Actual events emitted by src/vector-cortex/outcomes/* — the outcome append is
+// the sole aggregate signal (consent grants/revokes are not emitted as events).
+const OUTCOME_EVENTS = ["vector_cortex_outcome_appended"];
 /**
  * GET /api/vector-cortex/outcomes — reader-only outcomes aggregate (VC8A).
  * POST /api/vector-cortex/outcomes/consent — audited consent admin API.
  */
-export function handleVectorCortexOutcomes(req, res, _ctx) {
+export function handleVectorCortexOutcomes(req, res, ctx) {
     const url = req.url ?? "";
     const path = url.split("?")[0] ?? url;
     if (path === "/api/vector-cortex/outcomes/consent") {
@@ -62,17 +67,20 @@ export function handleVectorCortexOutcomes(req, res, _ctx) {
         return true;
     }
     const enabled = VC8A_ENABLED();
+    const counts = countVcEvents(ctx.stateDir, OUTCOME_EVENTS);
+    const outcomeCount = vcCount(counts, "vector_cortex_outcome_appended");
     const mode = enabled ? "A" : "C";
     const body = {
         enabled,
         mode,
-        outcomeCount: 0,
+        outcomeCount,
         consentedSessions: 0,
         revokedSessions: 0,
         manifestCount: 0,
         excludedCount: 0,
         lastFailure: null,
         updatedAt: new Date().toISOString(),
+        status: deriveVcStatus({ enabled, hasData: outcomeCount > 0 }),
     };
     sendJson(res, 200, body);
     return true;

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

@@ -23,6 +23,7 @@ import { VC5A_ENABLED } from "../../src/config.js";
 import { DAG_IDS } from "../../src/vector-cortex/prompt-dag/types.js";
 import { PLN_IDS } from "../../src/vector-cortex/planner/types.js";
 import { sendJson } from "./routes-vector-cortex-shared.js";
+import { deriveVcStatus } from "./vc-status.js";
 /**
  * Reader-only GET /api/vector-cortex/plans (VC5A).
  */
@@ -43,6 +44,7 @@ export function handleVectorCortexPlans(req, res, _ctx) {
         plannerCount: enabled ? PLN_IDS.length : 0,
         plans: [],
         updatedAt: new Date().toISOString(),
+        status: deriveVcStatus({ enabled, hasData: true, structuralOnly: true }),
     };
     sendJson(res, 200, body);
     return true;

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

@@ -15,8 +15,16 @@
  */
 import { VC8C_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";
+// Actual events emitted by src/vector-cortex/platform/* — a parity run checks
+// fixtures and a demotion records an engine-selection downgrade.
+const PLATFORM_EVENTS = [
+    "vector_cortex_engine_parity_checked",
+    "vector_cortex_engine_selection_demoted",
+];
 /** GET /api/vector-cortex/platform — reader-only engine parity/selection aggregate (VC8C). */
-export function handleVectorCortexPlatform(req, res, _ctx) {
+export function handleVectorCortexPlatform(req, res, ctx) {
     const url = req.url ?? "";
     const path = url.split("?")[0] ?? url;
     if (path !== "/api/vector-cortex/platform")
@@ -26,16 +34,19 @@ export function handleVectorCortexPlatform(req, res, _ctx) {
         return true;
     }
     const enabled = VC8C_ENABLED();
+    const counts = countVcEvents(ctx.stateDir, PLATFORM_EVENTS);
     const mode = enabled ? "A" : "C";
+    const fixtureCount = vcCount(counts, "vector_cortex_engine_parity_checked");
     const body = {
         enabled,
         mode,
-        fixtureCount: 0,
+        fixtureCount,
         passed: 0,
         failed: 0,
         externalRunnerConfigured: process.env.MEGACOMPACT_RUST_RUNNER !== undefined,
         lastFailure: null,
         updatedAt: new Date().toISOString(),
+        status: deriveVcStatus({ enabled, hasData: fixtureCount > 0 }),
     };
     sendJson(res, 200, body);
     return true;

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

@@ -17,6 +17,7 @@
  */
 import { VC8B_ENABLED } from "../../src/config.js";
 import { sendJson } from "./routes-vector-cortex-shared.js";
+import { deriveVcStatus } from "./vc-status.js";
 /** GET /api/vector-cortex/policy — reader-only policy + shadow aggregate (VC8B). */
 export function handleVectorCortexPolicy(req, res, _ctx) {
     const url = req.url ?? "";
@@ -40,6 +41,11 @@ export function handleVectorCortexPolicy(req, res, _ctx) {
         lastFailure: null,
         updatedAt: new Date().toISOString(),
         deferredReason: "shadow_controller_not_instantiated_v0_20_23",
+        status: deriveVcStatus({
+            enabled,
+            deferredReason: "shadow_controller_not_instantiated_v0_20_23",
+            hasData: false,
+        }),
     };
     sendJson(res, 200, body);
     return true;

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

@@ -15,6 +15,7 @@
 import { VC3C_ENABLED } from "../../src/config.js";
 import { ROUTER_KEY_VERSION } from "../../src/vector-cortex/topology/query.js";
 import { sendJson } from "./routes-vector-cortex-shared.js";
+import { deriveVcStatus } from "./vc-status.js";
 /**
  * Reader-only GET /api/vector-cortex/query (VC3C query-layer diagnostics).
  */
@@ -40,6 +41,7 @@ export function handleVectorCortexQuery(req, res, _ctx) {
         enabled,
         routerVersion: ROUTER_KEY_VERSION,
         updatedAt: new Date().toISOString(),
+        status: deriveVcStatus({ enabled, hasData: true, structuralOnly: true }),
     };
     sendJson(res, 200, body);
     return true;

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

@@ -9,6 +9,7 @@
 import { VC4C_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";
 // Closure attempt/rejection events emitted by src/vector-cortex/heal/emit.ts.
 const RECONSTRUCT_EVENTS = [
     "vector_cortex_closure_optimized",
@@ -34,6 +35,10 @@ export function handleVectorCortexReconstruct(req, res, ctx) {
         spanTotal: 0,
         byteTotal: 0,
         updatedAt: new Date().toISOString(),
+        status: deriveVcStatus({
+            enabled,
+            hasData: vcCount(counts, "vector_cortex_closure_optimized") > 0,
+        }),
     };
     sendJson(res, 200, body);
     return true;

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

@@ -17,6 +17,7 @@ import { REN_IDS } from "../../src/vector-cortex/render/types.js";
 import { PRO_IDS } from "../../src/vector-cortex/provider/types.js";
 import { KNOWN_PROVIDER_KEYS } from "../../src/vector-cortex/provider/registry.js";
 import { sendJson } from "./routes-vector-cortex-shared.js";
+import { deriveVcStatus } from "./vc-status.js";
 /** Reader-only GET /api/vector-cortex/render (VC5B). */
 export function handleVectorCortexRender(req, res, _ctx) {
     const url = req.url ?? "";
@@ -34,6 +35,7 @@ export function handleVectorCortexRender(req, res, _ctx) {
         providerCount: enabled ? PRO_IDS.length : 0,
         knownProfiles: enabled ? KNOWN_PROVIDER_KEYS : [],
         updatedAt: new Date().toISOString(),
+        status: deriveVcStatus({ enabled, hasData: true, structuralOnly: true }),
     };
     sendJson(res, 200, body);
     return true;

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

@@ -23,6 +23,7 @@
 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";
 // Actual event names emitted by src/vector-cortex/heal/repair-emit.ts.
 const REPAIR_EVENTS = [
     "vector_cortex_repair_planned",
@@ -65,6 +66,10 @@ export function handleVectorCortexRepair(req, res, ctx) {
         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/dist/extensions/dashboard-server/routes-vector-cortex-residual.js

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

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

@@ -11,11 +11,22 @@
  * Guardrails: PREVENT-PI-004 (local in-process state only), PREVENT-011 (no
  * `any`), reader-only aggregate (counts + gate state only).
  */
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
 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";
+// 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",
+];
 /** Reader-only GET /api/vector-cortex/rollout (VC5C). */
-export function handleVectorCortexRollout(req, res, _ctx) {
+export function handleVectorCortexRollout(req, res, ctx) {
     const url = req.url ?? "";
     const path = url.split("?")[0] ?? url;
     if (path !== "/api/vector-cortex/rollout")
@@ -25,6 +36,11 @@ export function handleVectorCortexRollout(req, res, _ctx) {
         return true;
     }
     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 = {
@@ -33,11 +49,48 @@ export function handleVectorCortexRollout(req, res, _ctx) {
         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) {
+    const seen = new Set();
+    let raw;
+    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];
+        if (line.length === 0)
+            continue;
+        let ev = null;
+        try {
+            ev = JSON.parse(line);
+        }
+        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/dist/extensions/dashboard-server/routes-vector-cortex-shards.js

@@ -20,6 +20,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 { 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
 // shard-write signal — so semanticCount is wired to it and exactCount stays 0
@@ -50,6 +51,10 @@ export function handleVectorCortexShards(req, res, ctx) {
         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/dist/extensions/dashboard-server/routes-vector-cortex-topology.js

@@ -26,6 +26,7 @@ import { Logger } from "../../src/log.js";
 import { createCortexStore } from "../../src/vector-cortex/cortex/store.js";
 import { buildTopologyGraph } from "../../src/vector-cortex/topology/index.js";
 import { sendJson } from "./routes-vector-cortex-shared.js";
+import { deriveVcStatus } from "./vc-status.js";
 /** Well-known cortex record kind that carries a canonical candidate payload. */
 const TOPOLOGY_RECORD_KIND = "topology";
 /**
@@ -88,6 +89,7 @@ export function handleVectorCortexTopology(req, res, ctx) {
             ? { nodes, edges, generationDigest }
             : {}),
         updatedAt: new Date().toISOString(),
+        status: deriveVcStatus({ enabled: active, hasData: summary.recordCount > 0 }),
     };
     sendJson(res, 200, body);
     return true;

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

@@ -254,9 +254,11 @@ export async function launchDashboardServer(stateDir) {
                     }));
                     v6.listen(port, "::1", () => log("ipv6 loopback bound", { port })); // guardrails-allow PREVENT-PI-004: IPv6 loopback (::1) mirror of the dashboard server
                 }
-                // Write port.pid
+                // Write port.pid (VC0F B2: stamp `version` so the launcher can detect
+                // a stale runner by comparing the marker against its own version
+                // without an HTTP probe — closes the orphan case for pre-B2 servers).
                 try {
-                    writeFileSync(portFile, JSON.stringify({ port, pid: process.pid }));
+                    writeFileSync(portFile, JSON.stringify({ port, pid: process.pid, version: SERVER_VERSION }));
                 }
                 catch (e) {
                     log("could not write port.pid", { error: String(e) });

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

@@ -0,0 +1,17 @@
+/**
+ * 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 function deriveVcStatus(opts) {
+    if (!opts.enabled)
+        return "off";
+    if (opts.deferredReason)
+        return "deferred";
+    if (opts.structuralOnly)
+        return "structural";
+    return opts.hasData ? "live" : "awaiting_data";
+}

package/dist/extensions/mega-dashboard-bounce.js

@@ -0,0 +1,79 @@
+/**
+ * mega-dashboard-bounce.ts — VC0F stale-runner detection + bounce.
+ *
+ * Delegate of `mega-dashboard-cmds.ts` (kept under the extensions/ soft limit):
+ * owns the once-per-process staleness gate and the pure
+ * `bounceStaleRunnerIfAny` decision, which is the durable restart-on-upgrade
+ * seam — after `pi update --extensions` replaces the on-disk package, the next
+ * `session_start` probes the running dashboard, sees the version mismatch, and
+ * kills + respawns the stale runner so it serves the current code.
+ *
+ * The function is dependency-injected so unit tests (VC0F C1–C3) can stub every
+ * primitive; the production wiring (live discovery / version / kill) lives in
+ * `mega-dashboard-cmds.ts` and is passed in. No network here — the localhost
+ * HTTP probes live behind the injected `isServerRunning`/`serverVersion` deps
+ * (already audited PREVENT-PI-004 in the parent file).
+ */
+/**
+ * Once-per-process staleness gate (VC0F A2). After the FIRST successful probe
+ * we skip re-probing on later /mega-dashboard invocations or session-start
+ * events within the same extension process — the probe is cheap but the
+ * kill+respawn it triggers is disruptive. Set regardless of outcome.
+ */
+let stalenessCheckedThisProcess = false;
+/** Test-only seam: clear the once-per-process gate between unit tests. */
+export function resetStalenessGateForTests() {
+    stalenessCheckedThisProcess = false;
+}
+/**
+ * Detect + replace a STALE dashboard runner for the current repo (VC0F A1).
+ *
+ * A runner is stale when it is an orphan (live but missing its port.pid
+ * marker), when its marker's stamped `version` differs from this extension's
+ * own version (VC0F B2 — avoids the HTTP probe), or when the version it
+ * reports over HTTP differs from our own (fallback for pre-B2 servers whose
+ * marker has no `version` field). A stale runner is killed so the next launch
+ * serves the current on-disk code.
+ *
+ * Best-effort and non-fatal (Goal 4): any failure returns `{bounced:false}`
+ * and never throws. Runs at most once per extension process (A2).
+ */
+export async function bounceStaleRunnerIfAny(deps) {
+    if (stalenessCheckedThisProcess)
+        return { bounced: false };
+    try {
+        stalenessCheckedThisProcess = true; // once per process, regardless of outcome
+        const info = await deps.isServerRunning();
+        if (!info)
+            return { bounced: false };
+        const orphan = !info.hasPidFile;
+        const want = deps.ownVersion();
+        const marker = deps.markerVersion();
+        let stale;
+        let from = null;
+        if (orphan) {
+            stale = true; // live server with no marker → orphan by definition
+        }
+        else if (want != null && marker != null) {
+            stale = marker !== want; // B2: compare the stamped marker, skip the HTTP probe
+            from = marker;
+        }
+        else {
+            const running = await deps.serverVersion(info.port);
+            from = running;
+            stale = want != null && running != null && running !== want;
+        }
+        if (stale) {
+            deps.notify(orphan
+                ? "[mega-compact] replacing orphaned dashboard server…"
+                : `[mega-compact] replacing stale dashboard (${from ?? "?"} → ${want ?? "?"})…`);
+            deps.killServerOnPort(info.port);
+            return { bounced: true };
+        }
+        return { bounced: false };
+    }
+    catch {
+        // Best-effort, non-fatal — a failed probe/kill never breaks the caller.
+        return { bounced: false };
+    }
+}