pi-mega-compact 0.20.5 → 0.20.6

package/dist/config/vector-cortex.js

@@ -184,6 +184,18 @@ export const VC5A_ENABLED = () => sprintFlag("MEGACOMPACT_VC5A");
  * in EXCLUDED_SETTINGS), mirroring VC4A/VC4B/VC4C/VC5A.
  */
 export const VC5B_ENABLED = () => sprintFlag("MEGACOMPACT_VC5B");
+/**
+ * VC5C — live graduated rollout. Default ON. `MEGACOMPACT_VC5C=0` disables and
+ * is byte-identical to the predecessor (VC5B): no session is assigned a stable
+ * 10k bucket, no gate-advance decision runs, the `vector_cortex_rollout_assigned`
+ * / `vector_cortex_rollout_promotion_blocked` events are never emitted, and the
+ * prompt continues to be built by the predecessor VC5B renderer path (its goldens
+ * are unchanged). The assign/gate/emit functions are PURE — flag OFF gates the
+ * reporter + dashboard seam, never the arithmetic. This flag MUST also be a
+ * dashboard SETTINGS toggle (visible in config UI, never in EXCLUDED_SETTINGS),
+ * mirroring VC4A/VC4B/VC4C/VC5A/VC5B.
+ */
+export const VC5C_ENABLED = () => sprintFlag("MEGACOMPACT_VC5C");
 // ---------------------------------------------------------------------------
 // Breaker state machine constants (TRIAD_RESILIENCE.md §breaker).
 // Rolled numbers for one 60s window; VC0C consumes these at its breaker seam.

package/dist/config.js

@@ -114,4 +114,4 @@ export const NEW_UI = () => ragEnabled("MEGACOMPACT_NEW_UI");
 // default ON, `=0`/`_DISABLED` off. Re-exported from src/config/vector-cortex.ts
 // so root consumers share one source of truth.
 // ---------------------------------------------------------------------------
-export { VC0A_ENABLED, VC0B_ENABLED, VC1A_ENABLED, VC0C_ENABLED, VC1B_ENABLED, VC1C_ENABLED, VC2A_ENABLED, VC2B_ENABLED, VC2C_ENABLED, VC3A_ENABLED, VC3B_ENABLED, VC3C_ENABLED, VC4A_ENABLED, VC4B_ENABLED, VC4C_ENABLED, VC5A_ENABLED, VC5B_ENABLED, BREAKER_WINDOW_MS, BREAKER_MIN_ATTEMPTS, BREAKER_PERF_FAILURES, BREAKER_PERF_FAILURE_RATE, BREAKER_CORRECTNESS_FAILURES, BREAKER_COOLDOWN_MS, BREAKER_PROBE_COUNT, BREAKER_RETRY_BASE_MS, BREAKER_RETRY_CAP_MS, BREAKER_RETRY_JITTER, BREAKER_HYSTERESIS_FAILURE_RATE, BREAKER_HYSTERESIS_BUDGET_P95_MS, BREAKER_MIN_HEALTHY_RESIDENCE_MS, } from "./config/vector-cortex.js";
+export { VC0A_ENABLED, VC0B_ENABLED, VC1A_ENABLED, VC0C_ENABLED, VC1B_ENABLED, VC1C_ENABLED, VC2A_ENABLED, VC2B_ENABLED, VC2C_ENABLED, VC3A_ENABLED, VC3B_ENABLED, VC3C_ENABLED, VC4A_ENABLED, VC4B_ENABLED, VC4C_ENABLED, VC5A_ENABLED, VC5B_ENABLED, VC5C_ENABLED, BREAKER_WINDOW_MS, BREAKER_MIN_ATTEMPTS, BREAKER_PERF_FAILURES, BREAKER_PERF_FAILURE_RATE, BREAKER_CORRECTNESS_FAILURES, BREAKER_COOLDOWN_MS, BREAKER_PROBE_COUNT, BREAKER_RETRY_BASE_MS, BREAKER_RETRY_CAP_MS, BREAKER_RETRY_JITTER, BREAKER_HYSTERESIS_FAILURE_RATE, BREAKER_HYSTERESIS_BUDGET_P95_MS, BREAKER_MIN_HEALTHY_RESIDENCE_MS, } from "./config/vector-cortex.js";

package/dist/extensions/dashboard-server/routes-rag-settings-helpers.js

@@ -151,6 +151,7 @@ export const SETTINGS = [
             boolDirect("MEGACOMPACT_VC4C", "VC4C Reconstruction Fidelity", "Conservative closure + source-order assembly + reconstruction validator: recursively closes dependencies and whole tool pairs to a fixed point, resolves contradictions by retaining the later exact source resolution, assembles spans solely by source range, and rejects missing anchors / split pairs / digest mismatch / unresolved contradiction. Mandatory token estimate is content-only and handed unchanged to VC5A. OFF = mode C, no closure/validator, byte-identical predecessor (VC4B).", true),
             boolDirect("MEGACOMPACT_VC5A", "VC5A PromptDagV1 + Budgeted Planner", "Single-session DAG (PromptDagV1) + budgeted 0/1 portfolio planner: builds a stable Kahn-ordered DAG, computes the mandatory dependency/tool/anchor closure before optional selection, returns MANDATORY_CLOSURE_OVER_BUDGET with evidence preserved on overflow, and runs a utility-per-token portfolio that never exceeds the remaining budget. Framing is owned here, not in VC4C. OFF = byte-identical predecessor (VC4C).", true),
             boolDirect("MEGACOMPACT_VC5B", "VC5B Validated Renderer + Provider Profiles", "Validated prompt renderer: replays VC5A's stable Kahn order verbatim, preserves exact tool bytes (PREVENT-PI-002), places compacted context via the host before_agent_start prepend seam — never role:system (PREVENT-PI-003) — and SHA-256 hashes the entire canonical outbound request before provider invocation. Unknown provider/model cleanly bypasses to the predecessor prompt path. OFF = byte-identical predecessor (VC5A).", true),
+            boolDirect("MEGACOMPACT_VC5C", "VC5C Live Graduated Rollout", "Live graduated rollout: deterministically hashes each session into a stable 10,000-bucket cohort and advances the exposure gate (1/5/25/50/100%) only after a 72h monotonic residency, a powered sample, >=10,000 events, and >=200 sessions — advancing ONE gate at a time. A hard causal/tool/anchor/exact failure freezes promotion and selects the pre-VC path. OFF = byte-identical predecessor (VC5B).", true),
         ],
     },
     {

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

@@ -0,0 +1,43 @@
+/**
+ * dashboard-server/routes-vector-cortex-rollout.ts — VC5C live graduated-rollout
+ * dashboard route.
+ *
+ * Reader-only GET /api/vector-cortex/rollout returning the rollout aggregate:
+ * current gate, bucket count, sessions/events counts, and promotion-blocked
+ * state. NEVER exposes session payloads, prompt text, or bucket→session mappings
+ * (reader-only, SECURITY_PRIVACY). Flag-gated on MEGACOMPACT_VC5C: `enabled:false`
+ * when off (byte-identical to the pre-VC5C predecessor).
+ *
+ * Guardrails: PREVENT-PI-004 (local in-process state only), PREVENT-011 (no
+ * `any`), reader-only aggregate (counts + gate state only).
+ */
+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";
+/** Reader-only GET /api/vector-cortex/rollout (VC5C). */
+export function handleVectorCortexRollout(req, res, _ctx) {
+    const url = req.url ?? "";
+    const path = url.split("?")[0] ?? url;
+    if (path !== "/api/vector-cortex/rollout")
+        return false;
+    if (req.method !== "GET") {
+        sendJson(res, 405, { error: "method_not_allowed" });
+        return true;
+    }
+    const enabled = VC5C_ENABLED();
+    const gateIndex = 0; // Ephemeral rollout state: no durable gate in this sprint.
+    const gatePct = ROLLOUT_GATES[gateIndex];
+    const body = {
+        enabled,
+        gateIndex: enabled ? gateIndex : 0,
+        gatePct: enabled ? gatePct : 0,
+        buckets: ROLLOUT_BUCKETS,
+        bucketCount: enabled ? gatePct * 100 : 0,
+        events: 0,
+        sessions: 0,
+        promotionBlocked: false,
+        updatedAt: new Date().toISOString(),
+    };
+    sendJson(res, 200, body);
+    return true;
+}

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

@@ -23,3 +23,4 @@ export { handleVectorCortexResidual } from "./routes-vector-cortex-residual.js";
 export { handleVectorCortexReconstruct } from "./routes-vector-cortex-reconstruct.js";
 export { handleVectorCortexPlans } from "./routes-vector-cortex-plans.js";
 export { handleVectorCortexRender } from "./routes-vector-cortex-render.js";
+export { handleVectorCortexRollout } from "./routes-vector-cortex-rollout.js";

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

@@ -23,4 +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, handleVectorCortexTopology, handleVectorCortexQuery, handleVectorCortexShards, handleVectorCortexResidual, handleVectorCortexReconstruct, handleVectorCortexPlans, handleVectorCortexRender, } from "./routes-vector-cortex.js";
+export { handleVectorCortexEvaluation, handleVectorCortexHealth, handleVectorCortexBreakersReset, handleVectorCortexLedger, handleVectorCortexTopology, handleVectorCortexQuery, handleVectorCortexShards, handleVectorCortexResidual, handleVectorCortexReconstruct, handleVectorCortexPlans, handleVectorCortexRender, handleVectorCortexRollout, } from "./routes-vector-cortex.js";

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

@@ -14,7 +14,7 @@ import { createRequire } from "node:module";
 import { NEW_UI } from "../../src/config.js";
 import { log, setLogPath, setDashboardServerVersion } from "./state.js";
 import { detectTailscaleIP } from "./tailscale.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, handleVectorCortexTopology, handleVectorCortexQuery, handleVectorCortexShards, handleVectorCortexResidual, handleVectorCortexReconstruct, handleVectorCortexPlans, handleVectorCortexRender, 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, handleVectorCortexTopology, handleVectorCortexQuery, handleVectorCortexShards, handleVectorCortexResidual, handleVectorCortexReconstruct, handleVectorCortexPlans, handleVectorCortexRender, handleVectorCortexRollout, 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
@@ -279,6 +279,8 @@ export async function launchDashboardServer(stateDir) {
             return;
         if (handleVectorCortexRender(req, res, ctx))
             return;
+        if (handleVectorCortexRollout(req, res, ctx))
+            return;
         handleStatic(req, res, ctx);
     });
     // Bind base + range are env-configurable so tests can use a private,

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

@@ -0,0 +1,105 @@
+/**
+ * vector-cortex-live.ts — VC5C live graduated-rollout integration seam.
+ *
+ * This adapter composes the rollout assign + gate + emit seams into the host
+ * provider-invocation path. It runs BEFORE provider invocation and decides, for
+ * the current session, which live path is active:
+ *
+ *   - on a hard causal/tool/anchor/exact failure → select mode C (pre-VC prompt
+ *     path) and FREEZE promotion (promotionBlocked=true) for the remainder of the
+ *     cooldown/spool/restart/clock period satisfying TRIAD_RESILIENCE;
+ *   - otherwise → the active gate decides whether the VC path is exposed to this
+ *     session's bucket.
+ *
+ * PREVENT-PI-003: the rollout NEVER emits a `role:"system"` message. The VC
+ * prompt context is composed into the host `before_agent_start` systemPrompt
+ * prepend seam only. PREVENT-PI-004: zero network calls (local in-process state
+ * + injected clock only). PREVENT-011: no `any`. Non-fatal: any rollout noise
+ * degrades to mode C (pre-VC continuity), never breaking the agent loop.
+ *
+ * LIVENESS HONESTY (mirrors VC0C-Q01/Q06): the rollout decision state here is
+ * PER-PROCESS / IN-MEMORY and EPHEMERAL — there is NO persistent rollout runtime
+ * and NO live producer wiring. The gate decision is recomputed from injected
+ * evidence each epoch. The assigned/blocked events are emitted for observability
+ * only.
+ */
+import { assignSession, bucketInGate, gatePctForIndex } from "../../src/vector-cortex/rollout/assign.js";
+import { decideGate, selectsPreVcPath, } from "../../src/vector-cortex/rollout/gate.js";
+import { createRolloutReporter } from "../../src/vector-cortex/rollout/emit.js";
+import { VC5C_ENABLED } from "../../src/config/vector-cortex.js";
+const NO_PREPEND = "";
+/**
+ * Decide the live path for a session epoch. Pure over injected context; no
+ * I/O, no network. Flag OFF (or absent evidence/clock) degrades to mode C with
+ * the VC path inactive (pre-VC predecessor parity).
+ */
+export function decideLivePath(sessionId, ctx) {
+    const reporter = createRolloutReporter(ctx.emit);
+    const assignment = assignSession(sessionId);
+    if (!VC5C_ENABLED()) {
+        // Pre-VC predecessor: no rollout, no VC path. Never emit role:system.
+        return {
+            vcActive: false,
+            forcedPreVc: false,
+            mode: "C",
+            bucket: assignment.bucket,
+            gateIndex: 0,
+            promotionBlocked: false,
+            systemPromptPrepend: NO_PREPEND,
+        };
+    }
+    reporter.assigned({
+        sessionId,
+        bucket: assignment.bucket,
+        gateIndex: assignment.gateIndex,
+        gatePct: gatePctForIndex(assignment.gateIndex),
+    });
+    const hardFaults = ctx.hardFaults ?? [];
+    const hardFault = hardFaults.length > 0 ? hardFaults[0] : undefined;
+    const forcedPreVc = selectsPreVcPath(hardFault);
+    if (forcedPreVc && hardFault) {
+        reporter.promotionBlocked({
+            gateIndex: ctx.currentGate ?? assignment.gateIndex,
+            kind: hardFault.kind,
+            detail: hardFault.detail,
+        });
+        // Hard failure → select C (pre-VC path) and freeze promotion.
+        return {
+            vcActive: false,
+            forcedPreVc: true,
+            mode: "C",
+            bucket: assignment.bucket,
+            gateIndex: ctx.currentGate ?? assignment.gateIndex,
+            promotionBlocked: true,
+            systemPromptPrepend: NO_PREPEND,
+        };
+    }
+    const clock = ctx.clock;
+    const evidence = ctx.evidence;
+    if (clock === undefined || evidence === undefined) {
+        // No live evidence/clock → pre-VC parity (no promotion, no VC exposure).
+        return {
+            vcActive: false,
+            forcedPreVc: false,
+            mode: "C",
+            bucket: assignment.bucket,
+            gateIndex: assignment.gateIndex,
+            promotionBlocked: false,
+            systemPromptPrepend: NO_PREPEND,
+        };
+    }
+    const outcome = decideGate(ctx.currentGate ?? assignment.gateIndex, evidence, clock);
+    const vcActive = bucketInGate(assignment.bucket, outcome.gatePct);
+    // PREVENT-PI-003: VC prompt context is composed into the host prepend seam,
+    // never as a role:system message. Empty prepend here (the actual prompt text
+    // is owned by the renderer seam); this seam only signals eligibility.
+    return {
+        vcActive,
+        forcedPreVc: false,
+        mode: vcActive ? "A" : "C",
+        bucket: assignment.bucket,
+        gateIndex: outcome.gateIndex,
+        promotionBlocked: outcome.promotionBlocked,
+        systemPromptPrepend: NO_PREPEND,
+    };
+}

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

@@ -184,6 +184,18 @@ export const VC5A_ENABLED = () => sprintFlag("MEGACOMPACT_VC5A");
  * in EXCLUDED_SETTINGS), mirroring VC4A/VC4B/VC4C/VC5A.
  */
 export const VC5B_ENABLED = () => sprintFlag("MEGACOMPACT_VC5B");
+/**
+ * VC5C — live graduated rollout. Default ON. `MEGACOMPACT_VC5C=0` disables and
+ * is byte-identical to the predecessor (VC5B): no session is assigned a stable
+ * 10k bucket, no gate-advance decision runs, the `vector_cortex_rollout_assigned`
+ * / `vector_cortex_rollout_promotion_blocked` events are never emitted, and the
+ * prompt continues to be built by the predecessor VC5B renderer path (its goldens
+ * are unchanged). The assign/gate/emit functions are PURE — flag OFF gates the
+ * reporter + dashboard seam, never the arithmetic. This flag MUST also be a
+ * dashboard SETTINGS toggle (visible in config UI, never in EXCLUDED_SETTINGS),
+ * mirroring VC4A/VC4B/VC4C/VC5A/VC5B.
+ */
+export const VC5C_ENABLED = () => sprintFlag("MEGACOMPACT_VC5C");
 // ---------------------------------------------------------------------------
 // Breaker state machine constants (TRIAD_RESILIENCE.md §breaker).
 // Rolled numbers for one 60s window; VC0C consumes these at its breaker seam.

package/dist/src/config.js

@@ -114,4 +114,4 @@ export const NEW_UI = () => ragEnabled("MEGACOMPACT_NEW_UI");
 // default ON, `=0`/`_DISABLED` off. Re-exported from src/config/vector-cortex.ts
 // so root consumers share one source of truth.
 // ---------------------------------------------------------------------------
-export { VC0A_ENABLED, VC0B_ENABLED, VC1A_ENABLED, VC0C_ENABLED, VC1B_ENABLED, VC1C_ENABLED, VC2A_ENABLED, VC2B_ENABLED, VC2C_ENABLED, VC3A_ENABLED, VC3B_ENABLED, VC3C_ENABLED, VC4A_ENABLED, VC4B_ENABLED, VC4C_ENABLED, VC5A_ENABLED, VC5B_ENABLED, BREAKER_WINDOW_MS, BREAKER_MIN_ATTEMPTS, BREAKER_PERF_FAILURES, BREAKER_PERF_FAILURE_RATE, BREAKER_CORRECTNESS_FAILURES, BREAKER_COOLDOWN_MS, BREAKER_PROBE_COUNT, BREAKER_RETRY_BASE_MS, BREAKER_RETRY_CAP_MS, BREAKER_RETRY_JITTER, BREAKER_HYSTERESIS_FAILURE_RATE, BREAKER_HYSTERESIS_BUDGET_P95_MS, BREAKER_MIN_HEALTHY_RESIDENCE_MS, } from "./config/vector-cortex.js";
+export { VC0A_ENABLED, VC0B_ENABLED, VC1A_ENABLED, VC0C_ENABLED, VC1B_ENABLED, VC1C_ENABLED, VC2A_ENABLED, VC2B_ENABLED, VC2C_ENABLED, VC3A_ENABLED, VC3B_ENABLED, VC3C_ENABLED, VC4A_ENABLED, VC4B_ENABLED, VC4C_ENABLED, VC5A_ENABLED, VC5B_ENABLED, VC5C_ENABLED, BREAKER_WINDOW_MS, BREAKER_MIN_ATTEMPTS, BREAKER_PERF_FAILURES, BREAKER_PERF_FAILURE_RATE, BREAKER_CORRECTNESS_FAILURES, BREAKER_COOLDOWN_MS, BREAKER_PROBE_COUNT, BREAKER_RETRY_BASE_MS, BREAKER_RETRY_CAP_MS, BREAKER_RETRY_JITTER, BREAKER_HYSTERESIS_FAILURE_RATE, BREAKER_HYSTERESIS_BUDGET_P95_MS, BREAKER_MIN_HEALTHY_RESIDENCE_MS, } from "./config/vector-cortex.js";

package/dist/src/vector-cortex/rollout/_acceptance-fixture.js

@@ -0,0 +1,55 @@
+/**
+ * rollout/_acceptance-fixture.ts — conformance fixture I/O for VC5C rollout
+ * acceptance rows.
+ *
+ * Reads the v2 conformance manifest + the per-sprint rollout fixture files, and
+ * exposes the `RolloutFx` shape the acceptance aggregator drives. No
+ * mocks/stubs: the fixtures are the committed canonical corpus.
+ */
+import { readFileSync, existsSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import assert from "node:assert/strict";
+const HERE = dirname(fileURLToPath(import.meta.url));
+function repoRoot(from) {
+    let dir = from;
+    for (let i = 0; i < 8; i++) {
+        if (existsSync(join(dir, "conformance", "vector-cortex")))
+            return dir;
+        const next = dirname(dir);
+        if (next === dir)
+            break;
+        dir = next;
+    }
+    throw new Error("conformance corpus not found above " + from);
+}
+export const REPO_ROOT = repoRoot(HERE);
+export const V2 = join(REPO_ROOT, "conformance", "vector-cortex", "v2");
+export function readManifest() {
+    return JSON.parse(readFileSync(join(V2, "manifest.json"), "utf8"));
+}
+function readFixture(id, prefix) {
+    const m = readManifest();
+    const row = m.fixtures.find((f) => f.id === id && f.path.startsWith(`${prefix}/`));
+    assert.ok(row, `fixture ${id} registered under ${prefix}/ in manifest`);
+    return JSON.parse(readFileSync(join(V2, row.path), "utf8"));
+}
+export function rolloutFixture(id) {
+    return readFixture(id, "rollout");
+}
+/** Flag-pinned wrapper: VC5C gated by MEGACOMPACT_VC5C (defaults ON). */
+export function withFlagsOn(fn) {
+    return () => {
+        const saved = process.env.MEGACOMPACT_VC5C;
+        process.env.MEGACOMPACT_VC5C = "1";
+        try {
+            fn();
+        }
+        finally {
+            if (saved === undefined)
+                delete process.env.MEGACOMPACT_VC5C;
+            else
+                process.env.MEGACOMPACT_VC5C = saved;
+        }
+    };
+}

package/dist/src/vector-cortex/rollout/_acceptance-helpers.js

@@ -0,0 +1,8 @@
+/**
+ * rollout/_acceptance-helpers.ts — pure barrel re-export of the VC5C rollout
+ * acceptance helpers (fixture I/O + REAL runner). Mirrors the render family's
+ * delegate-shell split so the aggregator stays under the 600-line test hard
+ * limit.
+ */
+export { REPO_ROOT, V2, readManifest, rolloutFixture, withFlagsOn, } from "./_acceptance-fixture.js";
+export { runRolloutScenario } from "./_acceptance-scenario.js";

package/dist/src/vector-cortex/rollout/_acceptance-scenario.js

@@ -0,0 +1,70 @@
+/**
+ * rollout/_acceptance-scenario.ts — the REAL rollout runner for VC5C acceptance
+ * rows. Drives `assignSession` + `decideGate` (no mocks) against the fixture
+ * `input` and returns the result fields the fixture's `expected` block pins.
+ *
+ * Fake clocks: the gate scenario accepts an injected monotonic clock so the
+ * spec's unique failure injection (restart at 71h59m with a wall-clock jump +1d
+ * but monotonic unchanged) is reproducible. The wall-clock jump is irrelevant to
+ * the safety decision because eligibility uses the MONOTONIC delta only.
+ */
+import { assignSession } from "./assign.js";
+import { decideGate, } from "./gate.js";
+const GATE_MIN_ELAPSED_MS = 72 * 60 * 60 * 1000;
+/** Fixed monotonic clock: elapsed = now - windowStart (the only driver). */
+function clockAt(elapsedMs, windowStartMs) {
+    return {
+        now: () => windowStartMs + elapsedMs, // monotonic delta is the truth
+        wallNow: () => new Date(1_700_000_000_000 + elapsedMs).toISOString(),
+    };
+}
+/** Run a rollout fixture through the REAL assign + gate pipeline. */
+export function runRolloutScenario(fx) {
+    const scenario = fx.input.scenario;
+    if (scenario === "assign-stable") {
+        const a = assignSession(fx.input.sessionId ?? "");
+        const b = assignSession(fx.input.sessionId ?? "");
+        // Determinism: recomputing yields the identical bucket.
+        if (a.bucket !== b.bucket) {
+            return { ok: false };
+        }
+        return { ok: true, bucket: a.bucket };
+    }
+    if (scenario === "gate-power" || scenario === "gate-safety") {
+        const ev = fx.input.evidence ?? {};
+        const windowStartMs = ev.windowStartMs ?? 0;
+        const hardFaults = (ev.hardFaults ?? []).map((f) => ({ kind: f.kind, detail: f.detail }));
+        const evidence = {
+            windowStartMs,
+            powered: ev.powered ?? false,
+            events: ev.events ?? 0,
+            sessions: ev.sessions ?? 0,
+            hardFaults,
+        };
+        // The spec's unique failure injection: wall-clock jump is irrelevant; only the
+        // monotonic elapsed drives eligibility. For the 71h59m row we pass 71h59m; for
+        // the wall-jump row we pass the SAME monotonic elapsed (so it must stay blocked);
+        // for the >=72h row we pass a full 72h+ monotonic delta (so it advances).
+        const start = fx._monotonicElapsedMs;
+        const elapsedMs = start ?? GATE_MIN_ELAPSED_MS; // default: a full 72h window
+        const clock = clockAt(elapsedMs, windowStartMs);
+        // gate-safety with a hard fault forces pre-VC + freezes promotion regardless of
+        // the monotonic window; the gate index stays at the input's prior gate (0 here).
+        if (scenario === "gate-safety") {
+            const outcome = decideGate(0, evidence, clock);
+            return {
+                ok: true,
+                gateIndex: outcome.gateIndex,
+                promotionBlocked: outcome.promotionBlocked,
+                selectsPreVc: outcome.promotionBlocked,
+            };
+        }
+        const outcome = decideGate(0, evidence, clock);
+        return {
+            ok: true,
+            gateIndex: outcome.gateIndex,
+            promotionBlocked: outcome.promotionBlocked,
+        };
+    }
+    throw new Error(`unknown rollout scenario: ${scenario}`);
+}

package/dist/src/vector-cortex/rollout/assign.js

@@ -0,0 +1,56 @@
+/**
+ * vector-cortex/rollout/assign.ts — deterministic stable-bucket assignment.
+ *
+ * `assignSession(sessionId)` hashes a session id into one of 10,000 stable
+ * buckets (0..9999). The assignment is a PURE function of the session id and
+ * NEVER changes across process restart: it uses a fixed-seed FNV-1a over the
+ * session id bytes, never Date.now / Math.random (PREVENT-PI-004-adjacent
+ * determinism contract; the spec's restart-invariance requirement).
+ *
+ * A bucket `b` is "in" gate `g` (one of [1,5,25,50,100]) iff
+ * `b < g * 100`. So gate 1% covers buckets 0..99, gate 100% covers 0..9999.
+ *
+ * Pure: no I/O, no clock, no network. PREVENT-011: no `any`.
+ */
+import { ROLLOUT_BUCKETS, ROLLOUT_GATES, } from "./types.js";
+/**
+ * Deterministic 32-bit FNV-1a over the session id (UTF-8 bytes). Fixed seed
+ * (2166136261) — restart-invariant by construction. Returns a bucket in
+ * 0..(ROLLOUT_BUCKETS-1).
+ */
+export function assignSession(sessionId) {
+    const enc = new TextEncoder();
+    const bytes = enc.encode(sessionId);
+    let hash = 0x811c9dc5; // FNV offset basis (32-bit)
+    for (let i = 0; i < bytes.length; i++) {
+        hash ^= bytes[i];
+        // hash *= 16777619 (FNV prime) with 32-bit overflow wrap.
+        hash = Math.imul(hash, 0x01000193);
+    }
+    const bucket = (hash >>> 0) % ROLLOUT_BUCKETS;
+    // The bucket's qualifying gate is the HIGHEST gate whose bound it falls under.
+    let gateIndex = 0;
+    for (let i = 0; i < ROLLOUT_GATES.length; i++) {
+        if (bucket < ROLLOUT_GATES[i] * 100) {
+            gateIndex = i;
+            break;
+        }
+    }
+    return {
+        schema: "rollout-assignment-v1",
+        sessionId,
+        bucket,
+        gateIndex,
+    };
+}
+/**
+ * Whether a bucket qualifies for a given gate percentage. Used by the live seam
+ * to decide whether a session's bucket is currently exposed to the VC path.
+ */
+export function bucketInGate(bucket, gatePct) {
+    return bucket < gatePct * 100;
+}
+/** Current gate percentage for a gate index. */
+export function gatePctForIndex(gateIndex) {
+    return ROLLOUT_GATES[gateIndex];
+}

package/dist/src/vector-cortex/rollout/emit.js

@@ -0,0 +1,50 @@
+/**
+ * vector-cortex/rollout/emit.ts — VC5C rollout emit seam.
+ *
+ * The structured-event surface for the live graduated rollout: assignment and
+ * promotion-blocked observability. Mirrors the VC0C resilience emit seam and
+ * the VC0B replay emit seam: the same injected `(event, fields)` callback, the
+ * same non-fatal `safe()` best-effort wrapper, and the same per-call
+ * `VC5C_ENABLED()` gate. Absent emitter (or flag OFF) degrades to a no-op with
+ * byte-identical predecessor behavior (PREVENT-PI-004, structured `ts`+`event`).
+ *
+ * Carries exactly the two events the sprint names:
+ *   - vector_cortex_rollout_assigned         (a session was assigned a bucket)
+ *   - vector_cortex_rollout_promotion_blocked (a hard fault froze promotion)
+ */
+import { VC5C_ENABLED } from "../../config/vector-cortex.js";
+function safe(fn) {
+    return (event, fields) => {
+        try {
+            fn(event, fields);
+        }
+        catch {
+            /* non-fatal observability — never break the agent loop */
+        }
+    };
+}
+/**
+ * Build a typed reporter over an injected emit callback. Emission is gated on
+ * `VC5C_ENABLED()` — flag OFF (or absent emitter) means zero rollout
+ * observability writes (pre-VC predecessor parity). The flag is read per-call so
+ * a live toggle takes effect immediately.
+ */
+export function createRolloutReporter(emit) {
+    const fire = safe((event, fields) => {
+        if (VC5C_ENABLED())
+            emit?.(event, fields);
+    });
+    return {
+        assigned(fields) {
+            fire("vector_cortex_rollout_assigned", fields);
+        },
+        promotionBlocked(fields) {
+            fire("vector_cortex_rollout_promotion_blocked", fields);
+        },
+    };
+}
+/** Export the event names for consumers that match on them. */
+export const ROLLOUT_EVENT_NAMES = [
+    "vector_cortex_rollout_assigned",
+    "vector_cortex_rollout_promotion_blocked",
+];

package/dist/src/vector-cortex/rollout/gate.js

@@ -0,0 +1,75 @@
+/**
+ * vector-cortex/rollout/gate.ts — monotonic graduated-gate advance decision.
+ *
+ * A gate advances exactly ONE step only when ALL conjuncts hold:
+ *   (elapsedWallClock >= 72h)  — measured on the MONOTONIC clock, not wall time
+ *   AND (powered sample available)
+ *   AND (events >= 10000)
+ *   AND (sessions >= 200)
+ *
+ * Promotion is strictly monotonic by one gate step. The unique failure
+ * injection (TRIAD_RESILIENCE.md): a wall-clock jump while the monotonic clock
+ * is unchanged does NOT advance — because the 72h eligibility is the MONOTONIC
+ * delta, not wall time. We therefore take an injected clock seam with SEPARATE
+ * monotonic and wall readings and never call Date.now() directly for the safety
+ * decision (PREVENT decorum: the host injects a testable fake clock).
+ *
+ * Pure arithmetic over injected evidence + clock; no I/O, no network.
+ * PREVENT-011: no `any`.
+ */
+import { ROLLOUT_GATES, } from "./types.js";
+/** The 72h monotonic residency requirement (milliseconds). */
+export const GATE_MIN_ELAPSED_MS = 72 * 60 * 60 * 1000;
+/** Powered-sample availability gate (minimum events for a one-sided CI read). */
+export const GATE_MIN_EVENTS = 10_000;
+/** Minimum distinct sessions before a gate may advance. */
+export const GATE_MIN_SESSIONS = 200;
+/** Default clock: real monotonic (performance.now) + wall (ISO). */
+export function defaultClock() {
+    return {
+        now: () => performance.now(),
+        wallNow: () => new Date().toISOString(),
+    };
+}
+/**
+ * Decide the next live outcome for a decision epoch. Returns the (possibly
+ * advanced) gate index + the full evidence snapshot. Promotion monotonic by one
+ * step; a hard fault freezes promotion (promotionBlocked=true) and is reported
+ * for C-selection by the live seam.
+ *
+ * @param currentGate the gate index BEFORE this decision (0..4).
+ * @param evidence the observed window evidence.
+ * @param clock the injected monotonic/wall clock seam.
+ */
+export function decideGate(currentGate, evidence, clock) {
+    const elapsedMs = Math.max(0, clock.now() - evidence.windowStartMs);
+    const hardFault = evidence.hardFaults.length > 0;
+    const eligible = !hardFault &&
+        currentGate < (ROLLOUT_GATES.length - 1) &&
+        elapsedMs >= GATE_MIN_ELAPSED_MS &&
+        evidence.powered &&
+        evidence.events >= GATE_MIN_EVENTS &&
+        evidence.sessions >= GATE_MIN_SESSIONS;
+    // Monotonic by ONE step only.
+    const nextGate = eligible
+        ? (currentGate + 1)
+        : currentGate;
+    return {
+        schema: "live-outcome-v1",
+        gateIndex: nextGate,
+        gatePct: ROLLOUT_GATES[nextGate],
+        elapsedMs,
+        powered: evidence.powered,
+        events: evidence.events,
+        sessions: evidence.sessions,
+        promotionBlocked: hardFault,
+        decidedAt: clock.wallNow(),
+    };
+}
+/**
+ * Whether a hard fault should SELECT triad C (pre-VC path). Any hard causal/
+ * tool/anchor/exact failure does. Exposed so the live seam can branch cleanly.
+ */
+export function selectsPreVcPath(fault) {
+    return fault !== undefined;
+}

package/dist/src/vector-cortex/rollout/types.js

@@ -0,0 +1,39 @@
+/**
+ * vector-cortex/rollout/types.ts — VC5C live graduated-rollout contracts.
+ *
+ * A session is deterministically hashed into one of 10,000 stable buckets
+ * (0..9999). The current rollout gate is one of 1% / 5% / 25% / 50% / 100%.
+ * A bucket is "in" the current gate iff `bucket < gatePct * 100`. Assignment is
+ * a PURE function of the session id: it NEVER changes across process restart
+ * (no Date.now / Math.random — see `assign.ts`).
+ *
+ * Pure types + registered conformance IDs: no storage, no console, no network
+ * (PREVENT-PI-004 / PREVENT-011).
+ */
+/** Total stable buckets. Reassignment on restart is impossible by construction. */
+export const ROLLOUT_BUCKETS = 10_000;
+/**
+ * The five graduated gates, in promotion order. Index = step. Promotion is
+ * strictly monotonic by ONE step (never skipping a gate).
+ */
+export const ROLLOUT_GATES = [1, 5, 25, 50, 100];
+/**
+ * The two conformance events VC5C emits to the monitoring/events path. Mirrors
+ * how prior sprints emit (resilience/emit.ts, render/emit.ts).
+ */
+export const ROLLOUT_EVENTS = [
+    "vector_cortex_rollout_assigned",
+    "vector_cortex_rollout_promotion_blocked",
+];
+/**
+ * Registered rollout conformance ID range (ROL-001..020). The acceptance
+ * aggregator reads these rows from the v2 manifest and asserts each returns its
+ * manifest `ok`/`code`.
+ */
+export const ROL_IDS = Array.from({ length: 20 }, (_v, i) => `ROL-${String(i + 1).padStart(3, "0")}`);
+/** Named VC5C rollout conformance assertions (the sprint's headline rows). */
+export const ROL_NAMED_IDS = [
+    "ROL-BUCKET-001",
+    "ROL-POWER-002",
+    "ROL-SAFETY-003",
+];