pi-mega-compact 0.19.0 → 0.19.1

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

@@ -0,0 +1,83 @@
+/**
+ * dashboard-server/routes-vector-cortex-topology.ts — VC3A vector-cortex topology
+ * dashboard route.
+ *
+ * Reader-only GET /api/vector-cortex/topology built ENTIRELY on the CortexReader
+ * capability: opens the isolated cortex DB for this repo's state dir and returns
+ * the topology summary (enabled, active generation identity, one root digest,
+ * derived frontier, record count, ordinal). It is query-only — never
+ * append/rebuild/switch. No writer or admin capability is reachable on this path
+ * (no writer/admin leakage). Non-fatal: a missing or corrupt cortex DB degrades
+ * to `enabled:false`.
+ *
+ * Guardrails: PREVENT-PI-004 (local filesystem read only), PREVENT-011 (no
+ * `any`), reader-only aggregate.
+ */
+
+import type { IncomingMessage, ServerResponse } from "node:http";
+import type { RouteContext } from "./routes-core.js";
+import { VC3A_ENABLED } from "../../src/config.js";
+import { createCortexStore } from "../../src/vector-cortex/cortex/store.js";
+import { sendJson } from "./routes-vector-cortex-shared.js";
+import type { VectorCortexTopologyView } from "./api-contracts/vector-cortex.js";
+
+/**
+ * Reader-only GET /api/vector-cortex/topology (VC3A).
+ */
+export function handleVectorCortexTopology(
+  req: IncomingMessage,
+  res: ServerResponse,
+  ctx: RouteContext,
+): boolean {
+  const url = req.url ?? "";
+  const path = url.split("?")[0] ?? url;
+  if (path !== "/api/vector-cortex/topology") return false;
+  if (req.method !== "GET") {
+    // Reader-only path: no mutation endpoint lives at /topology.
+    sendJson(res, 405, { error: "method_not_allowed" });
+    return true;
+  }
+
+  const enabled = VC3A_ENABLED();
+  let active = enabled;
+  let summary: {
+    generationId: string | null;
+    rootDigest: string | null;
+    sourceHighWater: string;
+    recordCount: number;
+    ordinal: string | null;
+  } = { generationId: null, rootDigest: null, sourceHighWater: "0", recordCount: 0, ordinal: null };
+
+  if (enabled) {
+    try {
+      const store = createCortexStore({ stateDir: ctx.stateDir });
+      try {
+        const s = store.reader().topologySummary();
+        summary = {
+          generationId: s.generationId,
+          rootDigest: s.rootDigest,
+          sourceHighWater: s.sourceHighWater,
+          recordCount: s.recordCount,
+          ordinal: s.ordinal,
+        };
+      } finally {
+        store.close();
+      }
+    } catch {
+      // Non-fatal: a missing/corrupt cortex DB degrades to `enabled:false`.
+      active = false;
+    }
+  }
+
+  const body: VectorCortexTopologyView = {
+    enabled: active,
+    generationId: summary.generationId,
+    rootDigest: summary.rootDigest,
+    sourceHighWater: summary.sourceHighWater,
+    recordCount: summary.recordCount,
+    ordinal: summary.ordinal,
+    updatedAt: new Date().toISOString(),
+  };
+  sendJson(res, 200, body);
+  return true;
+}

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

@@ -1,439 +1,20 @@
 /**
  * dashboard-server/routes-vector-cortex.ts — vector-cortex dashboard routes.
  *
- * VC0A ships a single reader-only GET /api/vector-cortex/evaluation that
- * aggregates redacted evaluation rows (persisted JSONL under the state dir)
- * via the reader. No writable capability — no reset/mutation here; VC0C adds
- * breaker health + reset endpoints into this same file, keeping it additive
- * and within extension limits.
+ * Delegate shell: each VC feature owns a focused handler module below the
+ * extension line limit, and this file re-exports them unchanged so the existing
+ * registration (`routes.ts`, `server.ts`) keeps working without modification.
  *
- * VC0C (task 5) adds:
- *   GET  /api/vector-cortex/health          — reader-only aggregate health card
- *   POST /api/vector-cortex/breakers/reset  — explicit admin capability
+ *   VC0A evaluation  -> routes-vector-cortex-eval.ts  (GET  /evaluation)
+ *   VC0C health/reset-> routes-vector-cortex-health.ts(GET  /health, POST /breakers/reset)
+ *   VC1B ledger      -> routes-vector-cortex-ledger.ts (GET  /ledger)
+ *   VC3A topology    -> routes-vector-cortex-topology.ts(GET /topology)
  *
  * Guardrails: PREVENT-PI-004 (local filesystem read only), PREVENT-011 (no
- * `any`), reader-only aggregate (never payloads/prompts/ledger — EVAL-REDACT-002).
+ * `any`), reader-only aggregates (never payloads/prompts/ledger text).
  */
 
-import type { IncomingMessage, ServerResponse } from "node:http";
-import type { RouteContext } from "./routes-core.js";
-import { createHash } from "node:crypto";
-import { readFileSync, statSync } from "node:fs";
-import { join, dirname } from "node:path";
-import { fileURLToPath } from "node:url";
-import { VC0A_ENABLED, VC0C_ENABLED, VC1B_ENABLED, VC2C_ENABLED } from "../../src/config.js";
-import { readEvalRows } from "../../src/vector-cortex/eval/persist.js";
-import { summarizeEvalRows } from "../../src/vector-cortex/eval/reader.js";
-import { createVectorCortexSafety } from "../mega-runtime/vector-cortex-safety.js";
-import { createLedgerStore } from "../../src/vector-cortex/ledger/store.js";
-import { readEncoderManifest, verifyEncoderAsset, detectPlatform } from "../../src/vector-cortex/encoder/asset.js";
-import type {
-  VectorCortexEvaluationSummary,
-  VectorCortexHealthCard,
-  VectorCortexLedgerView,
-  VectorCortexResetResult,
-} from "./api-contracts/vector-cortex.js";
-
-/** Admin capability: an actor-supplied subsystem selector for breaker reset. */
-function readJsonBody(
-  req: IncomingMessage,
-  cb: (
-    result: { ok: true; value: Record<string, unknown> } | { ok: false; error: string },
-  ) => void,
-): void {
-  let body = "";
-  let tooBig = false;
-  req.on("data", (chunk: Buffer) => {
-    if (body.length > 65536) {
-      tooBig = true;
-      return;
-    }
-    body += chunk.toString();
-  });
-  req.on("end", () => {
-    if (tooBig) return cb({ ok: false, error: "body_too_large" });
-    try {
-      const v = body ? JSON.parse(body) : {};
-      if (typeof v !== "object" || v === null || Array.isArray(v)) {
-        return cb({ ok: false, error: "invalid_object" });
-      }
-      cb({ ok: true, value: v as Record<string, unknown> });
-    } catch {
-      cb({ ok: false, error: "invalid_json" });
-    }
-  });
-}
-
-function sendJson(res: ServerResponse, status: number, body: unknown): void {
-  // guardrails-allow PREVENT-PI-004: loopback dashboard response (local)
-  res.writeHead(status, { "Content-Type": "application/json" });
-  res.end(JSON.stringify(body));
-}
-
-/** Resolve the committed encoder-v1 asset dir by walking up to the repo root. */
-function encoderAssetDir(): string | null {
-  let dir = dirname(fileURLToPath(import.meta.url));
-  const rel = join("assets", "vector-cortex", "encoder-v1");
-  for (let i = 0; i < 8; i++) {
-    const candidate = join(dir, rel);
-    try {
-      // guardrails-allow PREVENT-PI-004: local asset filesystem read (loopback)
-      readFileSync(join(candidate, "manifest.json"));
-      return candidate;
-    } catch {
-      /* keep walking */
-    }
-    const next = dirname(dir);
-    if (next === dir) break;
-    dir = next;
-  }
-  return null;
-}
-
-/**
- * VC2C encoder health facts (task 5): the SHA-256 of the committed qualified
- * manifest (asset digest) and the encoder triad mode. Reader-only aggregate
- * (digest prefix, no bytes). Gated on MEGACOMPACT_VC2C: when the flag is OFF
- * (rollback), the card reports mode C with an absent digest — consistent with
- * the rest of the card, whose enabled/mode fields reflect active (flag-gated)
- * state. When ON: "A" when the committed asset verifies on this host, "B" when
- * present but not verified (demotion), "C" when absent.
- *
- * The verification hashes the full ONNX + tokenizer bytes, which is expensive
- * on a periodically-polled endpoint as the shipped asset grows. The result is
- * memoized against a cheap key (manifest bytes + file sizes/mtimes + platform);
- * any on-disk mutation invalidates the key, so the cache never goes stale while
- * avoiding the repeated large-file hashing. A failed digest read returns null
- * (an absent digest), never a misleading zero-sentinel.
- */
-type EncoderHealthFacts = { assetDigest: string | null; mode: "A" | "B" | "C" };
-
-interface HealthFactCache {
-  key: string;
-  facts: EncoderHealthFacts;
-}
-
-let healthCache: HealthFactCache | null = null;
-
-/** Stable cache key: manifest bytes + (size,mtime) of the asset files + platform. */
-function healthFactCacheKey(dir: string, manifestPath: string): string | null {
-  const platform = detectPlatform();
-  if (!platform) return null;
-  const parts: string[] = [platform];
-  try {
-    for (const p of [manifestPath, join(dir, "model.onnx"), join(dir, "tokenizer.json")]) {
-      const s = statSync(p);
-      parts.push(`${s.size}:${s.mtimeMs}`);
-    }
-    // guardrails-allow PREVENT-PI-004: local manifest filesystem read (loopback)
-    parts.push(createHash("sha256").update(readFileSync(manifestPath)).digest("hex"));
-  } catch {
-    return null;
-  }
-  return parts.join("|");
-}
-
-function computeEncoderHealthFacts(dir: string): EncoderHealthFacts | null {
-  const manifest = readEncoderManifest(dir);
-  if (manifest === null) return { assetDigest: null, mode: "C" };
-  const manifestPath = join(dir, "manifest.json");
-  const key = healthFactCacheKey(dir, manifestPath);
-  if (key === null) return null;
-  if (healthCache !== null && healthCache.key === key) return healthCache.facts;
-  let digest: string;
-  try {
-    // guardrails-allow PREVENT-PI-004: local manifest filesystem read (loopback)
-    digest = createHash("sha256").update(readFileSync(manifestPath)).digest("hex");
-  } catch {
-    return { assetDigest: null, mode: "B" };
-  }
-  const verify = verifyEncoderAsset(dir, manifest, detectPlatform());
-  const facts: EncoderHealthFacts = { assetDigest: digest, mode: verify.ok ? "A" : "B" };
-  healthCache = { key, facts };
-  return facts;
-}
-
-function encoderHealthFacts(): EncoderHealthFacts {
-  if (!VC2C_ENABLED()) {
-    // Rollback: MEGACOMPACT_VC2C=0 selects C — report the inactive (flag-gated)
-    // mode with no asset digest rather than an on-disk-computed A/B.
-    return { assetDigest: null, mode: "C" };
-  }
-  const dir = encoderAssetDir();
-  if (dir === null) return { assetDigest: null, mode: "C" };
-  const facts = computeEncoderHealthFacts(dir);
-  if (facts === null) return { assetDigest: null, mode: "C" };
-  return facts;
-}
-
-/** Reader-only aggregate GET /api/vector-cortex/evaluation. */
-export function handleVectorCortexEvaluation(
-  req: IncomingMessage,
-  res: ServerResponse,
-  ctx: RouteContext,
-): boolean {
-  const url = req.url ?? "";
-  if (url !== "/api/vector-cortex/evaluation") return false;
-  if (req.method !== "GET") {
-    // Reader-only: no mutation endpoints exist on this path.
-    // guardrails-allow PREVENT-PI-004: loopback dashboard response (local)
-    res.writeHead(405, { "Content-Type": "application/json" });
-    res.end(JSON.stringify({ error: "method_not_allowed" }));
-    return true;
-  }
-
-  const enabled = VC0A_ENABLED();
-  const rows = enabled ? readEvalRows(ctx.stateDir) : [];
-  const summary = summarizeEvalRows(rows);
-
-  const body: VectorCortexEvaluationSummary = {
-    enabled,
-    mode: enabled ? "A" : "C",
-    samples: summary.samples,
-    byMode: {
-      A: summary.byMode.A,
-      B: summary.byMode.B,
-      C: summary.byMode.C,
-    },
-    histogram: {
-      edges: [...summary.histogram.edges],
-      cells: [...summary.histogram.cells],
-      overflow: summary.histogram.overflow,
-      total: summary.histogram.total,
-    },
-    rejects: [], // VC0C wires live breaker/reject telemetry here
-    updatedAt: new Date().toISOString(),
-  };
-  sendJson(res, 200, body);
-  return true;
-}
-
-/**
- * Reader-only GET /api/vector-cortex/health (VC0C).
- *
- * Aggregate health card: breaker state (window/probe/backoff), durable spool
- * frontier/authority/lag, and a worst-state aggregate. Constructs the safety
- * adapter over the state dir — durable spool state (frontier-frozen, lag) is
- * read from disk, so it reflects restart. Purely read: no mutation, never
- * payloads/prompts/ledger.
- */
-export function handleVectorCortexHealth(
-  req: IncomingMessage,
-  res: ServerResponse,
-  ctx: RouteContext,
-): boolean {
-  const url = req.url ?? "";
-  if (url !== "/api/vector-cortex/health") return false;
-  if (req.method !== "GET") {
-    // Reader-only path: no mutation endpoint lives at /health.
-    sendJson(res, 405, { error: "method_not_allowed" });
-    return true;
-  }
-
-  const enabled = VC0C_ENABLED();
-  const safety = enabled ? createVectorCortexSafety({ stateDir: ctx.stateDir }) : null;
-  const card = safety ? safety.health() : null;
-
-  const enc = encoderHealthFacts();
-
-  const fallback: VectorCortexHealthCard = {
-    enabled: false,
-    mode: "C",
-    state: "CLOSED_A",
-    subsystem: "provider",
-    sinceMs: 0,
-    windowMs: 0,
-    probeCount: 0,
-    backoffDelayMs: 0,
-    frontierFrozen: false,
-    authorityOutage: false,
-    spoolLag: 0,
-    attempts: 0,
-    failures: 0,
-    p95Ms: 0,
-    failureRate: 0,
-    updatedAt: new Date().toISOString(),
-    aggregate: "CLOSED_A",
-    stateSource: "ephemeral",
-    encoderAssetDigest: enc.assetDigest,
-    encoderMode: enc.mode,
-  };
-  if (!card) {
-    sendJson(res, 200, fallback);
-    return true;
-  }
-
-  const mode: "A" | "B" | "C" =
-    card.state === "CLOSED_A" ? "A" : card.state === "MANUAL_HALT" ? "C" : "B";
-  const aggregate =
-    card.state === "MANUAL_HALT"
-      ? "MANUAL_HALT"
-      : card.state === "OPEN_C"
-        ? "OPEN_C"
-        : card.state === "OPEN_B"
-          ? "OPEN_B"
-          : card.state === "PROBE_B" || card.state === "PROBE_A"
-            ? "PROBE"
-            : "CLOSED_A";
-
-  const body: VectorCortexHealthCard = {
-    enabled,
-    mode,
-    state: card.state,
-    subsystem: card.subsystem,
-    sinceMs: card.sinceMs,
-    reason: card.reason,
-    windowMs: card.windowMs,
-    probeCount: card.probeCount,
-    backoffDelayMs: card.backoffDelayMs,
-    frontierFrozen: card.frontierFrozen,
-    authorityOutage: card.authorityOutage,
-    spoolLag: card.spoolLag,
-    attempts: card.attempts,
-    failures: card.failures,
-    p95Ms: card.p95Ms,
-    failureRate: card.failureRate,
-    updatedAt: new Date().toISOString(),
-    aggregate,
-    stateSource: card.stateSource,
-    encoderAssetDigest: enc.assetDigest,
-    encoderMode: enc.mode,
-  };
-  sendJson(res, 200, body);
-  return true;
-}
-
-/**
- * Admin POST /api/vector-cortex/breakers/reset (VC0C).
- *
- * Explicit admin capability (separate from the reader GET). Clears a breaker's
- * cooldown — or unwires a MANUAL_HALT — but NEVER evidence (attempts/failures
- * are retained, per TRIAD_RESILIENCE). The subsystem is actor-supplied via the
- * JSON body `{ subsystem }`. Every reset is documented in the returned record
- * (state, retained evidence, updatedAt) — an auditable mutation surface; the
- * GET path can never mutate.
- */
-export function handleVectorCortexBreakersReset(
-  req: IncomingMessage,
-  res: ServerResponse,
-  ctx: RouteContext,
-): boolean {
-  const url = req.url ?? "";
-  if (url !== "/api/vector-cortex/breakers/reset") return false;
-  if (req.method !== "POST") {
-    sendJson(res, 405, { error: "method_not_allowed" });
-    return true;
-  }
-  if (!VC0C_ENABLED()) {
-    sendJson(res, 409, { error: "vco_c_disabled" });
-    return true;
-  }
-
-  readJsonBody(req, (parsed) => {
-    if (!parsed.ok) {
-      sendJson(res, 400, { error: parsed.error });
-      return;
-    }
-    const subsystem = parsed.value.subsystem;
-    if (typeof subsystem !== "string" || subsystem.length === 0) {
-      sendJson(res, 400, { error: "subsystem_required" });
-      return;
-    }
-    try {
-      const safety = createVectorCortexSafety({ stateDir: ctx.stateDir });
-      const rec = safety.reset(subsystem);
-      const body: VectorCortexResetResult = {
-        subsystem: rec.subsystem,
-        state: rec.state,
-        cooldownCleared: true,
-        attempts: rec.attempts,
-        failures: rec.failures,
-        probeCount: rec.probeCount,
-        manualReason: rec.manualReason,
-        updatedAt: rec.updatedAt,
-      };
-      sendJson(res, 200, body);
-    } catch {
-      sendJson(res, 500, { error: "reset_failed" });
-    }
-  });
-  return true;
-}
-
-/**
- * Reader-only GET /api/vector-cortex/ledger (VC1B).
- *
- * Built on the LedgerReader capability: opens the occurrence-v2 ledger for this
- * repo's state dir and returns the session's occurrence IDENTITY rows
- * (seq/eventId/kind/digest/toolCallId) plus high-water/count. NEVER ships
- * sourceBytes or prompt text (reader-only no-ledger-text rule). Optional
- * `?session=<id>` query selects the session (default "default").
- */
-export function handleVectorCortexLedger(
-  req: IncomingMessage,
-  res: ServerResponse,
-  ctx: RouteContext,
-): boolean {
-  const url = req.url ?? "";
-  const path = url.split("?")[0] ?? url;
-  if (path !== "/api/vector-cortex/ledger") return false;
-  if (req.method !== "GET") {
-    // Reader-only path: no mutation endpoint lives at /ledger.
-    sendJson(res, 405, { error: "method_not_allowed" });
-    return true;
-  }
-
-  // Parse the optional session query parameter.
-  let session = "default";
-  const qs = url.split("?")[1];
-  if (qs !== undefined) {
-    for (const pair of qs.split("&")) {
-      const [k, v] = pair.split("=");
-      if (k === "session" && v !== undefined && v.length > 0) {
-        session = decodeURIComponent(v);
-      }
-    }
-  }
-
-  const enabled = VC1B_ENABLED();
-  let active = enabled;
-  let highWater = "0";
-  let count = 0;
-  let occurrences: VectorCortexLedgerView["occurrences"] = [];
-
-  if (enabled) {
-    try {
-      const store = createLedgerStore({ stateDir: ctx.stateDir });
-      try {
-        const reader = store.reader();
-        highWater = reader.highWater(session).toString();
-        const rows = reader.readSession(session);
-        count = rows.length;
-        // Identity only: never sourceBytes or prompt text (reader-only rule).
-        occurrences = rows.slice(-500).map((occ) => ({
-          seq: occ.seq.toString(),
-          eventId: occ.eventId,
-          kind: occ.kind,
-          digest: occ.digest,
-          ...(occ.toolCallId !== undefined ? { toolCallId: occ.toolCallId } : {}),
-        }));
-      } finally {
-        store.close();
-      }
-    } catch {
-      // Non-fatal: a missing/corrupt ledger DB degrades to `enabled:false`.
-      active = false;
-    }
-  }
-
-  const body: VectorCortexLedgerView = {
-    enabled: active,
-    session,
-    highWater,
-    count,
-    occurrences,
-    updatedAt: new Date().toISOString(),
-  };
-  sendJson(res, 200, body);
-  return true;
-}
+export { handleVectorCortexEvaluation } from "./routes-vector-cortex-eval.js";
+export { handleVectorCortexHealth, handleVectorCortexBreakersReset } from "./routes-vector-cortex-health.js";
+export { handleVectorCortexLedger } from "./routes-vector-cortex-ledger.js";
+export { handleVectorCortexTopology } from "./routes-vector-cortex-topology.js";

package/extensions/dashboard-server/routes.ts

@@ -45,4 +45,5 @@ export {
 	handleVectorCortexHealth,
 	handleVectorCortexBreakersReset,
 	handleVectorCortexLedger,
+	handleVectorCortexTopology,
 } from "./routes-vector-cortex.js";

package/extensions/dashboard-server/server.ts

@@ -60,6 +60,7 @@ import {
 	handleVectorCortexHealth,
 	handleVectorCortexBreakersReset,
 	handleVectorCortexLedger,
+	handleVectorCortexTopology,
 	handleStatic,
 } from "./routes.js";
 
@@ -283,6 +284,7 @@ export async function launchDashboardServer(
 		if (handleVectorCortexHealth(req, res, ctx)) return;
 		if (handleVectorCortexBreakersReset(req, res, ctx)) return;
 		if (handleVectorCortexLedger(req, res, ctx)) return;
+		if (handleVectorCortexTopology(req, res, ctx)) return;
 		handleStatic(req, res, ctx);
 	});
 

package/package.json

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

package/src/config/vector-cortex.ts

@@ -100,6 +100,17 @@ export const VC2B_ENABLED = (): boolean => sprintFlag("MEGACOMPACT_VC2B");
  */
 export const VC2C_ENABLED = (): boolean => sprintFlag("MEGACOMPACT_VC2C");
 
+/**
+ * VC3A — capability-gated cortex store (CortexReader/Writer/Admin, CortexRecordV1).
+ * Default ON. `MEGACOMPACT_VC3A=0` disables and is byte-identical to the
+ * predecessor (mode C: the derived cortex store is absent, mode B in-memory is
+ * not consulted, zero `vector_cortex_record_append_failed` /
+ * `vector_cortex_generation_rebuilt` emissions; the predecessor derived pointer
+ * and goldens are unchanged). The real consumers are the cortex append seam, the
+ * cortex rebuild/admin seam and the reader-only topology summary seam.
+ */
+export const VC3A_ENABLED = (): boolean => sprintFlag("MEGACOMPACT_VC3A");
+
 // ---------------------------------------------------------------------------
 // Breaker state machine constants (TRIAD_RESILIENCE.md §breaker).
 // Rolled numbers for one 60s window; VC0C consumes these at its breaker seam.

package/src/config.ts

@@ -160,6 +160,7 @@ export {
   VC2A_ENABLED,
   VC2B_ENABLED,
   VC2C_ENABLED,
+  VC3A_ENABLED,
   BREAKER_WINDOW_MS,
   BREAKER_MIN_ATTEMPTS,
   BREAKER_PERF_FAILURES,