pi-mega-compact 0.20.3 → 0.20.5

package/dist/src/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/src/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/src/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/src/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/provider/registry.js

@@ -0,0 +1,112 @@
+/**
+ * vector-cortex/provider/registry.ts — fixture-backed base provider profile
+ * registry (VC5B, task 2).
+ *
+ * The registry resolves a `(provider, model)` pair to a `ProviderProfileBundle`
+ * (CONTRACTS §ProviderProfileV1 + role/tool/cache rules). Unknown provider/model
+ * returns `PRO_PROFILE_UNKNOWN` and the renderer CLEANLY bypasses vector-cortex
+ * rendering (NOT an error — the host uses the predecessor prompt path).
+ *
+ * Profiles are fixture-backed: each base profile is declared here as a constant
+ * and is also pinned as a conformance fixture under `conformance/vector-cortex/v2/
+ * provider/` (registered by `scripts/gen-fixtures/provider.mjs`). The registry is
+ * the REAL resolver the acceptance suite drives; the fixtures are the committed
+ * canonical corpus that proves each profile's cache-identity behavior.
+ *
+ * Pi-agnostic, dependency-free, zero network (PREVENT-PI-004 / PREVENT-011).
+ */
+import { PRO_PROFILE_UNKNOWN, } from "./types.js";
+/** A registry key is `provider` + `model`. Lookup is exact-match. */
+function key(provider, model) {
+    return `${provider}//${model}`;
+}
+/**
+ * The base role rule every VC5B profile shares: the renderer MUST use the host
+ * `before_agent_start` prepend seam and MUST NOT inject `role:"system"`
+ * (PREVENT-PI-003, critical).
+ */
+const BASE_ROLE = {
+    useHostPrependSeam: true,
+    forbidSystemRoleInjection: true,
+};
+/**
+ * The base tool rule every VC5B profile shares: exact tool bytes preserved
+ * (PREVENT-PI-002) and the renderer never reorders away from the validator order.
+ */
+const BASE_TOOL = {
+    preserveExactToolBytes: true,
+    forbidToolReorder: true,
+};
+/** Build a base cache rule (entire-canonical-request hashing by default). */
+function baseCache(stableFields) {
+    return {
+        hashMode: "entire-canonical-request",
+        stableFields,
+    };
+}
+/** Build a contract-profile shape pinned as a conformance fixture too. */
+function profile(id, version, excludedJsonPointers) {
+    return {
+        schema: "provider-profile-v1",
+        id,
+        version,
+        hashMode: "entire-canonical-request",
+        excludedJsonPointers,
+    };
+}
+/**
+ * The fixture-backed base profiles. Each entry is the REAL bundle the renderer
+ * resolves; the parallel conformance fixtures prove the cache-identity behavior.
+ */
+const BASE_PROFILES = [
+    {
+        profile: profile("anthropic-claude-opus", "v1", []),
+        role: BASE_ROLE,
+        tool: BASE_TOOL,
+        cache: baseCache(["systemPromptPrepend", "tools", "nodes"]),
+    },
+    {
+        profile: profile("anthropic-claude-sonnet", "v1", []),
+        role: BASE_ROLE,
+        tool: BASE_TOOL,
+        cache: baseCache(["systemPromptPrepend", "tools", "nodes"]),
+    },
+    {
+        profile: profile("openai-gpt", "v1", []),
+        role: BASE_ROLE,
+        tool: BASE_TOOL,
+        cache: baseCache(["systemPromptPrepend", "tools", "nodes"]),
+    },
+    {
+        // A profile that proves a fixture-excluded pointer: a provider whose
+        // request-id header cannot affect cache identity. Excluded + versioned.
+        profile: profile("google-gemini", "v1", [
+            {
+                pointer: "/requestId",
+                fixtureId: "PRO-EXCLUDE-010",
+                proofDigest: "sha256:excluded-request-id-proof",
+            },
+        ]),
+        role: BASE_ROLE,
+        tool: BASE_TOOL,
+        cache: baseCache(["systemPromptPrepend", "tools", "nodes"]),
+    },
+];
+const REGISTRY = new Map(BASE_PROFILES.map((b) => [key(b.profile.id, b.profile.version), b]));
+/**
+ * Resolve a `(provider, model)` pair to a `ProviderProfileBundle`. Unknown
+ * provider / model / version → a CLEAN bypass (`PRO_PROFILE_UNKNOWN`), never an
+ * error. The renderer consults this and, on `ok:false`, selects triad C (the
+ * predecessor prompt path).
+ */
+export function resolveProviderProfile(provider, model) {
+    const bundle = REGISTRY.get(key(provider, model));
+    if (bundle === undefined) {
+        return { ok: false, code: PRO_PROFILE_UNKNOWN };
+    }
+    return { ok: true, bundle };
+}
+/** The fixture-backed base profiles (exposed for tests / dashboard introspection). */
+export const BASE_PROVIDER_PROFILES = BASE_PROFILES;
+/** The set of known `(provider, model)` keys, for conformance registration. */
+export const KNOWN_PROVIDER_KEYS = Array.from(REGISTRY.keys());

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

@@ -0,0 +1,30 @@
+/**
+ * vector-cortex/provider/types.ts — provider profile contract (VC5B, task 1).
+ *
+ * A `ProviderProfileV1` describes how a given provider/model caches and what the
+ * renderer may or may not fold into the outbound prompt without breaking the
+ * provider's KV-cache identity (CONTRACTS §ProviderProfileV1 + crystals).
+ *
+ * The renderer hashes the ENTIRE canonical outbound request by default
+ * (`hashMode: "entire-canonical-request"`). A profile may EXCLUDE a field only
+ * when a fixture proves that field cannot affect provider cache identity; every
+ * exclusion is versioned and listed in the manifest. Unknown provider / profile /
+ * version → the renderer bypasses vector-cortex rendering (a clean bypass, NOT an
+ * error) and the host falls back to the predecessor prompt path.
+ *
+ * Pure types + registered conformance IDs: no storage, no console, no network
+ * (PREVENT-PI-004 / PREVENT-011).
+ */
+/**
+ * The sentinel returned for an unknown provider/model. The renderer sees this as
+ * a CLEAN bypass decision, not an error, and emits `vector_cortex_provider_bypassed`.
+ */
+export const PRO_PROFILE_UNKNOWN = "PRO_PROFILE_UNKNOWN";
+/**
+ * Registered PRO conformance ID range (PRO-001..015). The acceptance aggregator
+ * reads these rows from the v2 manifest and asserts each returns its manifest
+ * `ok`/`code` / pinned `requestDigest`.
+ */
+export const PRO_IDS = Array.from({ length: 15 }, (_v, i) => `PRO-${String(i + 1).padStart(3, "0")}`);
+/** Named VC5B provider conformance assertions (the sprint's headline rows). */
+export const PRO_NAMED_IDS = ["PRO-UNKNOWN-003"];