pi-mega-compact 0.16.3 → 0.17.1

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

@@ -0,0 +1,292 @@
+/**
+ * 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.
+ *
+ * VC0C (task 5) adds:
+ *   GET  /api/vector-cortex/health          — reader-only aggregate health card
+ *   POST /api/vector-cortex/breakers/reset  — explicit admin capability
+ *
+ * Guardrails: PREVENT-PI-004 (local filesystem read only), PREVENT-011 (no
+ * `any`), reader-only aggregate (never payloads/prompts/ledger — EVAL-REDACT-002).
+ */
+import { VC0A_ENABLED, VC0C_ENABLED, VC1B_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";
+/** Admin capability: an actor-supplied subsystem selector for breaker reset. */
+function readJsonBody(req, cb) {
+    let body = "";
+    let tooBig = false;
+    req.on("data", (chunk) => {
+        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 });
+        }
+        catch {
+            cb({ ok: false, error: "invalid_json" });
+        }
+    });
+}
+function sendJson(res, status, body) {
+    // guardrails-allow PREVENT-PI-004: loopback dashboard response (local)
+    res.writeHead(status, { "Content-Type": "application/json" });
+    res.end(JSON.stringify(body));
+}
+/** Reader-only aggregate GET /api/vector-cortex/evaluation. */
+export function handleVectorCortexEvaluation(req, res, ctx) {
+    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 = {
+        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, res, ctx) {
+    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 fallback = {
+        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",
+    };
+    if (!card) {
+        sendJson(res, 200, fallback);
+        return true;
+    }
+    const mode = 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 = {
+        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,
+    };
+    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, res, ctx) {
+    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 = {
+                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, res, ctx) {
+    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 = [];
+    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 = {
+        enabled: active,
+        session,
+        highWater,
+        count,
+        occurrences,
+        updatedAt: new Date().toISOString(),
+    };
+    sendJson(res, 200, body);
+    return true;
+}

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

@@ -23,3 +23,4 @@ export { handleRagSettings } from "./routes-rag-settings.js";
 export { handleRagMetrics } from "./routes-rag-metrics.js";
 export { handleModelThresholds } from "./routes-model-thresholds.js";
 export { handleWiki } from "./routes-wiki.js";
+export { handleVectorCortexEvaluation, handleVectorCortexHealth, handleVectorCortexBreakersReset, handleVectorCortexLedger, } from "./routes-vector-cortex.js";

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

@@ -13,7 +13,7 @@ import { fileURLToPath } from "node:url";
 import { createRequire } from "node:module";
 import { NEW_UI } from "../../src/config.js";
 import { log, setLogPath, setDashboardServerVersion } from "./state.js";
-import { buildRouteContext, handleIndex, handleRepoIndex, handleEvents, handleGameState, handleGameScores, handlePerf, handlePerfSamples, handleAchievements, handleSessions, handleTopics, handleTurns, handleMaintenance, handleProviderCache, handleCacheStripes, handleMemoryStatus, handleSetupStatus, handleSetupDetect, handleSetupConfigure, handleMemoryMap, handleRaptorTree, handleRaptorBuildHistory, handleContextHealth, handleCachePoison, handleHealthSettings, handleEmbedderHealth, handleRagSettings, handleRagMetrics, handleModelThresholds, handleWiki, handleStatic, } from "./routes.js";
+import { buildRouteContext, handleIndex, handleRepoIndex, handleEvents, handleGameState, handleGameScores, handlePerf, handlePerfSamples, handleAchievements, handleSessions, handleTopics, handleTurns, handleMaintenance, handleProviderCache, handleCacheStripes, handleMemoryStatus, handleSetupStatus, handleSetupDetect, handleSetupConfigure, handleMemoryMap, handleRaptorTree, handleRaptorBuildHistory, handleContextHealth, handleCachePoison, handleHealthSettings, handleEmbedderHealth, handleRagSettings, handleRagMetrics, handleModelThresholds, handleWiki, handleVectorCortexEvaluation, handleVectorCortexHealth, handleVectorCortexBreakersReset, handleVectorCortexLedger, handleStatic, } from "./routes.js";
 export async function launchDashboardServer(stateDir) {
     // Our own package version — exposed at /api/version so the launcher can
     // detect a stale server (started by an older build) and replace it on
@@ -241,6 +241,14 @@ export async function launchDashboardServer(stateDir) {
             return;
         if (handleWiki(req, res, ctx))
             return;
+        if (handleVectorCortexEvaluation(req, res, ctx))
+            return;
+        if (handleVectorCortexHealth(req, res, ctx))
+            return;
+        if (handleVectorCortexBreakersReset(req, res, ctx))
+            return;
+        if (handleVectorCortexLedger(req, res, ctx))
+            return;
         handleStatic(req, res, ctx);
     });
     // Bind base + range are env-configurable so tests can use a private,

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

@@ -4,6 +4,7 @@ import { estimateSessionTokens, estimateBlockTokens, estimateMessageTokens, } fr
 import { runCompact, piCompactWouldNoop } from "../mega-pipeline.js";
 import { pressureFromPct, pressureRatio, } from "../mega-config.js";
 import { appendMirrorMessages } from "./mirror-append.js";
+import { appendMessagesToLedger } from "../mega-runtime/vector-cortex-ledger.js";
 import { epochIdFor } from "../../src/mirror/epoch.js";
 import { computeLiveTrimCut, liveTrimSummaryMessage } from "../mega-trim.js";
 import { messageContentText } from "./context-handler/messageText.js";
@@ -101,6 +102,16 @@ export function registerContextHandler(pi, runtime, config) {
                 runtime.logger.warn("db-mirror-append-fail", { error: String(e) });
             }
         }
+        // VC1B (S1): canonical messages -> v2 ledger occurrences. Flag-OFF opens
+        // no DB (byte-identical predecessor); non-fatal. onFailure surfaces
+        // per-append rejections (e.g. EVT_SEQ_REGRESSION on rewind/fork) as
+        // structured warnings rather than swallowing them silently.
+        try {
+            appendMessagesToLedger(runtime.currentStateDir, runtime.rt.sessionId, messages, runtime.logger);
+        }
+        catch (e) {
+            runtime.logger.warn("vc1b-ledger-append-fail", { error: String(e) });
+        }
         // S52 / v0.16.1: per-model threshold override. The user can tune the
         // fire point + safety margin PER MODEL (different providers' models range
         // 8K-1M+ context, so one global tier % is wrong). Falls back to env/default

package/dist/extensions/mega-runtime/vector-cortex-ledger.js

@@ -0,0 +1,131 @@
+/**
+ * vector-cortex-ledger.ts — VC1B occurrence-ledger writer wiring (S1).
+ *
+ * Wires ONLY the `LedgerWriter` capability into message ingestion: each
+ * canonical message that flows through the compaction pipeline becomes an
+ * occurrence in the v2 ledger. The wiring is writer-only (never reader/admin
+ * here — the dashboard GET owns the reader), matching the capability-gated
+ * CONTRACTS §Store rule. A tool RESULT occurrence references exactly one
+ * earlier call via `toolCallId` (the ledger enforces EVT_TOOL_CALL_MISSING).
+ *
+ * When MEGACOMPACT_VC1B is OFF the seam opens NO ledger DB at all — and even if
+ * a caller already holds a store, its write path is inert (S2 flag-gate in
+ * store.ts) — so the OFF behavior is byte-identical to the pre-VC1B predecessor.
+ *
+ * Local-only (PREVENT-PI-004), no `any` (PREVENT-011), no console.log (events
+ * go through the ledger emit seam); non-fatal — a ledger write failure never
+ * breaks the agent loop.
+ */
+import { createHash } from "node:crypto";
+import { VC1B_ENABLED } from "../../src/config/vector-cortex.js";
+import { createLedgerStore, } from "../../src/vector-cortex/ledger/store.js";
+/** Open the ledger writer for ingestion, or null when VC1B is disabled. */
+export function openLedgerWriter(stateDir) {
+    if (!VC1B_ENABLED())
+        return null;
+    const store = createLedgerStore({ stateDir });
+    return { writer: store.writer(), close: () => store.close() };
+}
+/**
+ * Append one occurrence for a canonical message. `kind` is the neutral kind;
+ * when `toolCallId` is present the ledger enforces exactly-one reference to an
+ * earlier call. Flag-OFF (null handle) and the writer's own inert path are
+ * no-ops. Non-fatal: never throws to the loop — a failure is surfaced as
+ * `{ ok: false, code }` so the caller can log the reason (Q02).
+ */
+export function appendLedgerMessage(handle, input) {
+    try {
+        const res = handle.writer.append(input);
+        return res.ok ? { ok: true } : { ok: false, code: res.code };
+    }
+    catch (e) {
+        return { ok: false, code: String(e) };
+    }
+}
+/**
+ * Append one occurrence per canonical message in `messages` (session-scoped,
+ * sequence = 1-based index). Opens the writer, appends each, closes the handle.
+ * Returns the number of accepted occurrences (0 when disabled OR when every
+ * append was a non-fatal no-op). This is the S1 ingestion seam.
+ *
+ * Monotonic-prefix assumption (Q02): the FIRST accepted append establishes the
+ * per-session high-water, and each subsequent append must carry `seq =
+ * highWater + 1`. Append order here follows `messages` array order with 1-based
+ * indices, so a shorter/mid-removal/reordered `messages` list after a prior
+ * taller run (rewind/fork) can drive `seq` backwards and be rejected with
+ * `EVT_SEQ_REGRESSION`. Such appends fail on the ledger and, without `onFailure`,
+ * are swallowed silently — so the caller should pass `onFailure` to log them.
+ */
+export function appendMessagesToLedger(stateDir, sessionId, messages, onFailure) {
+    const ledger = openLedgerWriter(stateDir);
+    if (!ledger)
+        return 0;
+    try {
+        let accepted = 0;
+        for (let i = 0; i < messages.length; i++) {
+            const input = messageToLedgerInput(messages[i], sessionId, i);
+            const res = appendLedgerMessage(ledger, input);
+            if (res.ok) {
+                accepted++;
+            }
+            else if (onFailure) {
+                onFailure.warn("vc1b-ledger-append-skip", {
+                    session: sessionId,
+                    seq: input.seq.toString(),
+                    eventId: input.eventId,
+                    kind: input.kind,
+                    reason: res.code ?? "unknown",
+                });
+            }
+        }
+        return accepted;
+    }
+    finally {
+        ledger.close();
+    }
+}
+/**
+ * Map an AgentMessage to a ledger occurrence input. `eventId` is the stable
+ * content digest so re-observed identical messages are (event_id,digest)-deduped;
+ * `kind` mirrors the canonical role. `toolCallId` is intentionally NOT set here:
+ * pi discriminates messages by `role` only and the tool-call id lives in
+ * variant-specific `.content`/`.tool_calls` we must not reach into, so the
+ * exactly-one tool back-edge (EVT_TOOL_CALL_MISSING) is exercised at the
+ * store/acceptance level and the full live mapping is deferred to the VC1
+ * producer-wiring sprint.
+ */
+export function messageToLedgerInput(msg, session, indexInSession) {
+    const m = msg;
+    const text = messageText(msg);
+    const role = m.role ?? "unknown";
+    const digest = `sha256:${createHash("sha256").update(text).digest("hex")}`;
+    return {
+        session,
+        seq: BigInt(indexInSession + 1),
+        eventId: m.id ?? digest,
+        kind: role,
+        sourceBytes: new TextEncoder().encode(text),
+    };
+}
+/** Best-effort text extraction from an AgentMessage (string or part array). */
+function messageText(msg) {
+    const content = msg.content;
+    if (content == null)
+        return "";
+    if (typeof content === "string")
+        return content;
+    if (Array.isArray(content)) {
+        return content
+            .map((p) => {
+            const part = p;
+            return typeof part.text === "string" ? part.text : "";
+        })
+            .join("\n");
+    }
+    if (typeof content === "object") {
+        const maybe = content.text;
+        if (typeof maybe === "string")
+            return maybe;
+    }
+    return "";
+}

package/dist/extensions/mega-runtime/vector-cortex-safety.js

@@ -0,0 +1,100 @@
+/**
+ * vector-cortex-safety.ts — VC0C live safety envelope (VC0C, task 4 + 5).
+ *
+ * Owns the live triad selection BEFORE provider invocation: select mode A
+ * (optimized/learned), then independent mode B (deterministic local spool
+ * deriving directly from authority), then unchanged mode C (continuity, not
+ * semantic completeness — C uses only the exact current transcript and reports
+ * that limitation). A manual reset clears cooldown but NEVER evidence.
+ *
+ * This adapter composes the resilience seams (`resilience/breaker.ts`,
+ * `resilience/spool.ts`, `resilience/emit.ts`) into the health/reset API the
+ * dashboard owns (`GET /api/vector-cortex/health`, admin
+ * `POST /api/vector-cortex/breakers/reset`). It is the pi-runtime-adjacent shell;
+ * all durable state is owned by the src/ resilience modules. Non-fatal: any
+ * breaker/spool noise degrades to mode C (unchanged host transcript), and the
+ * agent loop is never broken.
+ *
+ * Local-only (PREVENT-PI-004); no `any` (PREVENT-011); no console.log — events
+ * go through the injected resilience reporter / Logger.
+ *
+ * LIVENESS HONESTY (VC0C-Q01/Q06): the breaker composed here is PER-PROCESS /
+ * IN-MEMORY and EPHEMERAL — `createVectorCortexSafety` builds a fresh instance on
+ * every dashboard request (GET /health, POST /reset). There is NO persistent
+ * breaker runtime and NO live producer wiring (the real circuit-breaker that runs
+ * around the actual compaction loop is DEFERRED to the producer-wiring sprint,
+ * carried VC0B-I08 -> VC0D). Consequently GET /health always reflects a brand-new
+ * CLOSED_A instance and POST /reset mutates an instance that vanishes when the
+ * request returns: the endpoints are ILLUSTRATIVE until VC0D wires a persistent
+ * instance. The health payload therefore carries `stateSource:"ephemeral"` so the
+ * dashboard/README never present it as a live breaker. Frontier-frozen / spool-lag
+ * are owned by the DURABLE spool but have no live per-session handle here, so they
+ * are surfaced as static/non-live until VC0D (with authorityOutage mirrored from
+ * the host context when supplied).
+ */
+import { join } from "node:path";
+import { createResilienceReporter } from "../../src/vector-cortex/resilience/emit.js";
+import { createBreaker } from "../../src/vector-cortex/resilience/breaker.js";
+import { createSpool } from "../../src/vector-cortex/resilience/spool.js";
+import { BREAKER_WINDOW_MS, VC0C_ENABLED } from "../../src/config/vector-cortex.js";
+/** Build the live safety envelope, wiring the emit seam into the breaker. */
+export function createVectorCortexSafety(ctx, emit) {
+    const reporter = createResilienceReporter(emit);
+    const wallNow = ctx.wallNow ?? (() => new Date().toISOString());
+    const breaker = createBreaker({ now: ctx.now, reporter, wallNow });
+    const spool = createSpool({
+        dir: join(ctx.stateDir, "spool"),
+        authorityOutage: ctx.authorityOutage,
+        // Wire the resilience emit seam (incl. vector_cortex_frontier_frozen) into
+        // the mode-B spool so a real authority-frontier freeze is observable.
+        reporter,
+    });
+    return {
+        spool,
+        select(provider) {
+            const { subsystem, inputDigest, runA, runB, runC, validate } = provider;
+            // Thin delegation to the breaker: it selects the highest healthy mode
+            // (A, else independent B, else unchanged C) BEFORE provider invocation and
+            // records the attempt/trip. Across invocations A-failure demotes to B and
+            // B-failure demotes to C (continuity — unchanged transcript).
+            return breaker.execute(subsystem, inputDigest, { A: runA, B: runB, C: runC }, validate);
+        },
+        health() {
+            const rec = breaker.snapshot("provider");
+            const enabled = VC0C_ENABLED();
+            // LIVENESS HONESTY (VC0C-Q01/Q06): this breaker is created fresh per request
+            // and is ephemeral — declare it explicitly so the dashboard never presents it
+            // as a live breaker. `authorityOutage` is mirrored from the host context when
+            // supplied (otherwise false). `frontierFrozen` (rec.frozenFrontier) and
+            // `spoolLag` are owned by the DURABLE spool, which has no live per-session
+            // handle here — they stay static/no-op until VC0D wires a persistent breaker
+            // instance; stateSource:"ephemeral" is the signal that they are not live.
+            return {
+                enabled,
+                mode: rec.state === "MANUAL_HALT" ? "C" : rec.state === "CLOSED_A" ? "A" : "B",
+                state: rec.state,
+                subsystem: "provider",
+                sinceMs: rec.transitionedAtMs,
+                reason: rec.manualReason,
+                windowMs: BREAKER_WINDOW_MS,
+                probeCount: rec.probeCount,
+                backoffDelayMs: rec.retryDelayMs,
+                frontierFrozen: rec.frozenFrontier,
+                authorityOutage: ctx.authorityOutage?.() ?? false,
+                spoolLag: 0,
+                attempts: rec.attempts,
+                failures: rec.failures,
+                p95Ms: rec.p95Ms,
+                failureRate: rec.failureRate,
+                updatedAt: wallNow(),
+                stateSource: "ephemeral",
+            };
+        },
+        reset(subsystem) {
+            return breaker.reset(subsystem);
+        },
+        halt(reason) {
+            return breaker.manualHalt(reason);
+        },
+    };
+}

package/dist/src/config/vector-cortex.js

@@ -0,0 +1,91 @@
+/**
+ * config/vector-cortex.ts — vector-cortex feature flags + breaker/triad constants.
+ *
+ * Every sprint ships one positive `MEGACOMPACT_<SPRINT>` flag, default ON and
+ * `=0`/`_DISABLED` off. Flag-OFF is byte-identical to the predecessor sprint's
+ * behavior (for VC0A: mode C — observer absent, zero evaluation writes).
+ *
+ * The breaker/triad constants (TRIAD_RESILIENCE.md) live here so VC0C consumes
+ * them without re-declaring the ownership boundary. Pi-agnostic, dependency-free.
+ */
+/** Positive sprint flag: `=0` or `_DISABLED=true` disables (default ON). */
+function sprintFlag(name) {
+    const v = process.env[name];
+    if (v === "0" || v === "false")
+        return false;
+    const disabled = process.env[name + "_DISABLED"];
+    if (disabled === "true" || disabled === "1")
+        return false;
+    return true;
+}
+/** VC0A — baseline observability (MetricEventV1 / AnnotationV1). Default ON. */
+export const VC0A_ENABLED = () => sprintFlag("MEGACOMPACT_VC0A");
+/**
+ * VC0B — replay correctness (ReplayCutV2 / ReplayReportV2, M3 effective-cut-v2).
+ * Default ON. `MEGACOMPACT_VC0B=0` disables and is byte-identical to the
+ * predecessor (legacy capped-replay behavior preserved; the v2 cut/replay is
+ * only consulted on the vector-cortex path).
+ */
+export const VC0B_ENABLED = () => sprintFlag("MEGACOMPACT_VC0B");
+/**
+ * VC1A — canonical byte events (EventV2 / EventCodec).
+ * Default ON. `MEGACOMPACT_VC1A=0` disables and is byte-identical to the
+ * predecessor (mode C: ledger absent, current transcript codec unchanged).
+ * The single real consumer is the ledger emit seam (`ledger/emit.ts`): flag OFF
+ * gates zero observability writes.
+ */
+export const VC1A_ENABLED = () => sprintFlag("MEGACOMPACT_VC1A");
+/**
+ * VC1B — occurrence ledger + tool identity + compat journal (LedgerReader/
+ * Writer/Admin, CompatJournalV1, M2 occurrence-v2 migration).
+ * Default ON. `MEGACOMPACT_VC1B=0` disables and is byte-identical to the
+ * predecessor (mode C: the neutral occurrence ledger is not written, no
+ * journal rows, zero `vector_cortex_occurrence_appended` emissions). The real
+ * consumers are the ledger write integration seam and the compat-journal
+ * switch seam.
+ */
+export const VC1B_ENABLED = () => sprintFlag("MEGACOMPACT_VC1B");
+/**
+ * VC0C — live safety envelope (TriadResult / Breaker / KillDecision + durable
+ * spool). Default ON. `MEGACOMPACT_VC0C=0` disables and is byte-identical to
+ * the predecessor (mode C: selected before provider invocation, unchanged host
+ * transcript, breaker/spool idle and emitting nothing). The single real
+ * consumer is the resilience emit seam + the safety adapter's triad selection.
+ */
+export const VC0C_ENABLED = () => sprintFlag("MEGACOMPACT_VC0C");
+/**
+ * VC1C — cross-language conformance v2 (FixtureManifestV2 / DowngradeReport /
+ * MinHashV2 + M4 minhash-v2 migration).
+ * Default ON. `MEGACOMPACT_VC1C=0` disables and is byte-identical to the
+ * predecessor (mode C: a v2 conformance runner that accepts authority fixtures
+ * and the manifest validator idle; the sync dedup scan stays on the v1 path;
+ * zero `vector_cortex_*` VC1C emissions). The real consumers are the conformance
+ * emit seam, the minhash-v2 backfill seam and the downgrade-export seam.
+ */
+export const VC1C_ENABLED = () => sprintFlag("MEGACOMPACT_VC1C");
+// ---------------------------------------------------------------------------
+// Breaker state machine constants (TRIAD_RESILIENCE.md §breaker).
+// Rolled numbers for one 60s window; VC0C consumes these at its breaker seam.
+// ---------------------------------------------------------------------------
+/** Rolling eligibility window (milliseconds). */
+export const BREAKER_WINDOW_MS = 60_000;
+/** Minimum attempts before a breaker may trip or promote. */
+export const BREAKER_MIN_ATTEMPTS = 20;
+/** Performance trip: ≥ this many failures in window, or ≥ this fraction. */
+export const BREAKER_PERF_FAILURES = 5;
+export const BREAKER_PERF_FAILURE_RATE = 0.1;
+/** Correctness trip trips on the first correctness failure. */
+export const BREAKER_CORRECTNESS_FAILURES = 1;
+/** Cooldown before an open breaker may probe (milliseconds). */
+export const BREAKER_COOLDOWN_MS = 30_000;
+/** Consecutive successful probes required to advance a state. */
+export const BREAKER_PROBE_COUNT = 3;
+/** Exponential retry base: 30s * 2^attempt, capped, ±10% jitter. */
+export const BREAKER_RETRY_BASE_MS = 30_000;
+export const BREAKER_RETRY_CAP_MS = 15 * 60_000;
+export const BREAKER_RETRY_JITTER = 0.1;
+/** Promotion hysteresis: failure rate must be < this and p95 within budget. */
+export const BREAKER_HYSTERESIS_FAILURE_RATE = 0.02;
+export const BREAKER_HYSTERESIS_BUDGET_P95_MS = 50;
+/** Minimum healthy residence before a further promotion (milliseconds). */
+export const BREAKER_MIN_HEALTHY_RESIDENCE_MS = 5 * 60_000;