pi-mega-compact 0.20.43 → 0.20.45

package/src/config/vector-cortex-enc0c.ts

@@ -0,0 +1,37 @@
+/**
+ * config/vector-cortex-enc0c.ts — ENC-0c five-head supervision transfer flag.
+ *
+ * Extracted from vector-cortex.ts so that file stays under the 300-line soft
+ * limit (soft-as-hard gate), exactly as vector-cortex-enc0a.ts / enc0b.ts and
+ * the VC8C/VC9A-D/ML5A-E/DEDUP_ATTR siblings were. vector-cortex.ts re-exports
+ * the flag below and root src/config.ts re-exports it, so no consumer import
+ * path changes.
+ *
+ * ENC-0c trains the five real heads onto the frozen ENC-0b bge-small trunk via
+ * supervision transfer, and stages a qualified candidate under
+ * ~/.pi/mega-compact-encoder/candidates/ (only when the developer trains it —
+ * the extension never stages one by itself). When the flag is ON and a
+ * qualified candidate exists, `loadHeadCandidate` (encoder/heads.ts seam) serves
+ * the trained head weights; when the flag is OFF (MEGACOMPACT_ENC_0C=0) or no
+ * candidate is staged, the heads keep serving the ENC-0b survivor exactly —
+ * byte-identical, no weight change. The flag gates ONLY the candidate-load seam;
+ * the survivor path is untouched.
+ *
+ * The split is purely mechanical: ENC_0C_ENABLED follows ENC_0B_ENABLED in name,
+ * semantics, and default, and vector-cortex.ts re-exports it so every existing
+ * `from "./config/vector-cortex.js"` import keeps resolving unchanged.
+ *
+ * Pi-agnostic, dependency-free (PREVENT-PI-004 / PREVENT-011).
+ */
+
+import { sprintFlag } from "./vector-cortex-flag.js";
+
+/**
+ * ENC-0c — five-head supervision transfer on the frozen bge-small trunk.
+ * Default ON. `MEGACOMPACT_ENC_0C=0` disables and is byte-identical to the
+ * predecessor (ENC-0b): no head candidate is loaded and the heads keep serving
+ * the ENC-0b survivor defaults exactly as before. This flag MUST also be a
+ * dashboard SETTINGS toggle (visible in config UI, never in EXCLUDED_SETTINGS),
+ * mirroring ENC_0A and ENC_0B.
+ */
+export const ENC_0C_ENABLED = (): boolean => sprintFlag("MEGACOMPACT_ENC_0C");

package/src/config/vector-cortex.ts

@@ -267,7 +267,6 @@ export const VC8A_ENABLED = (): boolean => sprintFlag("MEGACOMPACT_VC8A");
  */
 export const VC8B_ENABLED = (): boolean => sprintFlag("MEGACOMPACT_VC8B");
 
-// VC8C extracted to vector-cortex-vc8c.ts; re-exported so existing imports keep resolving.
 export { VC8C_ENABLED } from "./vector-cortex-vc8c.js";
 export { VC9A_ENABLED } from "./vector-cortex-vc9a.js";
 export { VC9B_ENABLED } from "./vector-cortex-vc9b.js";
@@ -281,7 +280,8 @@ export { ML5D_ENABLED } from "./vector-cortex-ml5d.js";
 export { ML5E_ENABLED } from "./vector-cortex-ml5e.js";
 export { DEDUP_ATTR_ENABLED } from "./vector-cortex-dedup-attr.js";
 export { ENC_0A_ENABLED } from "./vector-cortex-enc0a.js";
-
+export { ENC_0B_ENABLED } from "./vector-cortex-enc0b.js";
+export { ENC_0C_ENABLED } from "./vector-cortex-enc0c.js";
 // Breaker constants (TRIAD_RESILIENCE.md §breaker) extracted to vector-cortex-breakers.ts.
 export {
   BREAKER_WINDOW_MS,

package/src/config.ts

@@ -190,6 +190,8 @@ export {
   ML5E_ENABLED,
   DEDUP_ATTR_ENABLED,
   ENC_0A_ENABLED,
+  ENC_0B_ENABLED,
+  ENC_0C_ENABLED,
   BREAKER_WINDOW_MS,
   BREAKER_MIN_ATTEMPTS,
   BREAKER_PERF_FAILURES,

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

@@ -17,16 +17,19 @@ import { VC2A_ENABLED } from "../../config/vector-cortex.js";
 
 export type EncoderEmit = (event: string, fields: Record<string, unknown>) => void;
 
-/** The two-event reporter surface consumed by the runtime seams. */
+/** The reporter surface consumed by the runtime + ONNX seams. */
 export interface EncoderReporter {
   readonly assetVerified: (fields: Record<string, unknown>) => void;
   readonly runtimeDemoted: (fields: Record<string, unknown>) => void;
+  /** ENC-0b: fires when a real ONNX InferenceSession is successfully created. */
+  readonly onnxSessionLoaded: (fields: Record<string, unknown>) => void;
 }
 
 /** A flag-gated no-op reporter (zero emissions, default when none injected). */
 export const NOOP_ENCODER_REPORTER: EncoderReporter = {
   assetVerified: () => {},
   runtimeDemoted: () => {},
+  onnxSessionLoaded: () => {},
 };
 
 /**
@@ -47,5 +50,6 @@ export function createEncoderReporter(emit?: EncoderEmit): EncoderReporter {
   return {
     assetVerified: (fields) => fire("vector_cortex_encoder_asset_verified", fields),
     runtimeDemoted: (fields) => fire("vector_cortex_encoder_runtime_demoted", fields),
+    onnxSessionLoaded: (fields) => fire("vector_cortex_encoder_onnx_loaded", fields),
   };
 }

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

@@ -0,0 +1,76 @@
+/**
+ * encoder-onnx-dispatch.ts — ENC-0b ONNX dispatch: session lifecycle glue.
+ *
+ * Extracted from runtime.ts so runtime.ts stays under the 300-line soft limit.
+ * Encapsulates the ENC-0b real ONNX session build during load().
+ *
+ * IMPORTANT (interface constraint): EncoderRuntime.load() and infer() are
+ * SYNCHRONOUS — the router (router.ts:121-132) and all acceptance tests call
+ * them synchronously. ONNX session creation is ASYNC (WASM init). ENC-0b
+ * therefore expose the ONNX session as a SEPARATE async verification: load()
+ * fires-and-forgets the session build, verifySession() awaits it for tests,
+ * and infer() continues serving the LCG placeholder until the router is wired
+ * for async inference (ENC-0c scope). This preserves the sync contract while
+ * proving the real ONNX pipeline work end-to-end.
+ *
+ * ENC-0b gate: when MEGACOMPACT_ENC_0B is OFF, none of this code runs —
+ * the LCG stub serves mode A byte-identical to the predecessor.
+ *
+ * Pi-agnostic (PREVENT-PI-004 / PREVENT-011).
+ */
+
+import { ENC_0B_ENABLED } from "../../config/vector-cortex.js";
+import { buildOnnxSession, type OnnxInferenceSession } from "./onnx.js";
+import type { EncoderReporter } from "./emit.js";
+import type { ModelManifestV1 } from "./types.js";
+
+/** State held by the runtime for the ENC-0b ONNX dispatch. */
+export interface OnnxDispatchState {
+  /** The built ONNX session (null when not built, flag off, or build failed). */
+  readonly session: OnnxInferenceSession | null;
+  /** Resolved when the session build attempt settles (ok or fail). */
+  readonly ready: Promise<void>;
+}
+
+/** No-op state when ENC-0b is off or session build not attempted. */
+export const NO_ONNX: OnnxDispatchState = { session: null, ready: Promise.resolve() };
+
+/**
+ * Attempt a real ONNX session build during load(). Fire-and-forget: returns
+ * immediately with a state whose `ready` Promise resolves once the async
+ * build settles. On failure the state's `session` stays null.
+ */
+export function tryBuildOnnx(
+  assetDir: string,
+  manifest: ModelManifestV1,
+  reporter: EncoderReporter,
+  allocatedBytes: number,
+): OnnxDispatchState {
+  if (!ENC_0B_ENABLED()) return NO_ONNX;
+  let session: OnnxInferenceSession | null = null;
+  const ready = buildOnnxSession(assetDir, manifest, reporter, allocatedBytes)
+    .then((result) => { if (result.ok) session = result.session; })
+    .catch(() => {});
+  // Return a state whose `session` getter reads the mutable binding after
+  // ready resolves (the getter runs at test assertion time, not at load()).
+  return { get session() { return session; }, ready };
+}
+
+/**
+ * Await the ONNX session build and verify it with a real inference.
+ * Returns the embedding on success, null on any failure.
+ * Called by tests and the ENC-0b acceptance aggregator, not by production
+ * infer().
+ */
+export async function verifyOnnxSession(
+  state: OnnxDispatchState,
+  tokens: readonly number[],
+): Promise<Float32Array | null> {
+  await state.ready;
+  if (!state.session) return null;
+  try {
+    return await state.session.infer(tokens);
+  } catch {
+    return null;
+  }
+}

package/src/vector-cortex/encoder/heads-candidate.ts

@@ -0,0 +1,148 @@
+/**
+ * encoder/heads-candidate.ts — ENC-0c head-candidate load seam (delegate impl).
+ *
+ * Loads/validates a `head-candidate-v1` five-head candidate staged under
+ * `~/.pi/mega-compact-encoder/candidates/<version>/` after training on the
+ * frozen ENC-0b bge-small trunk. Flag-off / absent / malformed / wrong dims /
+ * non-finite / digest / trunk mismatch each return null or {ok:false} — a bad
+ * candidate is NEVER force-loaded; the runtime keeps the ENC-0b survivor
+ * byte-identical. No `any` (PREVENT-011), local-only, structured logging.
+ */
+
+import { createHash } from "node:crypto";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+
+import { ENC_0C_ENABLED } from "../../config/vector-cortex.js";
+import { ENCODER_HEAD_DIMS, ENCODER_HEAD_ORDER } from "./types.js";
+import type { EncoderHeadName, ModelManifestV1 } from "./types.js";
+
+export const HEAD_CANDIDATE_SCHEMA = "head-candidate-v1" as const;
+const MANIFEST_FILE = "manifest.json";
+
+export interface HeadCandidateHeadDigest {
+  readonly name: EncoderHeadName;
+  readonly dim: number;
+  readonly sha256: string;
+  readonly bytes: number;
+}
+
+/** On-disk candidate contract; `trunkDigest` pins the frozen trunk. */
+export interface HeadCandidateManifest {
+  readonly schema: typeof HEAD_CANDIDATE_SCHEMA;
+  readonly version: string;
+  readonly trunkDigest: string;
+  readonly heads: readonly HeadCandidateHeadDigest[];
+  readonly totalBytes: number;
+}
+
+/** Loaded candidate: parsed Float32Array weights per head. */
+export interface HeadCandidate {
+  readonly schema: typeof HEAD_CANDIDATE_SCHEMA;
+  readonly version: string;
+  readonly trunkDigest: string;
+  readonly dims: Readonly<Record<EncoderHeadName, number>>;
+  readonly weights: Readonly<Record<EncoderHeadName, Float32Array>>;
+  readonly digests: Readonly<Record<EncoderHeadName, string>>;
+}
+
+export type HeadCandidateValidation = { readonly ok: true } | { readonly ok: false; readonly code: string };
+
+export const HEAD_CANDIDATE_FAIL = {
+  INVALID: "ENC0C_CANDIDATE_INVALID",
+  TRUNK_MISMATCH: "ENC0C_TRUNK_MISMATCH",
+  DIM_MISMATCH: "ENC0C_DIM_MISMATCH",
+  NON_FINITE: "ENC0C_NON_FINITE",
+  DIGEST_MISMATCH: "ENC0C_DIGEST_MISMATCH",
+} as const;
+
+function sha256(buf: Uint8Array): string { return createHash("sha256").update(buf).digest("hex"); }
+function finiteDim(values: Float32Array, dim: number): boolean {
+  if (values.length !== dim) return false;
+  for (const v of values) if (!Number.isFinite(v)) return false;
+  return true;
+}
+
+/** Parse the candidate manifest object, or null if invalid. */
+type ParsedManifest = { version: string; trunkDigest: string; heads: HeadCandidateHeadDigest[] };
+function parseManifest(m: Record<string, unknown> | null): ParsedManifest | null {
+  if (!m || m["schema"] !== HEAD_CANDIDATE_SCHEMA) return null;
+  const version = typeof m["version"] === "string" ? m["version"] : "";
+  const trunkDigest = typeof m["trunkDigest"] === "string" ? m["trunkDigest"] : "";
+  if (!version || !trunkDigest || !Array.isArray(m["heads"])) return null;
+  const heads: HeadCandidateHeadDigest[] = [];
+  for (const item of m["heads"] as unknown[]) {
+    const rec = item as Record<string, unknown> | null;
+    if (!rec || typeof rec !== "object") return null;
+    const name = rec["name"];
+    if (typeof name !== "string" || !ENCODER_HEAD_ORDER.includes(name as EncoderHeadName)) return null;
+    heads.push({
+      name: name as EncoderHeadName,
+      dim: Number(rec["dim"] ?? 0),
+      sha256: typeof rec["sha256"] === "string" ? rec["sha256"] : "",
+      bytes: Number(rec["bytes"] ?? 0),
+    });
+  }
+  return { version, trunkDigest, heads };
+}
+
+/** All 5 dims match, weights finite, digests hold. */
+export function validateHeadCandidate(candidate: HeadCandidate): HeadCandidateValidation {
+  for (const h of ENCODER_HEAD_ORDER) {
+    const dim = candidate.dims[h];
+    if (dim !== ENCODER_HEAD_DIMS[h]) return { ok: false, code: HEAD_CANDIDATE_FAIL.DIM_MISMATCH };
+    const w = candidate.weights[h];
+    if (!w || !finiteDim(w, dim)) return { ok: false, code: HEAD_CANDIDATE_FAIL.NON_FINITE };
+    const buf = new Uint8Array(w.buffer, w.byteOffset, w.byteLength);
+    if (sha256(buf) !== candidate.digests[h]) return { ok: false, code: HEAD_CANDIDATE_FAIL.DIGEST_MISMATCH };
+  }
+  return { ok: true };
+}
+
+/** Load a candidate against the frozen trunk; null on any violation, never throws. */
+export function loadHeadCandidate(candidateDir: string, manifest: ModelManifestV1): HeadCandidate | null {
+  if (!ENC_0C_ENABLED()) return null;
+  let raw: string;
+  try {
+    raw = readFileSync(join(candidateDir, MANIFEST_FILE), "utf8");
+  } catch {
+    return null;
+  }
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return null;
+  }
+  const m = parseManifest(parsed as Record<string, unknown> | null);
+  if (!m || m.trunkDigest !== manifest.onnx.sha256) return null;
+  const weights: Partial<Record<EncoderHeadName, Float32Array>> = {};
+  const digests: Partial<Record<EncoderHeadName, string>> = {};
+  const dims: Partial<Record<EncoderHeadName, number>> = {};
+  for (const rec of m.heads) {
+    const want = rec.dim * 4;
+    if (!Number.isInteger(want) || want <= 0 || rec.dim !== ENCODER_HEAD_DIMS[rec.name]) return null;
+    let bytes: Buffer;
+    try {
+      bytes = readFileSync(join(candidateDir, `${rec.name}.bin`));
+    } catch {
+      return null;
+    }
+    const f = new Float32Array(bytes.buffer, bytes.byteOffset, rec.dim);
+    const d = sha256(bytes);
+    if (bytes.length !== want || d !== rec.sha256) return null;
+    weights[rec.name] = f.slice();
+    digests[rec.name] = d;
+    dims[rec.name] = rec.dim;
+  }
+  for (const h of ENCODER_HEAD_ORDER) {
+    if (weights[h] === undefined || digests[h] === undefined || dims[h] === undefined) return null;
+  }
+  const candidate: HeadCandidate = {
+    schema: HEAD_CANDIDATE_SCHEMA, version: m.version, trunkDigest: m.trunkDigest,
+    dims: dims as Record<EncoderHeadName, number>,
+    weights: weights as Record<EncoderHeadName, Float32Array>,
+    digests: digests as Record<EncoderHeadName, string>,
+  };
+  return validateHeadCandidate(candidate).ok ? candidate : null;
+}

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

@@ -246,3 +246,17 @@ export function projectHeadFromTrunk(
 }
 
 export { ENCODER_HEAD_ORDER, ENCODER_HEAD_DIMS, ENCODER_HEAD_LOSS_SUM, ENCODER_SEED, NOOP_VC2B_REPORTER };
+
+// ENC-0c five-head candidate seam (delegate-shell): the load/validate impl
+// lives in heads-candidate.ts; these re-exports keep the public import path
+// stable at heads.ts without growing this survivor file over the soft limit.
+export {
+  HEAD_CANDIDATE_SCHEMA,
+  HEAD_CANDIDATE_FAIL,
+  loadHeadCandidate,
+  validateHeadCandidate,
+  type HeadCandidate,
+  type HeadCandidateManifest,
+  type HeadCandidateHeadDigest,
+  type HeadCandidateValidation,
+} from "./heads-candidate.js";

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-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 }>>;
     }>;
@@ -51,8 +51,8 @@ export interface WasmSession {
   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;