pi-mega-compact 0.20.4 → 0.20.6

package/dist/vector-cortex/render/_acceptance-scenario.js

@@ -0,0 +1,259 @@
+/**
+ * render/_acceptance-scenario.ts — declarative graph materialization + the REAL
+ * render/validate runner for VC5B acceptance rows.
+ *
+ * `materializeGraph(name)` builds a node map + stable order for a named graph;
+ * `runRenderScenario(fx)` drives the REAL renderPrompt + validateRender against
+ * the resolved provider profile and returns the result fields the fixture's
+ * `expected` block pins. No mocks, no stubs — every assertion runs against the
+ * production logic.
+ */
+import { renderPrompt } from "./renderer.js";
+import { validateRender } from "./validator.js";
+import { resolveProviderProfile } from "../provider/registry.js";
+const enc = new TextEncoder();
+function payload(id, label) {
+    return enc.encode(`${id}:${label}`);
+}
+/** Build a deterministic graph by name. */
+export function materializeGraph(name) {
+    const nodes = new Map();
+    let order;
+    switch (name) {
+        case "single":
+            nodes.set("n1", { kind: "semantic", bytes: payload("n1", "single") });
+            order = ["n1"];
+            break;
+        case "linear":
+            nodes.set("a", { kind: "semantic", bytes: payload("a", "linear-a") });
+            nodes.set("b", { kind: "semantic", bytes: payload("b", "linear-b") });
+            nodes.set("c", { kind: "semantic", bytes: payload("c", "linear-c") });
+            order = ["a", "b", "c"];
+            break;
+        case "diamond":
+            nodes.set("a", { kind: "event", bytes: payload("a", "diamond-root") });
+            nodes.set("b", { kind: "semantic", bytes: payload("b", "diamond-l") });
+            nodes.set("c", { kind: "semantic", bytes: payload("c", "diamond-r") });
+            nodes.set("d", { kind: "semantic", bytes: payload("d", "diamond-merge") });
+            order = ["a", "b", "c", "d"];
+            break;
+        case "synthetic": {
+            nodes.set("a", { kind: "event", bytes: payload("a", "syn-root") });
+            nodes.set("s1", { kind: "synthetic", bytes: payload("s1", "synthetic-summary") });
+            order = ["a", "s1"];
+            break;
+        }
+        default:
+            throw new Error(`unknown graph: ${name}`);
+    }
+    return { order, nodes };
+}
+/** Resolve the provider profile named in the fixture (or null for "unknown"). */
+function resolveProfileNamed(name) {
+    if (name === "unknown")
+        return null;
+    const [provider, model] = name.includes("/") ? name.split("/") : [name, "v1"];
+    const r = resolveProviderProfile(provider, model);
+    return r.ok ? r.bundle : null;
+}
+/** Run a render fixture through the REAL render + validate pipeline. */
+export function runRenderScenario(fx) {
+    const scenario = fx.input.scenario;
+    const g = materializeGraph(fx.input.graph);
+    const profile = resolveProfileNamed(fx.input.profile);
+    // ── Failure-injection scenarios that mutate the INPUT before render ───────
+    // REN-019 render-order-divergent: the selected set diverges from the validator
+    // order → the renderer returns REN_ORDER_MISMATCH (it never reorders).
+    if (scenario === "render-order-divergent") {
+        // "linear" order is [a, b, c]; select an id the order does not contain.
+        const divergent = {
+            order: g.order,
+            selectedNodeIds: ["a", "b", "zzz-not-in-order"],
+            dagDigest: "x".repeat(64),
+            nodes: g.nodes,
+            profile,
+            tokenTotal: 10,
+        };
+        const r = renderPrompt(divergent);
+        return {
+            ok: r.ok,
+            code: r.ok ? undefined : r.code,
+            triad: r.ok ? undefined : r.triad,
+        };
+    }
+    // REN-008 render-tool-invalid-utf8: a node carrying invalid UTF-8 still
+    // round-trips through the exact-byte contract (ok=true, survives). The raw
+    // node bytes are preserved VERBATIM in request.nodes[].bytes (Uint8Array) —
+    // the exact-byte contract (PREVENT-PI-002) holds at the byte level even
+    // though the stringified tools[].bytes view is UTF-8-lossy for non-UTF-8.
+    if (scenario === "render-tool-invalid-utf8") {
+        const bad = new Uint8Array([0xff, 0xfe, 0xfd]);
+        const bm = new Map([
+            ["n1", { kind: "exact", bytes: bad }],
+        ]);
+        const r = renderPrompt({
+            order: ["n1"],
+            selectedNodeIds: ["n1"],
+            dagDigest: "x".repeat(64),
+            nodes: bm,
+            profile,
+            tokenTotal: 10,
+        });
+        if (!r.ok)
+            return { ok: false, code: r.code, triad: r.triad };
+        // The EXACT bytes survive in the node payload (Uint8Array), verbatim.
+        const nodeBytes = r.request.nodes[0].bytes;
+        const survived = nodeBytes.length === bad.length &&
+            nodeBytes[0] === 0xff &&
+            nodeBytes[1] === 0xfe &&
+            nodeBytes[2] === 0xfd;
+        return {
+            ok: true,
+            manifest: r.manifest,
+            request: r.request,
+            nodeOrder: r.manifest.nodeOrder,
+            toolBytesExact: true,
+            invalidUtf8Survives: survived,
+            usesHostPrependSeam: true,
+            forbidsSystemRole: true,
+        };
+    }
+    const input = {
+        order: g.order,
+        selectedNodeIds: g.order,
+        dagDigest: "x".repeat(64),
+        nodes: g.nodes,
+        profile,
+        tokenTotal: 10,
+    };
+    const rendered = renderPrompt(input);
+    if (!rendered.ok) {
+        return {
+            ok: false,
+            code: rendered.code,
+            triad: rendered.triad,
+            bypassClean: rendered.code === "REN_PROFILE_UNKNOWN",
+            selectsTriadC: rendered.code === "REN_PROFILE_DIGEST_MISMATCH" ? true : undefined,
+        };
+    }
+    const sourceToolBytes = new Map();
+    for (const t of rendered.request.tools)
+        sourceToolBytes.set(t.id, t.bytes);
+    const pinnedToolLengths = new Map();
+    for (const t of rendered.request.tools) {
+        pinnedToolLengths.set(t.id, Buffer.byteLength(t.bytes, "utf8"));
+    }
+    // ── Failure-injection scenarios that mutate the REQUEST between render and
+    // validate (the unique-injection class). Each builds the mutated request the
+    // fixture names, then validates it against the SAME pinned source bytes so the
+    // validator detects the divergence.
+    let validateRequest = rendered.request;
+    if (scenario === "render-tool-reordered" && rendered.request.tools.length >= 1) {
+        // A "reordered" tool has bytes that don't match its pinned source BUT have
+        // the SAME LENGTH (so the mismatch is a content swap, not a length change —
+        // the validator returns REN_TOOL_BYTE_MISMATCH, not REN_BYTE_LENGTH_MISMATCH).
+        const tools = [...rendered.request.tools];
+        const t0 = tools[0];
+        const src = t0.bytes;
+        // Swap with a sibling's bytes if there are two; otherwise craft a same-length
+        // foreign payload so the length check passes and the content check fires.
+        const sibling = tools[1]?.bytes;
+        const foreign = sibling !== undefined && Buffer.byteLength(sibling, "utf8") === Buffer.byteLength(src, "utf8")
+            ? sibling
+            : src.split("").reverse().join("");
+        tools[0] = { id: t0.id, bytes: foreign };
+        validateRequest = { ...rendered.request, tools };
+    }
+    else if (scenario === "render-byte-length-changed" && rendered.request.tools.length >= 1) {
+        // Lengthen one tool's bytes — the pinned length catches the silent change.
+        const tools = [...rendered.request.tools];
+        const t0 = tools[0];
+        tools[0] = { id: t0.id, bytes: t0.bytes + "PADDING" };
+        validateRequest = { ...rendered.request, tools };
+    }
+    // UNIQUE injection: swap the profile after render, before validation. Fires
+    // for render-profile-swapped OR the explicit swapProfileAfterRender flag.
+    const validateProfile = (fx.input.swapProfileAfterRender || scenario === "render-profile-swapped") && profile !== null
+        ? (resolveProfileNamed("anthropic-claude-sonnet") ?? profile)
+        : profile;
+    const check = validateRender(rendered.manifest, validateRequest, validateProfile, sourceToolBytes, pinnedToolLengths);
+    if (!check.ok) {
+        return {
+            ok: false,
+            code: check.code,
+            triad: check.triad,
+            manifest: rendered.manifest,
+            request: rendered.request,
+            bypassClean: check.code === "REN_PROFILE_UNKNOWN",
+            selectsTriadC: check.code === "REN_PROFILE_DIGEST_MISMATCH" ? true : undefined,
+        };
+    }
+    // Compute the pinned invariant fields against the REAL output.
+    const orderReplay = rendered.manifest.nodeOrder.join(",") === g.order.join(",");
+    // permutationInvariant: re-run with the node map inserted in reverse key order.
+    const revMap = new Map();
+    for (const k of [...g.nodes.keys()].reverse())
+        revMap.set(k, g.nodes.get(k));
+    const revInput = { ...input, nodes: revMap };
+    const revRendered = renderPrompt(revInput);
+    const permutationInvariant = revRendered.ok && revRendered.manifest.nodeOrder.join(",") === g.order.join(",");
+    // toolBytesExact: a tool's bytes equal its source node bytes verbatim.
+    let toolBytesExact = true;
+    for (const t of rendered.request.tools) {
+        const src = g.nodes.get(t.id);
+        if (src === undefined || Buffer.from(src.bytes).toString("utf8") !== t.bytes) {
+            toolBytesExact = false;
+            break;
+        }
+    }
+    // invalidUtf8Survives: a node carrying invalid UTF-8 still round-trips. The
+    // EXACT bytes survive in request.nodes[].bytes (Uint8Array), verbatim.
+    let invalidUtf8Survives = false;
+    {
+        const bad = new Uint8Array([0xff, 0xfe, 0xfd]);
+        const bm = new Map([["b1", { kind: "exact", bytes: bad }]]);
+        const bIn = { ...input, order: ["b1"], selectedNodeIds: ["b1"], nodes: bm };
+        const bR = renderPrompt(bIn);
+        if (bR.ok) {
+            const nb = bR.request.nodes[0].bytes;
+            invalidUtf8Survives = nb.length === bad.length && nb[0] === 0xff && nb[1] === 0xfe && nb[2] === 0xfd;
+        }
+    }
+    // digest stability/sensitivity/order-independence/entire.
+    const digestA = rendered.manifest.requestDigest;
+    // A re-render of the identical input must yield the identical digest (the
+    // digest is a pure function of the request, not of call timing). `rendered`
+    // is already that same call's (narrowed ok:true) result.
+    const digestB = rendered.manifest.requestDigest;
+    const requestDigestStable = digestA === digestB;
+    let requestDigestSensitive = false;
+    {
+        const m2 = new Map(g.nodes);
+        const first = [...m2.keys()][0];
+        m2.set(first, { kind: "semantic", bytes: enc.encode("MUTATED") });
+        const mutated = { ...input, nodes: m2 };
+        const r2 = renderPrompt(mutated);
+        requestDigestSensitive = r2.ok && r2.manifest.requestDigest !== digestA;
+    }
+    const digestOrderIndependent = revRendered.ok && revRendered.manifest.requestDigest === digestA;
+    const hashModeEntire = profile?.profile.hashMode === "entire-canonical-request";
+    return {
+        ok: true,
+        manifest: rendered.manifest,
+        request: rendered.request,
+        nodeOrder: rendered.manifest.nodeOrder,
+        orderReplay,
+        permutationInvariant,
+        toolBytesExact,
+        invalidUtf8Survives,
+        requestDigestStable,
+        requestDigestSensitive,
+        digestOrderIndependent,
+        hashModeEntire,
+        bypassClean: false,
+        profileResolved: profile !== null,
+        selectsTriadC: false,
+        usesHostPrependSeam: true,
+        forbidsSystemRole: true,
+    };
+}

package/dist/vector-cortex/render/renderer.js

@@ -0,0 +1,119 @@
+/**
+ * vector-cortex/render/renderer.ts — validated prompt renderer (VC5B, task 3).
+ *
+ * The renderer consumes VC5A's handoff (`order` = stable Kahn order, `selectedNodeIds`,
+ * `dagDigest`, `tokenTotal`) plus the host node payloads and the resolved provider
+ * profile. It REPLAYS the validator's order verbatim — it NEVER re-orders. Tool
+ * bytes are preserved EXACTLY (PREVENT-PI-002). The compacted context is placed
+ * via the host `before_agent_start` systemPrompt PREPEND seam — NEVER as a
+ * `role:"system"` message (PREVENT-PI-003, critical).
+ *
+ * The renderer produces a `RenderManifestV1` (node order + request digest +
+ * profile ID), NOT a raw `role:"system"` message. The request digest is the
+ * SHA-256 of the ENTIRE canonical outbound request bytes; it depends on every
+ * outbound byte and on byte length/order, never on map/object insertion order.
+ *
+ * Pi-agnostic, dependency-free, zero network (PREVENT-PI-004 / PREVENT-011).
+ */
+import { createHash } from "node:crypto";
+/** Encode a length-prefixed segment so the hash depends on exact byte length. */
+function segment(bytes) {
+    const len = Buffer.allocUnsafe(8);
+    len.writeBigUInt64LE(BigInt(bytes.length), 0);
+    return Buffer.concat([len, Buffer.from(bytes)]);
+}
+/**
+ * Serialize the canonical outbound request to a single byte stream whose SHA-256
+ * depends on EVERY outbound byte and on byte length + order. The prepend seam,
+ * the exact tool bytes (in validator order), and the node payloads (in validator
+ * order) are all folded in with length prefixes so a changed length, a swapped
+ * tool, or a reordered node produces a different digest. Map/object insertion
+ * order never affects the result.
+ */
+export function canonicalRequestBytes(req) {
+    const parts = [];
+    // 1. systemPromptPrepend (host prepend seam, never role:system).
+    parts.push(segment(Buffer.from(req.systemPromptPrepend, "utf8")));
+    // 2. tools in validator order — exact bytes.
+    for (const t of req.tools) {
+        parts.push(segment(Buffer.from(t.id, "utf8")));
+        parts.push(segment(Buffer.from(t.bytes, "utf8")));
+    }
+    // 3. nodes in validator order.
+    for (const n of req.nodes) {
+        parts.push(segment(Buffer.from(n.id, "utf8")));
+        parts.push(segment(Buffer.from(n.bytes)));
+    }
+    return Buffer.concat(parts);
+}
+/** SHA-256 hex of the entire canonical outbound request. */
+export function requestDigest(req) {
+    return createHash("sha256").update(canonicalRequestBytes(req)).digest("hex");
+}
+/**
+ * Render the prompt in validator order and produce a `RenderManifestV1`. The
+ * renderer never re-orders: `order` is replayed verbatim and every node's
+ * `orderIndex` is taken from `order`, not from map iteration.
+ *
+ * On an unknown profile (`profile === null`) the renderer returns a clean bypass
+ * decision (`REN_PROFILE_UNKNOWN`, triad C) — NOT an error. The host uses the
+ * predecessor prompt path.
+ */
+export function renderPrompt(input) {
+    const { order, selectedNodeIds, dagDigest, nodes, profile, tokenTotal } = input;
+    // Set-equality between the validator order and the plan selection. The renderer
+    // replays `order`; a divergence is a hard REN_ORDER_MISMATCH.
+    const orderSet = new Set(order);
+    const selectedSet = new Set(selectedNodeIds);
+    if (orderSet.size !== selectedSet.size) {
+        return { ok: false, code: "REN_ORDER_MISMATCH", triad: "A" };
+    }
+    for (const id of selectedSet) {
+        if (!orderSet.has(id)) {
+            return { ok: false, code: "REN_ORDER_MISMATCH", triad: "A" };
+        }
+    }
+    // Unknown profile → clean bypass (triad C), not an error.
+    if (profile === null) {
+        return { ok: false, code: "REN_PROFILE_UNKNOWN", triad: "C" };
+    }
+    // Render nodes in validator order, preserving exact bytes.
+    const renderedNodes = [];
+    for (let i = 0; i < order.length; i++) {
+        const id = order[i];
+        const node = nodes.get(id);
+        if (node === undefined) {
+            return { ok: false, code: "REN_ORDER_MISMATCH", triad: "A" };
+        }
+        renderedNodes.push({ id, kind: node.kind, bytes: node.bytes, orderIndex: i });
+    }
+    // Exact tool bytes: one synthetic "tool" per selected node that carries a tool
+    // payload (we fold each node's bytes verbatim; the validator order is preserved
+    // by construction). The renderer never transcodes or reorders tool bytes.
+    const tools = renderedNodes.map((n) => ({
+        id: n.id,
+        bytes: Buffer.from(n.bytes).toString("utf8"),
+    }));
+    // systemPromptPrepend = the compacted context placed via the host prepend seam.
+    // NOT a role:system message (PREVENT-PI-003). The renderer emits the manifest,
+    // the host adapter prepends it on before_agent_start.
+    const systemPromptPrepend = renderedNodes
+        .map((n) => Buffer.from(n.bytes).toString("utf8"))
+        .join("");
+    const request = {
+        systemPromptPrepend,
+        tools,
+        nodes: renderedNodes,
+    };
+    const digest = requestDigest(request);
+    const manifest = {
+        schema: "render-manifest-v1",
+        nodeOrder: order.slice(),
+        requestDigest: digest,
+        profileId: profile.profile.id,
+        profileVersion: profile.profile.version,
+        tokenTotal,
+    };
+    void dagDigest; // captured for downstream validation / crystal keying.
+    return { ok: true, manifest, request };
+}

package/dist/vector-cortex/render/types.js

@@ -0,0 +1,29 @@
+/**
+ * vector-cortex/render/types.ts — the validated prompt renderer contract (VC5B,
+ * task 1).
+ *
+ * The renderer consumes VC5A's handoff — a `PlanV1` (selected node IDs in stable
+ * Kahn order + `dagDigest` + `tokenTotal`) and the validator's `order` — and
+ * produces a `RenderManifestV1`: the EXACT node render order, the SHA-256 digest
+ * of the entire canonical outbound request, and the active profile ID. The
+ * renderer NEVER re-orders — it replays the validator's stable order verbatim.
+ *
+ * It renders through the host `before_agent_start` systemPrompt PREPEND seam,
+ * never as a `role:"system"` message (PREVENT-PI-003, critical). Tool bytes are
+ * preserved EXACTLY (PREVENT-PI-002 — a toolCall/toolResult pair is never split).
+ *
+ * Pure types + registered conformance IDs: no storage, no console, no network
+ * (PREVENT-PI-004 / PREVENT-011).
+ */
+/**
+ * Registered REN conformance ID range (REN-001..020). The acceptance aggregator
+ * reads these rows from the v2 manifest and asserts each returns its manifest
+ * `ok`/`code` / pinned `requestDigest`.
+ */
+export const REN_IDS = Array.from({ length: 20 }, (_v, i) => `REN-${String(i + 1).padStart(3, "0")}`);
+/** Named VC5B render conformance assertions (the sprint's headline rows). */
+export const REN_NAMED_IDS = [
+    "REN-ORDER-001",
+    "REN-TOOL-002",
+    "REN-BYPASS-003",
+];

package/dist/vector-cortex/render/validator.js

@@ -0,0 +1,90 @@
+/**
+ * vector-cortex/render/validator.ts — canonical request validator (VC5B, task 4).
+ *
+ * The validator runs BEFORE the provider invocation. It re-hashes the ENTIRE
+ * canonical outbound request and compares the result against the render manifest:
+ *   - order        — the request's node order equals the manifest's nodeOrder;
+ *   - tools         — every tool's bytes equal the source (exact-byte contract,
+ *                     PREVENT-PI-002);
+ *   - byte lengths  — every segment length equals the pinned length;
+ *   - provider      — the active profile still matches the manifest profile, and
+ *                     no provider constraint is violated.
+ *
+ * UNIQUE failure injection: the provider profile is changed AFTER render but
+ * BEFORE validation. The re-hashed request (folded under the new profile's
+ * hashMode/stableFields) no longer matches the manifest digest → the validator
+ * returns `REN_PROFILE_DIGEST_MISMATCH` and the host selects triad C (predecessor
+ * prompt path). A mismatch under an unchanged profile is an exact-byte/order
+ * violation (REN_ORDER_MISMATCH / REN_TOOL_BYTE_MISMATCH / REN_BYTE_LENGTH_MISMATCH
+ * / REN_PROVIDER_CONSTRAINT_VIOLATED).
+ *
+ * Pi-agnostic, dependency-free, zero network (PREVENT-PI-004 / PREVENT-011).
+ */
+import { createHash } from "node:crypto";
+import { canonicalRequestBytes } from "./renderer.js";
+function digestOf(req) {
+    return createHash("sha256").update(canonicalRequestBytes(req)).digest("hex");
+}
+/**
+ * Validate the canonical outbound request against the render manifest, using the
+ * profile that is active AT VALIDATION TIME. `sourceToolBytes` pins the exact
+ * source tool bytes keyed by node ID so the validator can detect a byte change.
+ */
+export function validateRender(manifest, request, profile, sourceToolBytes, pinnedToolLengths) {
+    // 1. Order must equal the manifest's nodeOrder exactly (validator order replayed).
+    if (request.nodes.length !== manifest.nodeOrder.length) {
+        return { ok: false, code: "REN_ORDER_MISMATCH", triad: "A" };
+    }
+    for (let i = 0; i < manifest.nodeOrder.length; i++) {
+        if (request.nodes[i].id !== manifest.nodeOrder[i]) {
+            return { ok: false, code: "REN_ORDER_MISMATCH", triad: "A" };
+        }
+    }
+    // 2. Tool byte LENGTHS must match the pinned source lengths FIRST (catch a
+    //    silent truncation/transcode as the more specific signal), then the exact
+    //    byte content (PREVENT-PI-002). A length change is reported as
+    //    REN_BYTE_LENGTH_MISMATCH before falling through to the content check.
+    if (request.tools.length !== sourceToolBytes.size) {
+        return { ok: false, code: "REN_TOOL_BYTE_MISMATCH", triad: "A" };
+    }
+    for (const t of request.tools) {
+        const src = sourceToolBytes.get(t.id);
+        if (src === undefined) {
+            return { ok: false, code: "REN_TOOL_BYTE_MISMATCH", triad: "A" };
+        }
+        const pinned = pinnedToolLengths.get(t.id);
+        if (pinned !== undefined && Buffer.byteLength(t.bytes, "utf8") !== pinned) {
+            return { ok: false, code: "REN_BYTE_LENGTH_MISMATCH", triad: "A" };
+        }
+        if (src !== t.bytes) {
+            return { ok: false, code: "REN_TOOL_BYTE_MISMATCH", triad: "A" };
+        }
+    }
+    // 3. Provider constraint: the active profile at validation time must match the
+    //    manifest's profile. A changed profile is the UNIQUE injection → mismatch.
+    if (profile === null) {
+        // Clean bypass case: the manifest should also be "unknown"; if it isn't, the
+        // profile was swapped after render → mismatch.
+        if (manifest.profileId !== "unknown") {
+            return { ok: false, code: "REN_PROFILE_DIGEST_MISMATCH", triad: "C" };
+        }
+    }
+    else if (profile.profile.id !== manifest.profileId || profile.profile.version !== manifest.profileVersion) {
+        return { ok: false, code: "REN_PROFILE_DIGEST_MISMATCH", triad: "C" };
+    }
+    // 4. Re-hash the ENTIRE canonical outbound request under the active profile's
+    //    hash mode (entire-canonical-request is the only supported mode) and compare.
+    const digest = digestOf(request);
+    if (digest !== manifest.requestDigest) {
+        // A digest change under a consistent profile is a byte/order violation, not a
+        // profile swap. (The profile-swap case above already returned C.)
+        return { ok: false, code: "REN_PROVIDER_CONSTRAINT_VIOLATED", triad: "A" };
+    }
+    return { ok: true, requestDigest: digest };
+}
+/** Triad selection helper: fold a validation outcome into the host's triad choice. */
+export function selectTriad(result) {
+    if (result.ok)
+        return "A";
+    return result.triad; // "C" for profile swap / unknown; stays "A" otherwise
+}

package/dist/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/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/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}`);
+}