pi-mega-compact 0.20.43 → 0.20.45

package/dist/config/vector-cortex-enc0b.js

@@ -0,0 +1,34 @@
+/**
+ * config/vector-cortex-enc0b.ts — ENC-0b real ONNX trunk fetch + gated inference 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 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-0b fetches the real bge-small-en-v1.5 int8 ONNX model from the Hugging
+ * Face Hub (build-time fetch into the assets directory, NOT a runtime network
+ * call — PREVENT-PI-004 safe), wires an ONNX InferenceSession via
+ * onnxruntime-web WASM, and runs gated inference through it. The gate is
+ * controlled by this flag: OFF = the LCG placeholder encoder serves
+ * byte-identical predecessor output and no ONNX session is constructed.
+ *
+ * The split is purely mechanical: ENC_0B_ENABLED is byte-identical in name,
+ * semantics, and default to the definition it replaces, 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-0b — real ONNX trunk fetch + gated inference. Default ON.
+ * `MEGACOMPACT_ENC_0B=0` disables and is byte-identical to the predecessor
+ * (ENC-0a / LCG placeholder): no ONNX session is built, the real bge-small
+ * model is not loaded, and the encoder continues serving the LCG placeholder
+ * output exactly as before. This flag MUST also be a dashboard SETTINGS toggle
+ * (visible in config UI, never in EXCLUDED_SETTINGS), mirroring ENC_0A and
+ * VC4A..VC9D.
+ */
+export const ENC_0B_ENABLED = () => sprintFlag("MEGACOMPACT_ENC_0B");

package/dist/config/vector-cortex-enc0c.js

@@ -0,0 +1,35 @@
+/**
+ * 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 = () => sprintFlag("MEGACOMPACT_ENC_0C");

package/dist/config/vector-cortex.js

@@ -237,7 +237,6 @@ export const VC8A_ENABLED = () => sprintFlag("MEGACOMPACT_VC8A");
  * mirroring VC4A..VC8A.
  */
 export const VC8B_ENABLED = () => 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";
@@ -251,5 +250,7 @@ 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, BREAKER_MIN_ATTEMPTS, BREAKER_PERF_FAILURES, BREAKER_PERF_FAILURE_RATE, BREAKER_CORRECTNESS_FAILURES, BREAKER_COOLDOWN_MS, BREAKER_PROBE_COUNT, BREAKER_RETRY_BASE_MS, BREAKER_RETRY_CAP_MS, BREAKER_RETRY_JITTER, BREAKER_HYSTERESIS_FAILURE_RATE, BREAKER_HYSTERESIS_BUDGET_P95_MS, BREAKER_MIN_HEALTHY_RESIDENCE_MS, } from "./vector-cortex-breakers.js";

package/dist/config.js

@@ -114,4 +114,4 @@ export const NEW_UI = () => ragEnabled("MEGACOMPACT_NEW_UI");
 // default ON, `=0`/`_DISABLED` off. Re-exported from src/config/vector-cortex.ts
 // so root consumers share one source of truth.
 // ---------------------------------------------------------------------------
-export { VC0A_ENABLED, VC0B_ENABLED, VC1A_ENABLED, VC0C_ENABLED, VC1B_ENABLED, VC1C_ENABLED, VC2A_ENABLED, VC2B_ENABLED, VC2C_ENABLED, VC3A_ENABLED, VC3B_ENABLED, VC3C_ENABLED, VC4A_ENABLED, VC4B_ENABLED, VC4C_ENABLED, VC5A_ENABLED, VC5B_ENABLED, VC5C_ENABLED, VC6A_ENABLED, VC6B_ENABLED, VC6C_ENABLED, VC7A_ENABLED, VC7B_ENABLED, VC7C_ENABLED, VC8A_ENABLED, VC8B_ENABLED, VC8C_ENABLED, VC9A_ENABLED, VC9B_ENABLED, VC9C_ENABLED, VC9D_ENABLED, PCC_ENABLED, ML5A_ENABLED, ML5B_ENABLED, ML5C_ENABLED, ML5D_ENABLED, ML5E_ENABLED, DEDUP_ATTR_ENABLED, ENC_0A_ENABLED, BREAKER_WINDOW_MS, BREAKER_MIN_ATTEMPTS, BREAKER_PERF_FAILURES, BREAKER_PERF_FAILURE_RATE, BREAKER_CORRECTNESS_FAILURES, BREAKER_COOLDOWN_MS, BREAKER_PROBE_COUNT, BREAKER_RETRY_BASE_MS, BREAKER_RETRY_CAP_MS, BREAKER_RETRY_JITTER, BREAKER_HYSTERESIS_FAILURE_RATE, BREAKER_HYSTERESIS_BUDGET_P95_MS, BREAKER_MIN_HEALTHY_RESIDENCE_MS, } from "./config/vector-cortex.js";
+export { VC0A_ENABLED, VC0B_ENABLED, VC1A_ENABLED, VC0C_ENABLED, VC1B_ENABLED, VC1C_ENABLED, VC2A_ENABLED, VC2B_ENABLED, VC2C_ENABLED, VC3A_ENABLED, VC3B_ENABLED, VC3C_ENABLED, VC4A_ENABLED, VC4B_ENABLED, VC4C_ENABLED, VC5A_ENABLED, VC5B_ENABLED, VC5C_ENABLED, VC6A_ENABLED, VC6B_ENABLED, VC6C_ENABLED, VC7A_ENABLED, VC7B_ENABLED, VC7C_ENABLED, VC8A_ENABLED, VC8B_ENABLED, VC8C_ENABLED, VC9A_ENABLED, VC9B_ENABLED, VC9C_ENABLED, VC9D_ENABLED, PCC_ENABLED, ML5A_ENABLED, ML5B_ENABLED, ML5C_ENABLED, ML5D_ENABLED, ML5E_ENABLED, DEDUP_ATTR_ENABLED, ENC_0A_ENABLED, ENC_0B_ENABLED, ENC_0C_ENABLED, BREAKER_WINDOW_MS, BREAKER_MIN_ATTEMPTS, BREAKER_PERF_FAILURES, BREAKER_PERF_FAILURE_RATE, BREAKER_CORRECTNESS_FAILURES, BREAKER_COOLDOWN_MS, BREAKER_PROBE_COUNT, BREAKER_RETRY_BASE_MS, BREAKER_RETRY_CAP_MS, BREAKER_RETRY_JITTER, BREAKER_HYSTERESIS_FAILURE_RATE, BREAKER_HYSTERESIS_BUDGET_P95_MS, BREAKER_MIN_HEALTHY_RESIDENCE_MS, } from "./config/vector-cortex.js";

package/dist/extensions/dashboard-server/routes-rag-settings-vector-cortex.js

@@ -59,5 +59,7 @@ export const VECTOR_CORTEX_SETTINGS = {
         boolDirect("MEGACOMPACT_ML5_E", "ML5-E Nightly Retraining Cron", "ML5-E nightly retraining + feedback loop: the user's own post-redaction conversation turns become fresh training signal, the five heads are re-fit nightly via system cron, calibration is re-validated, and mode-A promotion is re-checked without human intervention. The cron is system-configured (crontab -e); the extension never installs or writes a crontab. Candidates are written to ~/.pi/mega-compact-encoder/candidates/ and promoted via the ML5-D Improve Cortex flow. ON (default) = the scripts may be invoked by the system cron. OFF = scripts are never invoked; byte-identical to ML5-D.", true),
         boolDirect("MEGACOMPACT_DEDUP_ATTR", "Dedup Tier Attribution Rollup", "Dedup tier-attribution rollup: per-tier dedup catch shares (L0/L1/L2/new percent of dedup decisions) read from the local events.log dedup_audit stream (GET /api/dedup-tier-attribution). OFF = 404 + no cache file, byte-identical predecessor.", true),
         boolDirect("MEGACOMPACT_ENC_0A", "ENC-0a Encoder Backend Decision", "ENC-0a learned-encoder backend-decision lock: records the transformers.js/WASM vs onnxruntime-node choice, per-platform install matrix, opset-21 baseline and pinned digests in docs/vector-cortex/encoder-backend-decision.md. OFF = no decision record written / no resolver runs, mode B trigram byte-identical predecessor.", true),
+        boolDirect("MEGACOMPACT_ENC_0B", "ENC-0b Real Trunk Fetch & Gated Path", "ENC-0b real ONNX trunk fetch + gated inference: replaces the LCG placeholder with the real bge-small int8 model through an ONNX InferenceSession (onnxruntime-web WASM). OFF = LCG placeholder serves byte-identical predecessor output, no ONNX session built.", true),
+        boolDirect("MEGACOMPACT_ENC_0C", "ENC-0c Five-Head Supervision Transfer", "ENC-0c five-head supervision transfer on the frozen bge-small trunk: when a developer-trained head candidate is staged under ~/.pi/mega-compact-encoder/candidates/, the five heads serve the trained weights. OFF = no candidate is loaded, the heads serve byte-identical ENC-0b survivor defaults.", true),
     ],
 };

package/dist/src/config/vector-cortex-enc0b.js

@@ -0,0 +1,34 @@
+/**
+ * config/vector-cortex-enc0b.ts — ENC-0b real ONNX trunk fetch + gated inference 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 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-0b fetches the real bge-small-en-v1.5 int8 ONNX model from the Hugging
+ * Face Hub (build-time fetch into the assets directory, NOT a runtime network
+ * call — PREVENT-PI-004 safe), wires an ONNX InferenceSession via
+ * onnxruntime-web WASM, and runs gated inference through it. The gate is
+ * controlled by this flag: OFF = the LCG placeholder encoder serves
+ * byte-identical predecessor output and no ONNX session is constructed.
+ *
+ * The split is purely mechanical: ENC_0B_ENABLED is byte-identical in name,
+ * semantics, and default to the definition it replaces, 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-0b — real ONNX trunk fetch + gated inference. Default ON.
+ * `MEGACOMPACT_ENC_0B=0` disables and is byte-identical to the predecessor
+ * (ENC-0a / LCG placeholder): no ONNX session is built, the real bge-small
+ * model is not loaded, and the encoder continues serving the LCG placeholder
+ * output exactly as before. This flag MUST also be a dashboard SETTINGS toggle
+ * (visible in config UI, never in EXCLUDED_SETTINGS), mirroring ENC_0A and
+ * VC4A..VC9D.
+ */
+export const ENC_0B_ENABLED = () => sprintFlag("MEGACOMPACT_ENC_0B");

package/dist/src/config/vector-cortex-enc0c.js

@@ -0,0 +1,35 @@
+/**
+ * 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 = () => sprintFlag("MEGACOMPACT_ENC_0C");

package/dist/src/config/vector-cortex.js

@@ -237,7 +237,6 @@ export const VC8A_ENABLED = () => sprintFlag("MEGACOMPACT_VC8A");
  * mirroring VC4A..VC8A.
  */
 export const VC8B_ENABLED = () => 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";
@@ -251,5 +250,7 @@ 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, BREAKER_MIN_ATTEMPTS, BREAKER_PERF_FAILURES, BREAKER_PERF_FAILURE_RATE, BREAKER_CORRECTNESS_FAILURES, BREAKER_COOLDOWN_MS, BREAKER_PROBE_COUNT, BREAKER_RETRY_BASE_MS, BREAKER_RETRY_CAP_MS, BREAKER_RETRY_JITTER, BREAKER_HYSTERESIS_FAILURE_RATE, BREAKER_HYSTERESIS_BUDGET_P95_MS, BREAKER_MIN_HEALTHY_RESIDENCE_MS, } from "./vector-cortex-breakers.js";

package/dist/src/config.js

@@ -114,4 +114,4 @@ export const NEW_UI = () => ragEnabled("MEGACOMPACT_NEW_UI");
 // default ON, `=0`/`_DISABLED` off. Re-exported from src/config/vector-cortex.ts
 // so root consumers share one source of truth.
 // ---------------------------------------------------------------------------
-export { VC0A_ENABLED, VC0B_ENABLED, VC1A_ENABLED, VC0C_ENABLED, VC1B_ENABLED, VC1C_ENABLED, VC2A_ENABLED, VC2B_ENABLED, VC2C_ENABLED, VC3A_ENABLED, VC3B_ENABLED, VC3C_ENABLED, VC4A_ENABLED, VC4B_ENABLED, VC4C_ENABLED, VC5A_ENABLED, VC5B_ENABLED, VC5C_ENABLED, VC6A_ENABLED, VC6B_ENABLED, VC6C_ENABLED, VC7A_ENABLED, VC7B_ENABLED, VC7C_ENABLED, VC8A_ENABLED, VC8B_ENABLED, VC8C_ENABLED, VC9A_ENABLED, VC9B_ENABLED, VC9C_ENABLED, VC9D_ENABLED, PCC_ENABLED, ML5A_ENABLED, ML5B_ENABLED, ML5C_ENABLED, ML5D_ENABLED, ML5E_ENABLED, DEDUP_ATTR_ENABLED, ENC_0A_ENABLED, BREAKER_WINDOW_MS, BREAKER_MIN_ATTEMPTS, BREAKER_PERF_FAILURES, BREAKER_PERF_FAILURE_RATE, BREAKER_CORRECTNESS_FAILURES, BREAKER_COOLDOWN_MS, BREAKER_PROBE_COUNT, BREAKER_RETRY_BASE_MS, BREAKER_RETRY_CAP_MS, BREAKER_RETRY_JITTER, BREAKER_HYSTERESIS_FAILURE_RATE, BREAKER_HYSTERESIS_BUDGET_P95_MS, BREAKER_MIN_HEALTHY_RESIDENCE_MS, } from "./config/vector-cortex.js";
+export { VC0A_ENABLED, VC0B_ENABLED, VC1A_ENABLED, VC0C_ENABLED, VC1B_ENABLED, VC1C_ENABLED, VC2A_ENABLED, VC2B_ENABLED, VC2C_ENABLED, VC3A_ENABLED, VC3B_ENABLED, VC3C_ENABLED, VC4A_ENABLED, VC4B_ENABLED, VC4C_ENABLED, VC5A_ENABLED, VC5B_ENABLED, VC5C_ENABLED, VC6A_ENABLED, VC6B_ENABLED, VC6C_ENABLED, VC7A_ENABLED, VC7B_ENABLED, VC7C_ENABLED, VC8A_ENABLED, VC8B_ENABLED, VC8C_ENABLED, VC9A_ENABLED, VC9B_ENABLED, VC9C_ENABLED, VC9D_ENABLED, PCC_ENABLED, ML5A_ENABLED, ML5B_ENABLED, ML5C_ENABLED, ML5D_ENABLED, ML5E_ENABLED, DEDUP_ATTR_ENABLED, ENC_0A_ENABLED, ENC_0B_ENABLED, ENC_0C_ENABLED, BREAKER_WINDOW_MS, BREAKER_MIN_ATTEMPTS, BREAKER_PERF_FAILURES, BREAKER_PERF_FAILURE_RATE, BREAKER_CORRECTNESS_FAILURES, BREAKER_COOLDOWN_MS, BREAKER_PROBE_COUNT, BREAKER_RETRY_BASE_MS, BREAKER_RETRY_CAP_MS, BREAKER_RETRY_JITTER, BREAKER_HYSTERESIS_FAILURE_RATE, BREAKER_HYSTERESIS_BUDGET_P95_MS, BREAKER_MIN_HEALTHY_RESIDENCE_MS, } from "./config/vector-cortex.js";

package/dist/src/vector-cortex/encoder/emit.js

@@ -17,6 +17,7 @@ import { VC2A_ENABLED } from "../../config/vector-cortex.js";
 export const NOOP_ENCODER_REPORTER = {
     assetVerified: () => { },
     runtimeDemoted: () => { },
+    onnxSessionLoaded: () => { },
 };
 /**
  * Flag-gated emit: no-op when VC2A is off or no emitter is supplied. The
@@ -38,5 +39,6 @@ export function createEncoderReporter(emit) {
     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/dist/src/vector-cortex/encoder/encoder-onnx-dispatch.js

@@ -0,0 +1,58 @@
+/**
+ * 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 } from "./onnx.js";
+/** No-op state when ENC-0b is off or session build not attempted. */
+export const NO_ONNX = { 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, manifest, reporter, allocatedBytes) {
+    if (!ENC_0B_ENABLED())
+        return NO_ONNX;
+    let session = 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, tokens) {
+    await state.ready;
+    if (!state.session)
+        return null;
+    try {
+        return await state.session.infer(tokens);
+    }
+    catch {
+        return null;
+    }
+}

package/dist/src/vector-cortex/encoder/heads-candidate.js

@@ -0,0 +1,127 @@
+/**
+ * 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";
+export const HEAD_CANDIDATE_SCHEMA = "head-candidate-v1";
+const MANIFEST_FILE = "manifest.json";
+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",
+};
+function sha256(buf) { return createHash("sha256").update(buf).digest("hex"); }
+function finiteDim(values, dim) {
+    if (values.length !== dim)
+        return false;
+    for (const v of values)
+        if (!Number.isFinite(v))
+            return false;
+    return true;
+}
+function parseManifest(m) {
+    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 = [];
+    for (const item of m["heads"]) {
+        const rec = item;
+        if (!rec || typeof rec !== "object")
+            return null;
+        const name = rec["name"];
+        if (typeof name !== "string" || !ENCODER_HEAD_ORDER.includes(name))
+            return null;
+        heads.push({
+            name: name,
+            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) {
+    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, manifest) {
+    if (!ENC_0C_ENABLED())
+        return null;
+    let raw;
+    try {
+        raw = readFileSync(join(candidateDir, MANIFEST_FILE), "utf8");
+    }
+    catch {
+        return null;
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+    const m = parseManifest(parsed);
+    if (!m || m.trunkDigest !== manifest.onnx.sha256)
+        return null;
+    const weights = {};
+    const digests = {};
+    const dims = {};
+    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;
+        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 = {
+        schema: HEAD_CANDIDATE_SCHEMA, version: m.version, trunkDigest: m.trunkDigest,
+        dims: dims,
+        weights: weights,
+        digests: digests,
+    };
+    return validateHeadCandidate(candidate).ok ? candidate : null;
+}

package/dist/src/vector-cortex/encoder/heads.js

@@ -198,3 +198,7 @@ export function projectHeadFromTrunk(head, trunk, table) {
     return { head, dim, values: l2Normalize(out) };
 }
 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, } from "./heads-candidate.js";

package/dist/src/vector-cortex/encoder/onnx.js

@@ -0,0 +1,147 @@
+/**
+ * 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, } from "./types.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",
+};
+/** Resolve the onnxruntime-web package root from import.meta.url. */
+function resolveOrtWasmPath() {
+    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) {
+    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, manifest, reporter, allocatedBytes = 0) {
+    // 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;
+    try {
+        ort = (await import("onnxruntime-web/wasm"));
+        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;
+    try {
+        const opts = {
+            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 = {
+        opset: manifest.opset,
+        semanticWidth: ENCODER_SEMANTIC_WIDTH,
+        async infer(tokens) {
+            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/dist/src/vector-cortex/encoder/runtime-wasm.js

@@ -54,10 +54,23 @@ export async function createWasmSession(modelPath, options = {}) {
             opset: ENCODER_OPSET,
             semanticWidth: ENCODER_SEMANTIC_WIDTH,
             maxTokens,
-            async infer(inputIds) {
-                const feeds = { input_ids: inputIds };
-                const results = await session.run(feeds, ["embedding"]);
-                const out = results["embedding"];
+            async infer(tokens) {
+                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);
                 }