pi-mega-compact 0.20.42 → 0.20.44

package/src/vector-cortex/encoder/onnx.ts

@@ -0,0 +1,198 @@
+/**
+ * vector-cortex/encoder/onnx.ts — ENC-0b real ONNX InferenceSession builder.
+ *
+ * Creates a WASM-backed ONNX InferenceSession over the committed encoder-v1
+ * asset (bge-small-en-v1.5, opset 21, 384-dim sentence_embedding). Dynamically
+ * imports onnxruntime-web/wasm (the CPU-only variant) so the module graph
+ * compiles on hosts without the package. All failures return typed result
+ * codes — this function NEVER throws (PREVENT-011: no `any`).
+ *
+ * Lifecycle:
+ *   1. Check ENCODER_RSS_BUDGET_BYTES before allocation (cap-before-allocation).
+ *   2. Assert manifest.opset === ENCODER_OPSET (21).
+ *   3. Dynamically import("onnxruntime-web/wasm").
+ *   4. Create InferenceSession with wasm EP, 4 threads.
+ *   5. Expose infer(tokens) that feeds int64 input_ids + attention_mask + token_type_ids.
+ *   6. Return sentence_embedding, L2-normalized to unit norm.
+ *
+ * Pi-agnostic (PREVENT-PI-004: local file only, zero network).
+ */
+
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { existsSync } from "node:fs";
+import {
+  ENCODER_OPSET,
+  ENCODER_RSS_BUDGET_BYTES,
+  ENCODER_SEMANTIC_WIDTH,
+  type ModelManifestV1,
+} from "./types.js";
+import type { EncoderReporter } from "./emit.js";
+
+/** ENC-0b failure codes (new ENC_FAIL namespace entries declared here). */
+export const ENC_ONNX_FAIL = {
+  OPSET_MISMATCH: "ENC_ONNX_OPSET_MISMATCH",
+  RSS_BREACH: "ENC_ONNX_RSS_BREACH",
+  MODULE_ABSENT: "ENC_ONNX_MODULE_ABSENT",
+  SESSION_ERROR: "ENC_ONNX_SESSION_ERROR",
+  MODEL_ABSENT: "ENC_ONNX_MODEL_ABSENT",
+} as const;
+
+/** Typed failure code union. */
+export type OnnxFailCode = (typeof ENC_ONNX_FAIL)[keyof typeof ENC_ONNX_FAIL];
+
+/** Result of building an ONNX session — never throws. */
+export type OnnxSessionResult =
+  | { ok: true; session: OnnxInferenceSession }
+  | { ok: false; code: OnnxFailCode };
+
+/** The runnable ONNX inference surface (thin wrapper over the real session). */
+export interface OnnxInferenceSession {
+  readonly opset: number;
+  readonly semanticWidth: number;
+  /** Run inference over token IDs, returning L2-normalized sentence_embedding. */
+  infer(tokens: readonly number[]): Promise<Float32Array>;
+  /** Release the underlying session resources. */
+  release(): Promise<void>;
+}
+
+/** Shadow type for onnxruntime-web/wasm InferenceSession (avoids hard dep). */
+interface OrtSession {
+  run(
+    feeds: Record<string, { data: BigInt64Array | Float32Array; dims: readonly number[]; type: string }>,
+    fetches: readonly string[],
+  ): Promise<Record<string, { data: Float32Array | BigInt64Array; dims: readonly number[] }>>;
+  release(): Promise<void>;
+}
+interface OrtWasmModule {
+  InferenceSession: {
+    create(
+      path: string,
+      opts: { executionProviders: readonly string[]; intraOpNumThreads: number },
+    ): Promise<OrtSession>;
+  };
+}
+
+/** Resolve the onnxruntime-web package root from import.meta.url. */
+function resolveOrtWasmPath(): string | null {
+  try {
+    const here = dirname(fileURLToPath(import.meta.url));
+    // Walk up to find node_modules/onnxruntime-web/dist/ort-wasm-simd-threaded.wasm
+    let dir = here;
+    for (let i = 0; i < 12; i++) {
+      const candidate = join(dir, "node_modules", "onnxruntime-web", "dist", "ort-wasm-simd-threaded.wasm");
+      if (existsSync(candidate)) return candidate;
+      const next = dirname(dir);
+      if (next === dir) break;
+      dir = next;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+/** L2-normalize a Float32Array in-place; returns the same array. */
+function l2Normalize(arr: Float32Array): Float32Array {
+  let sum = 0;
+  for (let i = 0; i < arr.length; i++) sum += arr[i]! * arr[i]!;
+  const norm = Math.sqrt(sum);
+  if (norm > 1e-12) {
+    for (let i = 0; i < arr.length; i++) arr[i] = arr[i]! / norm;
+  }
+  return arr;
+}
+
+/**
+ * Build a real ONNX InferenceSession over the committed encoder-v1 asset.
+ * Returns a typed result — NEVER throws. On any failure the caller demotes
+ * to mode B trigram with the returned code.
+ *
+ * @param assetDir  Path to the directory containing model.onnx + manifest.
+ * @param manifest  The verified ModelManifestV1 from the asset.
+ * @param reporter  Encoder reporter for the onnx_loaded event (optional).
+ * @param allocatedBytes  Externally committed bytes (for RSS budget check).
+ */
+export async function buildOnnxSession(
+  assetDir: string,
+  manifest: ModelManifestV1,
+  reporter?: EncoderReporter,
+  allocatedBytes: number = 0,
+): Promise<OnnxSessionResult> {
+  // Q01: cap-before-allocation.
+  if (allocatedBytes > ENCODER_RSS_BUDGET_BYTES) {
+    return { ok: false, code: ENC_ONNX_FAIL.RSS_BREACH };
+  }
+
+  // Opset assertion.
+  if (manifest.opset !== ENCODER_OPSET) {
+    return { ok: false, code: ENC_ONNX_FAIL.OPSET_MISMATCH };
+  }
+
+  const modelPath = join(assetDir, manifest.onnx.path);
+  if (!existsSync(modelPath)) {
+    return { ok: false, code: ENC_ONNX_FAIL.MODEL_ABSENT };
+  }
+
+  // Dynamically import onnxruntime-web/wasm (never a hard dependency).
+  let ort: OrtWasmModule;
+  try {
+    ort = (await import("onnxruntime-web/wasm")) as OrtWasmModule;
+    if (!ort?.InferenceSession?.create) {
+      return { ok: false, code: ENC_ONNX_FAIL.MODULE_ABSENT };
+    }
+  } catch {
+    return { ok: false, code: ENC_ONNX_FAIL.MODULE_ABSENT };
+  }
+
+  // Resolve WASM binary path for the threading backend.
+  const wasmPath = resolveOrtWasmPath();
+
+  let rawSession: OrtSession;
+  try {
+    const opts: { executionProviders: readonly string[]; intraOpNumThreads: number; wasmPaths?: string } = {
+      executionProviders: ["wasm"],
+      intraOpNumThreads: 4,
+    };
+    if (wasmPath) opts.wasmPaths = wasmPath;
+    rawSession = await ort.InferenceSession.create(modelPath, opts);
+  } catch {
+    return { ok: false, code: ENC_ONNX_FAIL.SESSION_ERROR };
+  }
+
+  reporter?.onnxSessionLoaded({
+    opset: manifest.opset,
+    semanticWidth: ENCODER_SEMANTIC_WIDTH,
+    threads: 4,
+  });
+
+  const session: OnnxInferenceSession = {
+    opset: manifest.opset,
+    semanticWidth: ENCODER_SEMANTIC_WIDTH,
+    async infer(tokens: readonly number[]): Promise<Float32Array> {
+      const n = tokens.length;
+      const inputIds = new BigInt64Array(n);
+      const attentionMask = new BigInt64Array(n);
+      const tokenTypeIds = new BigInt64Array(n);
+      for (let i = 0; i < n; i++) {
+        inputIds[i] = BigInt(tokens[i]!);
+        attentionMask[i] = 1n;
+        tokenTypeIds[i] = 0n;
+      }
+      const feeds = {
+        input_ids: { data: inputIds, dims: [1, n], type: "int64" },
+        attention_mask: { data: attentionMask, dims: [1, n], type: "int64" },
+        token_type_ids: { data: tokenTypeIds, dims: [1, n], type: "int64" },
+      };
+      const results = await rawSession.run(feeds, ["sentence_embedding"]);
+      const out = results["sentence_embedding"];
+      if (!out || !(out.data instanceof Float32Array)) {
+        return new Float32Array(ENCODER_SEMANTIC_WIDTH);
+      }
+      return l2Normalize(out.data);
+    },
+    release: () => rawSession.release(),
+  };
+
+  return { ok: true, session };
+}

package/src/vector-cortex/encoder/runtime-native.ts

@@ -45,7 +45,7 @@ export interface OrtNativeModule {
 
 /** The backend's inference session — a thin wrapper over the real native session. */
 export interface NativeSession {
-  /** The declared ONNX opset in the loaded manifest (normative 17). */
+  /** The declared ONNX opset in the loaded manifest (normative 21). */
   readonly opset: number;
   /** The semantic embedding width (normative 384). */
   readonly semanticWidth: number;

package/src/vector-cortex/encoder/runtime-wasm.ts

@@ -36,7 +36,7 @@ export interface OrtWasmModule {
       opts: { executionProviders: string[]; intraOpNumThreads: number },
     ): Promise<{
       run(
-        feeds: Record<string, Float32Array>,
+        feeds: Record<string, { data: BigInt64Array; dims: number[]; type: string }>,
         outputNames: string[],
       ): Promise<Record<string, { data: Float32Array }>>;
     }>;
@@ -45,14 +45,14 @@ export interface OrtWasmModule {
 
 /** The backend's inference session — a thin wrapper over the real WASM session. */
 export interface WasmSession {
-  /** The declared ONNX opset in the loaded manifest (normative 17). */
+  /** The declared ONNX opset in the loaded manifest (normative 21). */
   readonly opset: number;
   /** The semantic embedding width (normative 384). */
   readonly semanticWidth: number;
   /** The per-asset token capacity cap (normative <= 512). */
   readonly maxTokens: number;
-  /** Run one inference over already shape-checked input tokens. */
-  infer(inputIds: Float32Array): Promise<Float32Array>;
+  /** Run one inference over shape-checked token IDs (int64 input_ids). */
+  infer(tokens: number[]): Promise<Float32Array>;
 }
 
 /** True if `onnxruntime-web` resolves on this host (loading is best-effort).
@@ -94,10 +94,23 @@ export async function createWasmSession(
       opset: ENCODER_OPSET,
       semanticWidth: ENCODER_SEMANTIC_WIDTH,
       maxTokens,
-      async infer(inputIds: Float32Array): Promise<Float32Array> {
-        const feeds = { input_ids: inputIds };
-        const results = await session.run(feeds, ["embedding"]);
-        const out = results["embedding"];
+      async infer(tokens: number[]): Promise<Float32Array> {
+        const n = tokens.length;
+        const inputIds = new BigInt64Array(n);
+        const attentionMask = new BigInt64Array(n);
+        const tokenTypeIds = new BigInt64Array(n);
+        for (let i = 0; i < n; i++) {
+          inputIds[i] = BigInt(tokens[i]!);
+          attentionMask[i] = 1n;
+          tokenTypeIds[i] = 0n;
+        }
+        const feeds = {
+          input_ids: { data: inputIds, dims: [1, n], type: "int64" },
+          attention_mask: { data: attentionMask, dims: [1, n], type: "int64" },
+          token_type_ids: { data: tokenTypeIds, dims: [1, n], type: "int64" },
+        };
+        const results = await session.run(feeds, ["sentence_embedding"]);
+        const out = results["sentence_embedding"];
         if (!out || !(out.data instanceof Float32Array)) {
           return new Float32Array(ENCODER_SEMANTIC_WIDTH);
         }

package/src/vector-cortex/encoder/runtime.ts

@@ -86,6 +86,7 @@ import { selectRuntimeBackend } from "./runtime-select.js";
 import { emitRuntimeSelected } from "./runtime-emit.js";
 import { projectSemantic, seedFromBytes } from "./runtime-stub.js";
 import { STATE_DIR_DEFAULT } from "../../config.js";
+import { tryBuildOnnx, type OnnxDispatchState, NO_ONNX } from "./encoder-onnx-dispatch.js";
 
 /** Bytes a single encoder-owned projection buffer commits to the marginal
  *  footprint (Float32Array, 4 bytes per element). */
@@ -136,9 +137,16 @@ function normalizePlatform(p: EncoderPlatform | null): EncoderPlatform | "unsupp
   return p === null ? "unsupported" : p;
 }
 
+/** The concrete runtime returned by createEncoderRuntime — the base
+ *  EncoderRuntime interface plus the ENC-0b ONNX dispatch state. */
+export type EncoderRuntimeHandle = EncoderRuntime & {
+  /** ENC-0b: the ONNX dispatch state (null when ENC_0B is off or not built). */
+  readonly onnxState: OnnxDispatchState;
+};
+
 export function createEncoderRuntime(
   options: CreateEncoderRuntimeOptions = {},
-): EncoderRuntime {
+): EncoderRuntimeHandle {
   const reporter = options.reporter ?? createEncoderReporter();
   const host = mergeHost(options.host);
   const forced = options.forcedMode;
@@ -152,6 +160,7 @@ export function createEncoderRuntime(
   let verified = false;
   let maxTokens = ENCODER_MAX_TOKENS;
   let selfAllocated = 0;
+  let onnxState: OnnxDispatchState = NO_ONNX;
 
   const footprint = (): number => selfAllocated + host.allocatedBytes();
 
@@ -161,12 +170,14 @@ export function createEncoderRuntime(
     reporter.runtimeDemoted({ reason: code, mode: rmode, platform: plat()?.toString() ?? "unsupported" });
   };
 
-  const runtime: EncoderRuntime = {
+  const runtime: EncoderRuntimeHandle = {
     schema: "encoder-runtime-v1",
-    // Live getter so `mode` always reflects the latest load/demote outcome.
     get mode(): EncoderMode {
       return mode;
     },
+    get onnxState(): OnnxDispatchState {
+      return onnxState;
+    },
     load(assetDir: string): EncoderLoadResult {
       if (rolledBack) {
         // Q04: report the rollback with its own code, not MANIFEST_INVALID.
@@ -225,6 +236,14 @@ export function createEncoderRuntime(
         emitRuntimeSelected(host.stateDir ?? STATE_DIR_DEFAULT, chosen);
       }
 
+      // ENC-0b: fire-and-forget ONNX session build (async, non-blocking).
+      // The sync load() contract is preserved; the session build settles
+      // asynchronously and is consumed by verifyOnnxSession for tests +
+      // future async-heavy router integration (ENC-0c).
+      if (manifest) {
+        onnxState = tryBuildOnnx(assetDir, manifest, reporter, footprint());
+      }
+
       return {
         ok: true,
         mode: "A",
@@ -262,14 +281,13 @@ export function createEncoderRuntime(
         };
       }
       const start = host.nowMs();
-      // ML5-C: the LCG placeholder STILL drives infer by default (the trained
-      // asset behind runtime-wasm.ts/runtime-native.ts is not yet the
-      // source-of-truth on master; only the runtime-selection event seam was
-      // added this sprint).
+      // ENC-0b builds the real ONNX session during load() (fire-and-forget);
+      // infer() continues serving the LCG placeholder until the router is
+      // wired for async inference (ENC-0c). The session is verified by tests
+      // via the runtime's verifySession() method.
       const semantic = projectSemantic(seedFromBytes(embeddedBytes) ^ n, ENCODER_SEMANTIC_WIDTH);
       selfAllocated = SEMANTIC_BUFFER_BYTES;
-      const latencyMs = host.nowMs() - start;
-      return { ok: true, semantic, rssBytes: footprint(), latencyMs, shapeError: null };
+      return { ok: true, semantic, rssBytes: footprint(), latencyMs: host.nowMs() - start, shapeError: null };
     },
   };
   return runtime;

package/src/vector-cortex/encoder/types-vc2c.ts

@@ -0,0 +1,134 @@
+/**
+ * vector-cortex/encoder/types-vc2c.ts — VC2C qualification + calibration
+ * contracts (QualifiedEncoderV1 / CalibrationV1 / EVALUATION_THRESHOLDS).
+ *
+ * Extracted from types.ts (delegate-shell split) when types.ts crossed the
+ * 300-line soft limit. types.ts re-exports everything here; consumers import
+ * from types.ts unchanged.
+ *
+ * Pi-agnostic and dependency-free (PREVENT-PI-004). No `any` (PREVENT-011).
+ */
+
+import type { EncoderHeadName } from "./types.js";
+
+/**
+ * Held-out metrics recorded as qualification evidence for a candidate asset
+ * (EVALUATION.md §metrics). Semantic metrics are Spearman rho + recall@10;
+ * dependency directed precision/recall; contradiction precision/recall/ECE;
+ * cache precision/recall; payload-routing macro-F1 + exact/anchor recall;
+ * reconstruction is the binary causality/exact/closure/task-success set. The
+ * qualification decision (task 3 `select.ts`) consumes ONLY the per-head rows
+ * this record carries; the true EVALUATION thresholds are the normative
+ * constants in MODEL_ASSET (mirrored in `EVALUATION_THRESHOLDS` below).
+ */
+export interface EncoderHeldOutMetrics {
+  /** Semantic: Spearman rho (>= .75) and recall@10 (>= .90). */
+  readonly semantic: { readonly spearman: number; readonly recallAt10: number };
+  /** Dependency: directed precision (>= .97) and recall (>= .95). */
+  readonly dependency: { readonly precision: number; readonly recall: number };
+  /** Contradiction: precision (>= .98), recall (>= .90), ECE (<= .05). */
+  readonly contradiction: { readonly precision: number; readonly recall: number; readonly ece: number };
+  /** Cache: precision (>= .999, zero false-stable) and recall (>= .90). */
+  readonly cacheStability: { readonly precision: number; readonly recall: number };
+  /** Payload routing: macro-F1 (>= .97) and exact/anchor recall (1.0). */
+  readonly payloadRouting: { readonly macroF1: number; readonly exactAnchorRecall: number };
+  /** Reconstruction: binary gates — zero causal/tool/anchor/exact violations. */
+  readonly reconstruction: {
+    readonly votesOk: boolean;
+    readonly dependencyClosureRecall: number;
+    readonly taskSuccessNonInferior: boolean;
+  };
+}
+
+/** Normative per-head + asset qualification thresholds (MODEL_ASSET §qualification
+ *  + EVALUATION.md §metrics). These are the constants `select.ts` evaluates the
+ *  candidate's held-out metrics against (task 3 atomic check). */
+export const EVALUATION_THRESHOLDS = {
+  semantic: { spearman: 0.75, recallAt10: 0.9 },
+  dependency: { precision: 0.97, recall: 0.95 },
+  contradiction: { precision: 0.98, recall: 0.9, ece: 0.05 },
+  cacheStability: { precision: 0.999, recall: 0.9 },
+  payloadRouting: { macroF1: 0.97, exactAnchorRecall: 1.0 },
+  reconstruction: { dependencyClosureRecall: 1.0 },
+  asset: { maxTokens: 512, maxLatencyP95Ms: 40, maxRssDeltaMib: 150 },
+} as const;
+
+/**
+ * CalibrationV1 — fitted temperature/isotonic calibration, frozen on the
+ * CALIBRATION split only (VC2C task 2). Held-out test labels NEVER enter the
+ * fit inputs (calibration-fit prohibition). The split digest proves the exact
+ * calibration assignment (grouped by repository+session); the frozen temp/threshold
+ * values are what `select.ts` stamps into a `QualifiedEncoderV1`.
+ */
+export interface CalibrationV1 {
+  readonly schema: "calibration-v1";
+  readonly headOrder: readonly EncoderHeadName[];
+  /** SHA-256 of the calibration split assignment (grouped repository+session). */
+  readonly calibrationSplitDigest: string;
+  /** Fitted on the calibration split only; held-out labels excluded from fit. */
+  readonly fittedOnCalibrationOnly: true;
+  /** Frozen per-head temperature (isotonic calibration reference points). */
+  readonly temperatures: Readonly<Record<EncoderHeadName, number>>;
+  /** Frozen per-head decision thresholds for the qualified decision. */
+  readonly thresholds: Readonly<Record<EncoderHeadName, number>>;
+  /** Seed of the deterministic calibration fit. */
+  readonly seed: number;
+}
+
+/**
+ * QualifiedEncoderV1 — the VC2C-owned eligibility record (mode A). Produced by
+ * `select.ts` ONLY when EVERY MODEL_ASSET + per-head EVALUATION threshold
+ * passes (atomic — one failed field demotes all of A). Pins the asset digest,
+ * the calibration digest, the held-out metrics that justified eligibility, and
+ * the calibration reference, so VC3A receives a fully self-describing candidate.
+ */
+export interface QualifiedEncoderV1 {
+  readonly schema: "qualified-encoder-v1";
+  readonly modelVersion: string;
+  readonly mode: "A";
+  /** SHA-256 of the asset manifest bytes (ModelManifestV1) that qualified.
+   *  Identical semantics to the dashboard health card's `encoderAssetDigest`
+   *  (both hash the committed manifest.json ModelManifestV1 bytes), so
+   *  downstream consumers (VC3A) pin the same digest across the seam. */
+  readonly assetDigest: string;
+  /** SHA-256 of the calibration split assignment (grouped repository+session)
+   *  that the CalibrationV1 was fitted on — the calibration's core identity. */
+  readonly calibrationDigest: string;
+  /** SHA-256 of the qualified asset's verified ONNX bytes (digest-pinned). */
+  readonly onnxDigest: string;
+  /** Held-out metrics recorded as the eligibility evidence. */
+  readonly heldOut: EncoderHeldOutMetrics;
+  /** Calibration reference this qualification is grounded in. */
+  readonly calibration: CalibrationV1;
+}
+
+/** VC2C-specific qualification failure codes (returned, never thrown). */
+export const ENC_QUALIFICATION_FAIL = {
+  /** The qualification manifest hash does not match the calibration that was fit
+   *  (corrupt qualification manifest after calibration before selection). */
+  DIGEST_MISMATCH: "ENC_QUALIFICATION_DIGEST_MISMATCH",
+  /** One or more per-head EVALUATION thresholds failed (demotes all of A). */
+  THRESHOLD_FAILED: "ENC_QUALIFICATION_THRESHOLD_FAILED",
+  /** An asset-field qualification check (asset/latency/RSS) failed. */
+  ASSET_FAILED: "ENC_QUALIFICATION_ASSET_FAILED",
+  /** Calibration was attempted using held-out labels (fit prohibition). */
+  HELD_OUT_IN_FIT: "ENC_QUALIFICATION_HELD_OUT_IN_FIT",
+} as const;
+
+/** The 4 registered VC2C conformance IDs (task 1: "register ENC-017..020"). */
+export const ENC2C_IDS: readonly string[] = [
+  "ENC-017",
+  "ENC-018",
+  "ENC-019",
+  "ENC-020",
+];
+
+/** The 6 registered ENC-0b conformance IDs (encoder-trunk fixtures). */
+export const ENC_0B_IDS: readonly string[] = [
+  "ENC-TRUNK-001",
+  "ENC-TRUNK-002",
+  "ENC-TRUNK-003",
+  "ENC-TRUNK-004",
+  "ENC-TRUNK-005",
+  "ENC-TRUNK-006",
+];

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

@@ -34,8 +34,13 @@ export const ENCODER_SUPPORTED_PLATFORMS: readonly EncoderPlatform[] = [
   "win32-x64",
 ];
 
-/** ONNX opset required by the normative v1 target (opset 17). */
-export const ENCODER_OPSET = 17;
+/** ONNX opset required by the normative v1 target. ENC-0a re-baselines from 17
+ *  to 21: the committed placeholder asset (assets/vector-cortex/encoder-v1/)
+ *  declares opset 21 in its manifest (the 2026-08-05 BAAI/bge-small-en-v1.5
+ *  upstream export is opset 21; the earlier Xenova opset-17 requirement was
+ *  dropped). The locked decision is recorded in
+ *  docs/vector-cortex/encoder-backend-decision.md. */
+export const ENCODER_OPSET = 21;
 /** Batch must be exactly 1 (single-request inference). */
 export const ENCODER_BATCH = 1;
 /** Maximum accepted token count (WordPiece, deterministic truncation). */
@@ -124,7 +129,7 @@ export type EncoderMode = "A" | "B" | "C";
 
 /** Exact VC2A failure codes (returned, never thrown across the boundary). */
 export const ENC_FAIL = {
-  /** opset != 17. */
+  /** opset != 21 (ENC-0a re-baseline applied; placeholder manifest updated alongside). */
   OPSET_INVALID: "ENC_OPSET_INVALID",
   /** batch != 1. */
   BATCH_INVALID: "ENC_BATCH_INVALID",
@@ -275,117 +280,16 @@ export const ENC2B_IDS: readonly string[] = [
 ];
 
 // ---------------------------------------------------------------------------
-// VC2C — encoder qualification + calibration (QualifiedEncoderV1 / CalibrationV1).
+// VC2C — encoder qualification + calibration: extracted to types-vc2c.ts
+// (delegate-shell split, soft-limit compliance). Re-exported here.
 // ---------------------------------------------------------------------------
 
-/**
- * Held-out metrics recorded as qualification evidence for a candidate asset
- * (EVALUATION.md §metrics). Semantic metrics are Spearman rho + recall@10;
- * dependency directed precision/recall; contradiction precision/recall/ECE;
- * cache precision/recall; payload-routing macro-F1 + exact/anchor recall;
- * reconstruction is the binary causality/exact/closure/task-success set. The
- * qualification decision (task 3 `select.ts`) consumes ONLY the per-head rows
- * this record carries; the true EVALUATION thresholds are the normative
- * constants in MODEL_ASSET (mirrored in `EVALUATION_THRESHOLDS` below).
- */
-export interface EncoderHeldOutMetrics {
-  /** Semantic: Spearman rho (>= .75) and recall@10 (>= .90). */
-  readonly semantic: { readonly spearman: number; readonly recallAt10: number };
-  /** Dependency: directed precision (>= .97) and recall (>= .95). */
-  readonly dependency: { readonly precision: number; readonly recall: number };
-  /** Contradiction: precision (>= .98), recall (>= .90), ECE (<= .05). */
-  readonly contradiction: { readonly precision: number; readonly recall: number; readonly ece: number };
-  /** Cache: precision (>= .999, zero false-stable) and recall (>= .90). */
-  readonly cacheStability: { readonly precision: number; readonly recall: number };
-  /** Payload routing: macro-F1 (>= .97) and exact/anchor recall (1.0). */
-  readonly payloadRouting: { readonly macroF1: number; readonly exactAnchorRecall: number };
-  /** Reconstruction: binary gates — zero causal/tool/anchor/exact violations. */
-  readonly reconstruction: {
-    readonly votesOk: boolean;
-    readonly dependencyClosureRecall: number;
-    readonly taskSuccessNonInferior: boolean;
-  };
-}
-
-/** Normative per-head + asset qualification thresholds (MODEL_ASSET §qualification
- *  + EVALUATION.md §metrics). These are the constants `select.ts` evaluates the
- *  candidate's held-out metrics against (task 3 atomic check). */
-export const EVALUATION_THRESHOLDS = {
-  semantic: { spearman: 0.75, recallAt10: 0.9 },
-  dependency: { precision: 0.97, recall: 0.95 },
-  contradiction: { precision: 0.98, recall: 0.9, ece: 0.05 },
-  cacheStability: { precision: 0.999, recall: 0.9 },
-  payloadRouting: { macroF1: 0.97, exactAnchorRecall: 1.0 },
-  reconstruction: { dependencyClosureRecall: 1.0 },
-  asset: { maxTokens: 512, maxLatencyP95Ms: 40, maxRssDeltaMib: 150 },
-} as const;
-
-/**
- * CalibrationV1 — fitted temperature/isotonic calibration, frozen on the
- * CALIBRATION split only (VC2C task 2). Held-out test labels NEVER enter the
- * fit inputs (calibration-fit prohibition). The split digest proves the exact
- * calibration assignment (grouped by repository+session); the frozen temp/threshold
- * values are what `select.ts` stamps into a `QualifiedEncoderV1`.
- */
-export interface CalibrationV1 {
-  readonly schema: "calibration-v1";
-  readonly headOrder: readonly EncoderHeadName[];
-  /** SHA-256 of the calibration split assignment (grouped repository+session). */
-  readonly calibrationSplitDigest: string;
-  /** Fitted on the calibration split only; held-out labels excluded from fit. */
-  readonly fittedOnCalibrationOnly: true;
-  /** Frozen per-head temperature (isotonic calibration reference points). */
-  readonly temperatures: Readonly<Record<EncoderHeadName, number>>;
-  /** Frozen per-head decision thresholds for the qualified decision. */
-  readonly thresholds: Readonly<Record<EncoderHeadName, number>>;
-  /** Seed of the deterministic calibration fit. */
-  readonly seed: number;
-}
-
-/**
- * QualifiedEncoderV1 — the VC2C-owned eligibility record (mode A). Produced by
- * `select.ts` ONLY when EVERY MODEL_ASSET + per-head EVALUATION threshold
- * passes (atomic — one failed field demotes all of A). Pins the asset digest,
- * the calibration digest, the held-out metrics that justified eligibility, and
- * the calibration reference, so VC3A receives a fully self-describing candidate.
- */
-export interface QualifiedEncoderV1 {
-  readonly schema: "qualified-encoder-v1";
-  readonly modelVersion: string;
-  readonly mode: "A";
-  /** SHA-256 of the asset manifest bytes (ModelManifestV1) that qualified.
-   *  Identical semantics to the dashboard health card's `encoderAssetDigest`
-   *  (both hash the committed manifest.json ModelManifestV1 bytes), so
-   *  downstream consumers (VC3A) pin the same digest across the seam. */
-  readonly assetDigest: string;
-  /** SHA-256 of the calibration split assignment (grouped repository+session)
-   *  that the CalibrationV1 was fitted on — the calibration's core identity. */
-  readonly calibrationDigest: string;
-  /** SHA-256 of the qualified asset's verified ONNX bytes (digest-pinned). */
-  readonly onnxDigest: string;
-  /** Held-out metrics recorded as the eligibility evidence. */
-  readonly heldOut: EncoderHeldOutMetrics;
-  /** Calibration reference this qualification is grounded in. */
-  readonly calibration: CalibrationV1;
-}
-
-/** VC2C-specific qualification failure codes (returned, never thrown). */
-export const ENC_QUALIFICATION_FAIL = {
-  /** The qualification manifest hash does not match the calibration that was fit
-   *  (corrupt qualification manifest after calibration before selection). */
-  DIGEST_MISMATCH: "ENC_QUALIFICATION_DIGEST_MISMATCH",
-  /** One or more per-head EVALUATION thresholds failed (demotes all of A). */
-  THRESHOLD_FAILED: "ENC_QUALIFICATION_THRESHOLD_FAILED",
-  /** An asset-field qualification check (asset/latency/RSS) failed. */
-  ASSET_FAILED: "ENC_QUALIFICATION_ASSET_FAILED",
-  /** Calibration was attempted using held-out labels (fit prohibition). */
-  HELD_OUT_IN_FIT: "ENC_QUALIFICATION_HELD_OUT_IN_FIT",
-} as const;
-
-/** The 4 registered VC2C conformance IDs (task 1: "register ENC-017..020"). */
-export const ENC2C_IDS: readonly string[] = [
-  "ENC-017",
-  "ENC-018",
-  "ENC-019",
-  "ENC-020",
-];
+export {
+  EVALUATION_THRESHOLDS,
+  ENC_QUALIFICATION_FAIL,
+  ENC2C_IDS,
+  ENC_0B_IDS,
+  type EncoderHeldOutMetrics,
+  type CalibrationV1,
+  type QualifiedEncoderV1,
+} from "./types-vc2c.js";