pi-mega-compact 0.20.4 → 0.20.5

package/src/vector-cortex/provider/types.ts

@@ -0,0 +1,163 @@
+/**
+ * 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 hash mode the renderer uses for the canonical outbound request. The ONLY
+ * supported mode is hashing the entire request bytes — partial hashing is not
+ * allowed (it would let a folded field silently break cache identity).
+ */
+export type ProviderHashMode = "entire-canonical-request";
+
+/**
+ * A JSON-pointer exclusion: a documented proof that the named pointer cannot
+ * affect provider cache identity. `fixtureId` pins the conformance row that
+ * proves it; `proofDigest` is that fixture's SHA-256. Exclusions are versioned
+ * per profile and MUST be listed in the manifest (CONTRACTS §ProviderProfileV1).
+ */
+export interface ProviderProfileExclusion {
+  readonly pointer: string;
+  readonly fixtureId: string;
+  readonly proofDigest: string;
+}
+
+/**
+ * The provider-profile contract. A renderer consumes a profile to decide how the
+ * rendered prompt is serialized into the canonical outbound request without
+ * invalidating the provider's cache identity.
+ */
+export interface ProviderProfileV1 {
+  readonly schema: "provider-profile-v1";
+  readonly id: string;
+  readonly version: string;
+  readonly hashMode: ProviderHashMode;
+  /** Versioned, fixture-proven exclusions (empty = hash the whole request). */
+  readonly excludedJsonPointers: readonly ProviderProfileExclusion[];
+}
+
+/**
+ * Role rules: how the rendered context may be placed relative to the host system
+ * prompt. The renderer MUST use the host `before_agent_start` systemPrompt
+ * prepend seam — it NEVER injects compacted context as `role:"system"`
+ * (PREVENT-PI-003, critical).
+ */
+export interface ProviderRoleRule {
+  /** Always true for VC5B: placement is the host prepend seam, never role:system. */
+  readonly useHostPrependSeam: true;
+  /** A renderer MUST NOT emit a `role:"system"` message for compacted context. */
+  readonly forbidSystemRoleInjection: true;
+}
+
+/**
+ * Tool rules: the renderer preserves EXACT tool bytes (PREVENT-PI-002 — never
+ * split a toolCall/toolResult pair). A profile declares whether the provider
+ * tolerates tool reordering; VC5B renders in the validator's stable order and
+ * never reorders, so this is a validation constraint, not a permission.
+ */
+export interface ProviderToolRule {
+  /** Exact tool bytes are preserved verbatim (no normalization/transcoding). */
+  readonly preserveExactToolBytes: true;
+  /** The renderer never reorders tools away from the validator's order. */
+  readonly forbidToolReorder: true;
+}
+
+/**
+ * Cache rules: what the profile pins about provider cache identity so the
+ * renderer's canonical hash stays stable across otherwise-equivalent renders.
+ */
+export interface ProviderCacheRule {
+  /** The hash mode the renderer uses when this profile is active. */
+  readonly hashMode: ProviderHashMode;
+  /** Cache-stable fields the renderer must not reorder or drop. */
+  readonly stableFields: readonly string[];
+}
+
+/**
+ * A fully-resolved provider profile bundle: the contract plus the role/tool/cache
+ * rules the renderer enforces. The fixture-backed base registry returns these.
+ */
+export interface ProviderProfileBundle {
+  readonly profile: ProviderProfileV1;
+  readonly role: ProviderRoleRule;
+  readonly tool: ProviderToolRule;
+  readonly cache: ProviderCacheRule;
+}
+
+/**
+ * Provider profile resolution failure codes. These are NOT errors that should
+ * break the agent loop — `PRO_PROFILE_UNKNOWN` is a clean bypass signal.
+ */
+export type ProviderProfileCode =
+  /** No matching profile for the provider/model; the renderer bypasses cleanly. */
+  | "PRO_PROFILE_UNKNOWN"
+  /** A profile matched but its version is unsupported by the renderer. */
+  | "PRO_PROFILE_VERSION_UNSUPPORTED";
+
+/**
+ * The provider-profile resolution verdict. `ok:true` carries the resolved
+ * bundle; `ok:false` carries a bypass code. Every `ok:false` is a CLEAN bypass
+ * (the host uses the predecessor prompt path) — never an error.
+ */
+export type ProviderProfileResult =
+  | { readonly ok: true; readonly bundle: ProviderProfileBundle }
+  | { readonly ok: false; readonly code: ProviderProfileCode };
+
+/**
+ * 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: ProviderProfileCode = "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: readonly string[] = 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"] as const;
+
+/** Injected emit callback — same (event, fields) shape as the other VC seams. */
+export type ProviderEmitter = (
+  event: string,
+  fields: Record<string, unknown>,
+) => void;
+
+/** The two structured events the VC5B provider seam emits. */
+export type ProviderEventName =
+  | "vector_cortex_render_validated"
+  | "vector_cortex_provider_bypassed";
+
+/** Typed, best-effort reporter bound to the two provider/render event names. */
+export interface ProviderReporter {
+  readonly renderValidated: (fields: Record<string, unknown>) => void;
+  readonly providerBypassed: (fields: Record<string, unknown>) => void;
+}
+
+/**
+ * Aggregate-only provider/render metrics for the dashboard (counts only, never
+ * prompt text or node payloads).
+ */
+export interface ProviderMetricsV1 {
+  readonly rendersValidated: number;
+  readonly providersBypassed: number;
+  readonly nodesRendered: number;
+}

package/src/vector-cortex/render/_acceptance-fixture.ts

@@ -0,0 +1,128 @@
+/**
+ * render/_acceptance-fixture.ts — conformance fixture I/O for VC5B render +
+ * provider acceptance rows.
+ *
+ * Reads the v2 conformance manifest + the per-sprint fixture files, and exposes
+ * the `RenderFx` / `ProviderFx` shapes 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: string): string {
+  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 interface ManifestRow {
+  id: string;
+  path: string;
+  algorithm: string;
+  expected: string;
+}
+export interface Manifest {
+  fixtures: ManifestRow[];
+}
+
+export function readManifest(): Manifest {
+  return JSON.parse(readFileSync(join(V2, "manifest.json"), "utf8")) as Manifest;
+}
+
+function readFixture(id: string, prefix: "render" | "provider"): unknown {
+  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 interface RenderFxInput {
+  scenario: string;
+  graph: string;
+  profile: string;
+  mutateByteAfterRender?: boolean;
+  swapProfileAfterRender?: boolean;
+}
+export interface RenderFxExpected {
+  ok: boolean;
+  code?: string;
+  nodeOrder?: string[];
+  orderReplay?: boolean;
+  permutationInvariant?: boolean;
+  toolBytesExact?: boolean;
+  invalidUtf8Survives?: boolean;
+  requestDigestStable?: boolean;
+  requestDigestSensitive?: boolean;
+  digestOrderIndependent?: boolean;
+  hashModeEntire?: boolean;
+  bypassClean?: boolean;
+  profileResolved?: boolean;
+  selectsTriadC?: boolean;
+  usesHostPrependSeam?: boolean;
+  forbidsSystemRole?: boolean;
+}
+export interface RenderFx {
+  id: string;
+  schema: string;
+  producer: string;
+  assertion: string;
+  kind: string;
+  input: RenderFxInput;
+  expected: RenderFxExpected;
+}
+export function renderFixture(id: string): RenderFx {
+  return readFixture(id, "render") as RenderFx;
+}
+
+export interface ProviderFxInput {
+  scenario: string;
+  provider: string;
+  model: string;
+}
+export interface ProviderFxExpected {
+  ok: boolean;
+  code?: string;
+  profileId?: string;
+  hashMode?: string;
+  excludedPointers?: string[];
+  bypassClean?: boolean;
+  cacheStable?: boolean;
+  deterministic?: boolean;
+}
+export interface ProviderFx {
+  id: string;
+  schema: string;
+  producer: string;
+  assertion: string;
+  kind: string;
+  input: ProviderFxInput;
+  expected: ProviderFxExpected;
+}
+export function providerFixture(id: string): ProviderFx {
+  return readFixture(id, "provider") as ProviderFx;
+}
+
+/** Flag-pinned wrapper: VC5B gated by MEGACOMPACT_VC5B (defaults ON). */
+export function withFlagsOn(fn: () => void): () => void {
+  return (): void => {
+    const saved = process.env.MEGACOMPACT_VC5B;
+    process.env.MEGACOMPACT_VC5B = "1";
+    try {
+      fn();
+    } finally {
+      if (saved === undefined) delete process.env.MEGACOMPACT_VC5B;
+      else process.env.MEGACOMPACT_VC5B = saved;
+    }
+  };
+}

package/src/vector-cortex/render/_acceptance-helpers.ts

@@ -0,0 +1,39 @@
+/**
+ * render/_acceptance-helpers.ts — barrel re-export for the VC5B render + provider
+ * acceptance rows.
+ *
+ * The implementation is split across focused sibling files to keep each under
+ * the src/ 500-line hard limit; this file is the single import surface the
+ * acceptance aggregator uses:
+ *   - `_acceptance-fixture.ts`  — manifest I/O + RenderFx/ProviderFx shapes + withFlagsOn
+ *   - `_acceptance-scenario.ts` — declarative graph materialization + runRenderScenario
+ *   - `_acceptance-provider.ts` — provider-registry runner + KNOWN_KEYS
+ *
+ * Every function drives the REAL render / validate / provider logic — no mocks,
+ * no stubs.
+ */
+
+export {
+  REPO_ROOT,
+  V2,
+  readManifest,
+  renderFixture,
+  providerFixture,
+  withFlagsOn,
+} from "./_acceptance-fixture.js";
+export type {
+  ManifestRow,
+  Manifest,
+  RenderFxInput,
+  RenderFxExpected,
+  RenderFx,
+  ProviderFxInput,
+  ProviderFxExpected,
+  ProviderFx,
+} from "./_acceptance-fixture.js";
+
+export { materializeGraph, runRenderScenario } from "./_acceptance-scenario.js";
+export type { MaterializedGraph, RenderRunOutcome } from "./_acceptance-scenario.js";
+
+export { runProviderScenario, KNOWN_KEYS } from "./_acceptance-provider.js";
+export type { ProviderRunOutcome } from "./_acceptance-provider.js";

package/src/vector-cortex/render/_acceptance-provider.ts

@@ -0,0 +1,45 @@
+/**
+ * render/_acceptance-provider.ts — the REAL provider-registry runner for VC5B
+ * provider acceptance rows. Drives `resolveProviderProfile` (no mocks).
+ */
+
+import { resolveProviderProfile, KNOWN_PROVIDER_KEYS } from "../provider/registry.js";
+import type { ProviderFx } from "./_acceptance-fixture.js";
+
+export interface ProviderRunOutcome {
+  readonly ok: boolean;
+  readonly code?: string;
+  readonly profileId?: string;
+  readonly hashMode?: string;
+  readonly excludedPointers?: string[];
+  readonly bypassClean?: boolean;
+  readonly cacheStable?: boolean;
+  readonly deterministic?: boolean;
+}
+
+/** Run a provider fixture through the REAL registry resolver. */
+export function runProviderScenario(fx: ProviderFx): ProviderRunOutcome {
+  const r = resolveProviderProfile(fx.input.provider, fx.input.model);
+  if (!r.ok) {
+    return { ok: false, code: r.code, bypassClean: true };
+  }
+  const p = r.bundle.profile;
+  const cacheStable =
+    fx.input.scenario === "resolve-excluded-cache" &&
+    p.excludedJsonPointers.length === 1 &&
+    p.excludedJsonPointers[0].pointer === "/requestId";
+  // deterministic: a second identical lookup returns the same profile id.
+  const r2 = resolveProviderProfile(fx.input.provider, fx.input.model);
+  const deterministic = r2.ok && r2.bundle.profile.id === p.id;
+  return {
+    ok: true,
+    profileId: p.id,
+    hashMode: p.hashMode,
+    excludedPointers: p.excludedJsonPointers.map((e) => e.pointer),
+    cacheStable,
+    deterministic,
+  };
+}
+
+/** Exposed for the acceptance registration check. */
+export const KNOWN_KEYS = KNOWN_PROVIDER_KEYS;

package/src/vector-cortex/render/_acceptance-scenario.ts

@@ -0,0 +1,319 @@
+/**
+ * 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";
+import type { RenderInput, RenderManifestV1, CanonicalOutboundRequest } from "./types.js";
+import type { ProviderProfileBundle } from "../provider/types.js";
+import type { RenderFx } from "./_acceptance-fixture.js";
+
+const enc = new TextEncoder();
+
+/** A materialized graph: node payloads + the stable validator order. */
+export interface MaterializedGraph {
+  readonly order: readonly string[];
+  readonly nodes: ReadonlyMap<string, { kind: string; bytes: Uint8Array }>;
+}
+
+function payload(id: string, label: string): Uint8Array {
+  return enc.encode(`${id}:${label}`);
+}
+
+/** Build a deterministic graph by name. */
+export function materializeGraph(name: string): MaterializedGraph {
+  const nodes = new Map<string, { kind: string; bytes: Uint8Array }>();
+  let order: string[];
+  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: string): ProviderProfileBundle | null {
+  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;
+}
+
+export interface RenderRunOutcome {
+  readonly ok: boolean;
+  readonly code?: string;
+  readonly triad?: "A" | "C";
+  readonly manifest?: RenderManifestV1;
+  readonly request?: CanonicalOutboundRequest;
+  readonly nodeOrder?: readonly string[];
+  readonly orderReplay?: boolean;
+  readonly permutationInvariant?: boolean;
+  readonly toolBytesExact?: boolean;
+  readonly invalidUtf8Survives?: boolean;
+  readonly requestDigestStable?: boolean;
+  readonly requestDigestSensitive?: boolean;
+  readonly digestOrderIndependent?: boolean;
+  readonly hashModeEntire?: boolean;
+  readonly bypassClean?: boolean;
+  readonly profileResolved?: boolean;
+  readonly selectsTriadC?: boolean;
+  readonly usesHostPrependSeam?: boolean;
+  readonly forbidsSystemRole?: boolean;
+}
+
+/** Run a render fixture through the REAL render + validate pipeline. */
+export function runRenderScenario(fx: RenderFx): RenderRunOutcome {
+  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: RenderInput = {
+      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<string, { kind: string; bytes: Uint8Array }>([
+      ["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: RenderInput = {
+    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<string, string>();
+  for (const t of rendered.request.tools) sourceToolBytes.set(t.id, t.bytes);
+  const pinnedToolLengths = new Map<string, number>();
+  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<string, { kind: string; bytes: Uint8Array }>();
+  for (const k of [...g.nodes.keys()].reverse()) revMap.set(k, g.nodes.get(k)!);
+  const revInput: RenderInput = { ...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<string, { kind: string; bytes: Uint8Array }>([["b1", { kind: "exact", bytes: bad }]]);
+    const bIn: RenderInput = { ...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: RenderInput = { ...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,
+  };
+}