pi-mega-compact 0.19.0 → 0.19.2

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

@@ -0,0 +1,244 @@
+/**
+ * dashboard-server/routes-vector-cortex-topology.ts — VC3A/VC3B 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`.
+ *
+ * VC3B adds the deterministic node/edge shapes (TopologyV1) when both VC3A and
+ * VC3B are enabled: the accepted derived records of kind "topology" that carry a
+ * canonical TopologyCandidate JSON payload are fed through the deterministic
+ * build (buildTopologyGraph), whose stable generation digest + sorted node/edge
+ * arrays are returned. Bad/unparseable records are skipped (PREVENT-001), and
+ * with VC3B off the node/edge fields are omitted entirely — byte-identical to
+ * the VC3A predecessor view.
+ *
+ * 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, VC3B_ENABLED } from "../../src/config.js";
+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 type { TopologyCandidate, TopologyEmit } from "../../src/vector-cortex/topology/index.js";
+import type { CortexRecordV1 } from "../../src/vector-cortex/cortex/types.js";
+import { sendJson } from "./routes-vector-cortex-shared.js";
+import type { VectorCortexTopologyView } from "./api-contracts/vector-cortex.js";
+
+/** Well-known cortex record kind that carries a canonical candidate payload. */
+const TOPOLOGY_RECORD_KIND = "topology";
+
+/**
+ * Reader-only GET /api/vector-cortex/topology (VC3A + VC3B node/edge shapes).
+ */
+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();
+  const topologyEnabled = VC3B_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 };
+  let nodes: { id: string; kind: string }[] | undefined;
+  let edges: {
+    source: string;
+    target: string;
+    head: string;
+    score: number;
+    direction: string;
+  }[] | undefined;
+  let generationDigest: string | null | undefined;
+
+  if (enabled) {
+    try {
+      const store = createCortexStore({ stateDir: ctx.stateDir });
+      try {
+        const reader = store.reader();
+        const s = reader.topologySummary();
+        summary = {
+          generationId: s.generationId,
+          rootDigest: s.rootDigest,
+          sourceHighWater: s.sourceHighWater,
+          recordCount: s.recordCount,
+          ordinal: s.ordinal,
+        };
+        if (topologyEnabled) {
+          const built = buildFromRecords(reader.readRecords());
+          nodes = built.nodes;
+          edges = built.edges;
+          generationDigest = built.generationDigest;
+        }
+      } 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,
+    ...(topologyEnabled
+      ? { nodes, edges, generationDigest }
+      : {}),
+    updatedAt: new Date().toISOString(),
+  };
+  sendJson(res, 200, body);
+  return true;
+}
+
+/**
+ * Reconstruct the deterministic topology graph from the accepted derived records
+ * (reader-only, best-effort). Only records of kind "topology" whose payload is a
+ * canonical TopologyCandidate JSON are consumed; everything else is ignored.
+ * Returns empty arrays + null digest when no valid candidates are stored.
+ *
+ * The build seam is invoked with a logger-derived emit so the VC3B observability
+ * events (`vector_cortex_topology_built` / `vector_cortex_topology_edge_rejected`)
+ * fire on this production path — not just under unit tests. Best-effort and
+ * non-fatal: a failing emitter never breaks the agent loop.
+ *
+ * Q04 — DIVERGENCE RISK (documented, currently latent): the build is invoked
+ * with a hardcoded `threshold: 0` (plus `sessionId: "dashboard"` and
+ * `sourceHighWater: 0n`). This reflects the VC3B state where no production
+ * writer emits calibrated-threshold candidates yet, so retaining ALL stored
+ * "topology" records is correct for now. Once a real calibrated-threshold
+ * producer lands (VC3C), this dashboard digest will NOT derive from the
+ * authoritative threshold and can diverge from the canonical build for the same
+ * stored candidate set. The calibrated threshold must then be threaded through
+ * (e.g. sourced from the authority/config, not zero) before this route is treated
+ * as authoritative. Until then the route is explicitly best-effort display only.
+ */
+function buildFromRecords(records: readonly CortexRecordV1[]): {
+  nodes: { id: string; kind: string }[];
+  edges: { source: string; target: string; head: string; score: number; direction: string }[];
+  generationDigest: string | null;
+} {
+  const candidates: TopologyCandidate[] = [];
+  for (const r of records) {
+    if (r.kind !== TOPOLOGY_RECORD_KIND) continue;
+    const parsed = parseCandidatePayload(r);
+    if (parsed) candidates.push(parsed);
+  }
+  const result = buildTopologyGraph(
+    { sessionId: "dashboard", sourceHighWater: 0n, threshold: 0, candidates },
+    topologyEmit,
+  );
+  if (!result.ok) return { nodes: [], edges: [], generationDigest: null };
+  return {
+    nodes: result.topology.nodes.map((n) => ({ id: n.id, kind: n.kind })),
+    edges: result.topology.edges.map((e) => ({
+      source: e.source,
+      target: e.target,
+      head: e.head,
+      score: e.score,
+      direction: e.direction,
+    })),
+    generationDigest: result.topology.generationDigest,
+  };
+}
+
+/**
+ * Logger-derived default emitter for the VC3B topology events. Mirrors the
+ * cortex store's `defaultEmitFor()` convention: a REAL structured-log producer so
+ * a caller that invokes the build seam without injecting an emitter still yields
+ * telemetry (best-effort, non-fatal). This is the production invoke point that
+ * makes the task-5 emission capable live (not dead under unit tests only).
+ */
+const topologyEmit: TopologyEmit = (event, fields) => {
+  new Logger().info(event, fields);
+};
+
+/**
+ * PREVENT-001: parse + shape-check a candidate payload before use. Returns
+ * undefined on any malformed/non-object input (best-effort, non-fatal).
+ *
+ * Q04 — FRAMING HARDENING: the canonical digest serialization in index.ts uses
+ * `|` (FIELD_SEP) and `~` (RECORD_SEP) as unambiguous delimiters between node
+ * ids/kinds and edge fields. That framing is collision-free only while id values
+ * (source/target/head) contain neither byte. Today ids are project-controlled, so
+ * this is latent, but a stored topology record could in principle carry a
+ * content-derived id containing those bytes, making the digest ambiguous
+ * (distinct graphs could collide) or the serialization injection-prone. To keep
+ * the digest well-defined for ANY input, reject candidates whose source/target/
+ * head contain the field/record separators; such a record is skipped (non-fatal)
+ * rather than fed into the digest.
+ */
+function parseCandidatePayload(r: CortexRecordV1): TopologyCandidate | undefined {
+  let text: string;
+  try {
+    text = new TextDecoder().decode(r.payloadBytes);
+  } catch {
+    return undefined;
+  }
+  try {
+    const v: unknown = JSON.parse(text);
+    if (
+      v === null ||
+      typeof v !== "object" ||
+      Array.isArray(v)
+    ) {
+      return undefined;
+    }
+    const o = v as Record<string, unknown>;
+    if (
+      typeof o.source !== "string" ||
+      typeof o.target !== "string" ||
+      typeof o.head !== "string" ||
+      typeof o.score !== "number" ||
+      (o.kind !== "dependency" && o.kind !== "contradiction")
+    ) {
+      return undefined;
+    }
+    // Q04: reject any id that would corrupt the `|`/`~` digest framing.
+    if (
+      FRAMING_SEP.test(o.source) ||
+      FRAMING_SEP.test(o.target) ||
+      FRAMING_SEP.test(o.head)
+    ) {
+      return undefined;
+    }
+    return {
+      source: o.source,
+      target: o.target,
+      head: o.head,
+      score: o.score,
+      kind: o.kind,
+    };
+  } catch {
+    return undefined;
+  }
+}
+
+/** Field (`|`) and record (`~`) separators used by the canonical digest framing. */
+const FRAMING_SEP = /[|~]/;

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";