pi-mega-compact 0.20.38 → 0.20.39

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

@@ -0,0 +1,28 @@
+/**
+ * config/vector-cortex-ml5c.ts — ML5-C runtime decision + packaging flag.
+ *
+ * Sibling extract mirroring vector-cortex-ml5a.ts / vector-cortex-ml5b.ts, so
+ * vector-cortex.ts stays under its 300-line soft limit (soft-as-hard gate).
+ * This is the ONNX Runtime backend selection + packaging sprint flag.
+ * vector-cortex.ts re-exports the ENUM below and root src/config.ts re-exports
+ * it, so no consumer import path changes.
+ *
+ * ML5-C selects the ONNX runtime backend (WASM vs native) based on the ML5-B
+ * bench record and platform support. The flag gates the runtime-selection
+ * dispatch only; when OFF the encoder serves mode B trigram exactly as before
+ * (byte-identical to the ML5-B survivor — no `vector_cortex_runtime_selected`
+ * event is emitted, no session-selection dispatch runs).
+ *
+ * Pi-agnostic, dependency-free (PREVENT-PI-004 / PREVENT-011).
+ */
+import { sprintFlag } from "./vector-cortex-flag.js";
+/**
+ * ML5-C — runtime decision + packaging (WASM vs native). Default ON.
+ * `MEGACOMPACT_ML5_C=0` disables and is byte-identical to the ML5-B survivor:
+ * no runtime selection runs — the encoder continues to serve mode B trigram,
+ * exactly as before, with no `vector_cortex_runtime_selected` event emitted.
+ * The flag gates the runtime-selection dispatch only; it does not gate the
+ * underlying WASM/native backends (which are exercised by ML5-B's bench
+ * harness and ML5-A's trained asset independently).
+ */
+export const ML5C_ENABLED = () => sprintFlag("MEGACOMPACT_ML5_C");

package/dist/config/vector-cortex.js

@@ -242,7 +242,7 @@ export const VC8B_ENABLED = () => sprintFlag("MEGACOMPACT_VC8B");
 // VC8C (canary selection + Rust parity) extracted to vector-cortex-vc8c.ts;
 // re-exported so existing `./config/vector-cortex.js` imports keep resolving.
 export { VC8C_ENABLED } from "./vector-cortex-vc8c.js";
-// VC9A/VC9B/VC9C/VC9D/PCC/ML5A split to sibling files to stay under the 300-line soft limit.
+// Sibling extracts to stay under the 300-line soft limit.
 export { VC9A_ENABLED } from "./vector-cortex-vc9a.js";
 export { VC9B_ENABLED } from "./vector-cortex-vc9b.js";
 export { VC9C_ENABLED } from "./vector-cortex-vc9c.js";
@@ -250,5 +250,6 @@ export { VC9D_ENABLED } from "./vector-cortex-vc9d.js";
 export { PCC_ENABLED } from "./vector-cortex-pcc.js";
 export { ML5A_ENABLED } from "./vector-cortex-ml5a.js";
 export { ML5B_ENABLED } from "./vector-cortex-ml5b.js";
+export { ML5C_ENABLED } from "./vector-cortex-ml5c.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, 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, 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

@@ -54,5 +54,6 @@ export const VECTOR_CORTEX_SETTINGS = {
         boolDirect("MEGACOMPACT_VC9D", "VC9D Embedder Detect Consolidation", "Embedder-detect consolidation + VC9 workstream roll-up: memoizes /api/setup-detect against the mutable input (resolved binary path + mtime) so consecutive requests reuse the result without re-spawning, and unifies the embedder + cortex sub-tabs' 5s poll contract. OFF = byte-identical predecessor (VC9C-era): detect spawns fresh per request and the embedder poll keeps its previous cadence.", true),
         boolDirect("MEGACOMPACT_PC_C", "PC-C Dashboard Cache Visibility", "Dashboard per-turn prompt-cache visibility: surfaces the per-turn stable-prefix ratio trend (GET /api/prefix-stability) in the CacheTab PrefixStabilityCard. Reads aggregate ratios/counts from the local monitoring events log only — no payload bytes. OFF = byte-identical predecessor (PC-B-era): /api/prefix-stability returns 404 and the CacheTab omits the PrefixStabilityCard.", true),
         boolDirect("MEGACOMPACT_ML5_A", "ML5-A Five-Head Training Load", "ML5-A real trained-head loading: loadHeadProjections (trained-heads-v1) feeds selectQualifiedEncoder (trainedHeadsPath atomic demotion) + loadCalibrationV1. ON (default) = a pinned trained-heads path must load for mode A. OFF = loaders return null and selection ignores trainedHeadsPath — byte-identical to the placeholder-weighted VC2C path.", true),
+        boolDirect("MEGACOMPACT_ML5_C", "ML5-C Runtime Decision + Packaging", "ML5-C runtime backend selection (WASM vs native): selects the ONNX runtime backend based on the ML5-B bench record and platform support. ON (default) = the runtime-selection dispatch runs and emits vector_cortex_runtime_selected. OFF = no selection runs — encoder serves mode B trigram, byte-identical to ML5-B.", true),
     ],
 };

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

@@ -0,0 +1,28 @@
+/**
+ * config/vector-cortex-ml5c.ts — ML5-C runtime decision + packaging flag.
+ *
+ * Sibling extract mirroring vector-cortex-ml5a.ts / vector-cortex-ml5b.ts, so
+ * vector-cortex.ts stays under its 300-line soft limit (soft-as-hard gate).
+ * This is the ONNX Runtime backend selection + packaging sprint flag.
+ * vector-cortex.ts re-exports the ENUM below and root src/config.ts re-exports
+ * it, so no consumer import path changes.
+ *
+ * ML5-C selects the ONNX runtime backend (WASM vs native) based on the ML5-B
+ * bench record and platform support. The flag gates the runtime-selection
+ * dispatch only; when OFF the encoder serves mode B trigram exactly as before
+ * (byte-identical to the ML5-B survivor — no `vector_cortex_runtime_selected`
+ * event is emitted, no session-selection dispatch runs).
+ *
+ * Pi-agnostic, dependency-free (PREVENT-PI-004 / PREVENT-011).
+ */
+import { sprintFlag } from "./vector-cortex-flag.js";
+/**
+ * ML5-C — runtime decision + packaging (WASM vs native). Default ON.
+ * `MEGACOMPACT_ML5_C=0` disables and is byte-identical to the ML5-B survivor:
+ * no runtime selection runs — the encoder continues to serve mode B trigram,
+ * exactly as before, with no `vector_cortex_runtime_selected` event emitted.
+ * The flag gates the runtime-selection dispatch only; it does not gate the
+ * underlying WASM/native backends (which are exercised by ML5-B's bench
+ * harness and ML5-A's trained asset independently).
+ */
+export const ML5C_ENABLED = () => sprintFlag("MEGACOMPACT_ML5_C");

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

@@ -242,7 +242,7 @@ export const VC8B_ENABLED = () => sprintFlag("MEGACOMPACT_VC8B");
 // VC8C (canary selection + Rust parity) extracted to vector-cortex-vc8c.ts;
 // re-exported so existing `./config/vector-cortex.js` imports keep resolving.
 export { VC8C_ENABLED } from "./vector-cortex-vc8c.js";
-// VC9A/VC9B/VC9C/VC9D/PCC/ML5A split to sibling files to stay under the 300-line soft limit.
+// Sibling extracts to stay under the 300-line soft limit.
 export { VC9A_ENABLED } from "./vector-cortex-vc9a.js";
 export { VC9B_ENABLED } from "./vector-cortex-vc9b.js";
 export { VC9C_ENABLED } from "./vector-cortex-vc9c.js";
@@ -250,5 +250,6 @@ export { VC9D_ENABLED } from "./vector-cortex-vc9d.js";
 export { PCC_ENABLED } from "./vector-cortex-pcc.js";
 export { ML5A_ENABLED } from "./vector-cortex-ml5a.js";
 export { ML5B_ENABLED } from "./vector-cortex-ml5b.js";
+export { ML5C_ENABLED } from "./vector-cortex-ml5c.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, 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, 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/store/backfill.js

@@ -24,7 +24,6 @@ import { buildRaptorTree } from "../dedup/raptor/tree.js";
 import { defaultEmbedder } from "../embedder.js";
 import { getStateDir } from "../store.js";
 const BATCH = 1000;
-const THROTTLE_MS = 0; // synchronous backfill; no cross-process yield needed
 function ensureProgressTable(db) {
     db.exec(`
     CREATE TABLE IF NOT EXISTS backfill_progress (
@@ -92,10 +91,6 @@ export function backfillContentHashes(stateDir = getStateDir()) {
         withTx(db, () => applyRows(pending));
         db.prepare("INSERT INTO backfill_progress(name, last_session_id, last_id, updated, duplicates_resolved) VALUES('content_hashes',?,?,?,?) ON CONFLICT(name) DO UPDATE SET last_session_id=excluded.last_session_id, last_id=excluded.last_id, updated=excluded.updated, duplicates_resolved=excluded.duplicates_resolved").run(lastSid, lastId, updated, duplicatesResolved);
     }
-    if (THROTTLE_MS > 0) {
-        // No-op in this synchronous build; placeholder for future streaming backfill.
-        // guardrails-allow PREVENT-STUB-001: ML5-C
-    }
     return { processed, updated, duplicatesResolved };
 }
 /** True when no rows remain pending (backfill complete for this state dir). */
@@ -151,10 +146,6 @@ export function backfillPhase(phase, sessionId, stateDir, opts = {}) {
         });
         savePhaseCursor(db, phase, cursor ?? null, processed);
         batches++;
-        if (THROTTLE_MS > 0) {
-            const end = Date.now() + THROTTLE_MS;
-            while (Date.now() < end) { /* throttle */ }
-        }
         if (opts.interruptAfterBatches && batches >= opts.interruptAfterBatches) {
             interrupted = true;
             break;

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

@@ -0,0 +1,42 @@
+/**
+ * vector-cortex/encoder/runtime-emit.ts — ML5-C seller event emitter.
+ *
+ * Emits the `vector_cortex_runtime_selected` seller event to the local
+ * events.log so the dashboard Setup Cortex blockers card can surface the HG-3
+ * (install budget) / HG-4 (darwin-x64 demotion) closure state. Aggregate
+ * fields only — never payload bytes (EVAL-REDACT-002).
+ *
+ * Extracted from runtime.ts so the runtime delegate-shell stays under the
+ * 300-line soft limit after the ML5-C dispatch was added. All writes are
+ * best-effort / non-fatal; a disk-full or missing state dir never breaks the
+ * encoder loop.
+ *
+ * Pi-agnostic, dependency-free (PREVENT-PI-004 — local filesystem append only;
+ * no network). No `any` (PREVENT-011).
+ */
+import { appendFileSync, mkdirSync } from "node:fs";
+import { dirname } from "node:path";
+import { defaultEventsPath } from "../../monitoring.js";
+/**
+ * Emit the ML5-C `vector_cortex_runtime_selected` seller event (best-effort).
+ * The event carries ONLY the four aggregate fields the sprint spec pins
+ * ({backend, p95Ms, budgetOk, platform}) — never message content.
+ */
+export function emitRuntimeSelected(stateDir, result) {
+    try {
+        const path = defaultEventsPath(stateDir);
+        const payload = {
+            ts: Date.now(),
+            event: "vector_cortex_runtime_selected",
+            backend: result.backend,
+            p95Ms: result.p95Ms,
+            budgetOk: result.budgetOk,
+            platform: result.platform,
+        };
+        mkdirSync(dirname(path), { recursive: true });
+        appendFileSync(path, JSON.stringify(payload) + "\n", "utf8");
+    }
+    catch {
+        /* best-effort — never break the encoder loop */
+    }
+}

package/dist/src/vector-cortex/encoder/runtime-native.js

@@ -0,0 +1,77 @@
+/**
+ * vector-cortex/encoder/runtime-native.ts — ML5-C native backend (Option N).
+ *
+ * Loads an `InferenceSession` from the `onnxruntime-node` native binding for
+ * the committed encoder-v1 ONNX asset. This is the CHOSEN selection when
+ * `MEGACOMPACT_ENCODER_NATIVE=1` (the native opt-in marker) is set AND the
+ * package is present — it uses the platform-specific prebuilt binary (no
+ * postinstall compilation needed; per vc2-model-prep §1 the allowScripts
+ * removal is safe because only CUDA/TensorRT downloads use it, and pi blocks
+ * all scripts anyway).
+ *
+ * The package is NOT declared in package.json dependencies — it is a lazily-
+ * resolved peer that the runtime loads ONLY when the native opt-in is set AND
+ * selected. Loading uses dynamic `import()` so the module graph compiles
+ * cleanly on hosts without the package (absent installs return null, never
+ * throw), so the ML5-C dispatch demotes to mode B trigram rather than
+ * breaking.
+ *
+ * Pi-agnostic, dependency-free (PREVENT-PI-004 — the native binary + model are
+ * committed local files). No `any` (PREVENT-011).
+ */
+import { ENCODER_OPSET, ENCODER_SEMANTIC_WIDTH, ENCODER_MAX_TOKENS, } from "./types.js";
+/** True when `MEGACOMPACT_ENCODER_NATIVE=1` (the native opt-in operator flag). */
+export function nativeOptIn() {
+    return process.env.MEGACOMPACT_ENCODER_NATIVE === "1";
+}
+/** True if `onnxruntime-node` resolves on this host (loading is best-effort).
+ *  Absent installs return null (never throw) so the ML5-C dispatch can demote
+ *  to mode B trigram cleanly. */
+async function loadOrtNative() {
+    try {
+        // @ts-expect-error — optional peer; the shadow type above covers the surface
+        const mod = (await import("onnxruntime-node"));
+        return mod;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Create a native-backed `NativeSession` over the committed ONNX asset, gated
+ * first on `nativeOptIn()`. Returns null (never throws) on any failure
+ * (opt-in off, absent package, unreadable asset, bad session creation) so the
+ * caller demotes to mode B trigram.
+ */
+export async function createNativeSession(modelPath, options = {}) {
+    if (!nativeOptIn())
+        return null;
+    const ort = await loadOrtNative();
+    if (!ort || !ort.InferenceSession?.create)
+        return null;
+    const threads = options.threads ?? 4;
+    const maxTokens = options.maxTokens ?? ENCODER_MAX_TOKENS;
+    try {
+        const session = await ort.InferenceSession.create(modelPath, {
+            executionProviders: ["cpu"],
+            intraOpNumThreads: threads,
+        });
+        return {
+            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"];
+                if (!out || !(out.data instanceof Float32Array)) {
+                    return new Float32Array(ENCODER_SEMANTIC_WIDTH);
+                }
+                return out.data;
+            },
+        };
+    }
+    catch {
+        return null;
+    }
+}

package/dist/src/vector-cortex/encoder/runtime-select.js

@@ -0,0 +1,122 @@
+/**
+ * vector-cortex/encoder/runtime-select.ts — ML5-C decision-rule dispatch.
+ *
+ * Pure function of {platform, benchRecord, nativeOptIn} → the chosen ONNX
+ * runtime backend. This is the deterministic selection that closes HG-3
+ * (install budget) and HG-4 (darwin-x64 disposition) per the ML5-C spec:
+ *
+ *   - Measured p95 at 512 tokens on 4 threads (linux-x64) <= 40 ms  →  Option W (WASM)
+ *   - Measured p95 > 40 ms or absent (degraded)                        →  Option N (native)
+ *   - Platform is darwin-x64 (Intel Mac, HG-1 deferral)               →  WASM demotion or mode B
+ *
+ * The `platform` comes from `detectPlatform()` (already in `asset.ts`); the
+ * `benchRecord` is the latest `BenchResultV1` (from ML5-B / JSONL); the
+ * `nativeOptIn` helper reads `MEGACOMPACT_ENCODER_NATIVE=1`. The selection is
+ * PURE — no side effects, no I/O, no network. The caller stamps the result on
+ * the `vector_cortex_runtime_selected` event carried to the dashboard.
+ *
+ * Pi-agnostic, dependency-free (PREVENT-PI-004 — selection is computed+in memory;
+ * no fetch/HTTP). No `any` (PREVENT-011).
+ */
+import { ENCODER_LATENCY_P95_MS, } from "./types.js";
+import { ML5C_ENABLED } from "../../config/vector-cortex.js";
+/** The 80 MiB install budget in bytes (the HG-3 ceiling, unamended). */
+export const RUNTIME_NATIVE_INSTALL_BUDGET_MIB = 80;
+/**
+ * Per-platform optionalDependency footprint of onnxruntime-node (MiB, approx).
+ * These sum to ~160 MiB SHIPPED in the npm package (every target platform is
+ * included so the resolver lands on a concrete row at install time) — which is
+ * what exceeds the 80 MiB HG-3 budget and forces the amendment the fixtures
+ * record (ML5-RUNTIME-001). The per-host INSTALLED footprint (one row only)
+ * is 28–35 MiB and irrelevant to the 80 MiB ceiling — the budget covers the
+ * shipped tarball, not the single-platform install.
+ */
+export const NATIVE_FOOTPRINT_MIB = {
+    "linux-x64": 33,
+    "darwin-arm64": 28,
+    "darwin-x64": 33,
+    "linux-arm64": 31,
+    "win32-x64": 35,
+};
+/**
+ * ML5-C decision-rule dispatch: choose the ONNX runtime backend (pure).
+ *
+ * When the flag is OFF (`MEGACOMPACT_ML5_C=0`), returns mode B trigram — byte-
+ * identical to the ML5-B survivor with no selection event emitted.
+ *
+ * The rule (from the sprint spec):
+ *   - If nativeOptIn && platform is supported → native (Option N)
+ *   - If benchRecord has p95Ms <= 40 ms on linux-x64 → WASM (Option W)
+ *   - Else → native (Option N) with the budget amendment recorded (p95 exceeds
+ *     the WASM gate or is absent — the placeholder has no measured p95)
+ *   - darwin-x64 → WASM or mode B demotion per HG-4 (never native here)
+ */
+export function selectRuntimeBackend(input) {
+    if (!ML5C_ENABLED()) {
+        return {
+            backend: "modeB",
+            budgetOk: true,
+            p95Ms: null,
+            platform: input.platform,
+            rationale: "flag-off: byte-identical mode-B trigram (no selection)",
+        };
+    }
+    // HG-4: Intel Mac (darwin-x64) is out-of-scope per HG-1's deferral — always demote.
+    if (input.platform === "darwin-x64") {
+        return {
+            backend: "wasm",
+            budgetOk: true,
+            p95Ms: null,
+            platform: input.platform,
+            rationale: "darwin-x64 demoted to WASM per HG-4 (never native on this platform)",
+        };
+    }
+    // Native opt-in short-circuits: operator explicitly wants the native path.
+    // The HG-3 budget compares the SHIPPED byte-count (sum across every platform
+    // row in the package's optionalDependencies map) against the 80 MiB ceiling
+    // — not the single-platform install size. Native always exceeds 80 MiB across
+    // 5 platforms (~160 MiB shipped), so budgetOk is false and the evidence
+    // records the amended budget (the ML5-C spec, HG-3 closure).
+    if (input.nativeOptIn) {
+        const shippedMib = Object.values(NATIVE_FOOTPRINT_MIB).reduce((a, b) => a + b, 0);
+        return {
+            backend: "native",
+            budgetOk: shippedMib <= RUNTIME_NATIVE_INSTALL_BUDGET_MIB,
+            p95Ms: input.benchRecord?.p95Ms ?? null,
+            platform: input.platform,
+            rationale: `native opt-in (MEGACOMPACT_ENCODER_NATIVE=1); shipped ${shippedMib} MiB across 5 platforms → budget amended to ${shippedMib} MiB`,
+        };
+    }
+    // No bench record or degraded (gates.all:false) → WASM cannot qualify (the
+    // placeholder 42-byte asset has no measured real p95), so native is selected
+    // with the SAME amended-budget disposition as the opt-in path above: the
+    // evidence records the closed HG-3 amendment.
+    if (!input.benchRecord || !input.benchRecord.gates.all || input.benchRecord.p95Ms === null) {
+        const shippedMib = Object.values(NATIVE_FOOTPRINT_MIB).reduce((a, b) => a + b, 0);
+        return {
+            backend: "native",
+            budgetOk: false, // amended: native ships > 80 MiB across the 5-platform matrix
+            p95Ms: input.benchRecord?.p95Ms ?? null,
+            platform: input.platform,
+            rationale: `no qualifying bench record — native fallback with budget amendment (${shippedMib} MiB shipped, HG-3 amendment recorded)`,
+        };
+    }
+    // The decision rule: WASM iff p95 <= 40 ms (linux-x64, 512 tokens, 4 threads) —
+    // native required otherwise, with the same budget amendment recorded.
+    if (input.benchRecord.p95Ms <= ENCODER_LATENCY_P95_MS) {
+        return {
+            backend: "wasm",
+            budgetOk: true,
+            p95Ms: input.benchRecord.p95Ms,
+            platform: input.platform,
+            rationale: `WASM qualifies: p95 ${input.benchRecord.p95Ms}ms <= ${ENCODER_LATENCY_P95_MS}ms`,
+        };
+    }
+    return {
+        backend: "native",
+        budgetOk: false, // amended: native exceeds the 80 MiB budget per the evidence
+        p95Ms: input.benchRecord.p95Ms,
+        platform: input.platform,
+        rationale: `native required: p95 ${input.benchRecord.p95Ms}ms > ${ENCODER_LATENCY_P95_MS}ms on WASM`,
+    };
+}

package/dist/src/vector-cortex/encoder/runtime-stub.js

@@ -0,0 +1,35 @@
+/**
+ * vector-cortex/encoder/runtime-stub.ts — the VC2A-era deterministic LCG
+ * placeholder (`projectSemantic`) + token-seed helper, split out of runtime.ts
+ * so `runtime.ts` stays under its 300-line soft limit as the delegate-shell.
+ *
+ * This placeholder is the VC2A-era stand-in for a real ONNX EncoderRuntime
+ * inference result (the actual weights were VC2C and the runtime-selection
+ * dispatch is ML5-C). It remains exported so tests driving end-to-end shape
+ * keep working even when no backend session is active.
+ *
+ * Pi-agnostic, dependency-free (PREVENT-PI-004 / PREVENT-011).
+ */
+import { ENCODER_SEMANTIC_WIDTH } from "./types.js";
+/** A deterministic seeded projection so the mode-A inference path is testable
+ *  end-to-end without onnxruntime (real weights + execution are VC2C). */
+export function projectSemantic(seed, n) {
+    const out = new Float32Array(n);
+    let state = (seed >>> 0) ^ 0x9e3779b9;
+    let sum = 0;
+    for (let i = 0; i < n; i++) {
+        state = (state * 1664525 + 1013904223) >>> 0;
+        out[i] = (state / 4294967296) * 2 - 1;
+        sum += out[i] * out[i];
+    }
+    const norm = Math.sqrt(sum) || 1;
+    for (let i = 0; i < n; i++)
+        out[i] = out[i] / norm;
+    return out;
+}
+/** Deterministic token seed derived from the verified asset bytes count. */
+export function seedFromBytes(embeddedBytes) {
+    return (embeddedBytes * 2654435761) >>> 0;
+}
+/** The semantic embedding width from the normative types barrel. */
+export { ENCODER_SEMANTIC_WIDTH };

package/dist/src/vector-cortex/encoder/runtime-wasm.js

@@ -0,0 +1,71 @@
+/**
+ * vector-cortex/encoder/runtime-wasm.ts — ML5-C WASM backend (Option W).
+ *
+ * Loads an `InferenceSession` from the `onnxruntime-web` WASM execution
+ * provider for the committed encoder-v1 ONNX asset. This is the default
+ * backend when the WASM path is selected by `select.ts` — it covers all Node
+ * platforms (no per-platform optionalDependencies), is pure JS + WASM (~9 MiB),
+ * and never fetches from the network (PREVENT-PI-004).
+ *
+ * The package is NOT declared in package.json dependencies — it is a lazily-
+ * resolved peer that the runtime loads ONLY when the WASM backend is actually
+ * selected. Loading uses dynamic `import()` so the module graph compiles
+ * cleanly on hosts without the package; absent installs return null (never
+ * throw), so the ML5-C dispatch demotes to mode B trigram rather than
+ * breaking (ML5-B-bench precedent: the fixtures declare the shape even when
+ * the package is absent).
+ *
+ * Pi-agnostic, dependency-free (PREVENT-PI-004 — the WASM artifact is loaded
+ * from the committed local path; no fetch/HTTP anywhere). No `any`
+ * (PREVENT-011).
+ */
+import { ENCODER_OPSET, ENCODER_SEMANTIC_WIDTH, ENCODER_MAX_TOKENS, } from "./types.js";
+/** True if `onnxruntime-web` resolves on this host (loading is best-effort).
+ *  Absent installs return null (never throw) so the ML5-C dispatch can demote
+ *  to mode B trigram cleanly. */
+async function loadOrtWasm() {
+    try {
+        // @ts-expect-error — optional peer; the shadow type above covers the surface
+        const mod = (await import("onnxruntime-web"));
+        return mod;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Create a WASM-backed `WasmSession` over the committed ONNX asset. Returns
+ * null (never throws) on any failure (absent package, unreadable asset, bad
+ * session creation) so the caller demotes to mode B trigram per HG-4 mode-B
+ * disposition when the WASM path is unavailable on a darwin-x64 host.
+ */
+export async function createWasmSession(modelPath, options = {}) {
+    const ort = await loadOrtWasm();
+    if (!ort || !ort.InferenceSession?.create)
+        return null;
+    const threads = options.threads ?? 4;
+    const maxTokens = options.maxTokens ?? ENCODER_MAX_TOKENS;
+    try {
+        const session = await ort.InferenceSession.create(modelPath, {
+            executionProviders: ["wasm"],
+            intraOpNumThreads: threads,
+        });
+        return {
+            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"];
+                if (!out || !(out.data instanceof Float32Array)) {
+                    return new Float32Array(ENCODER_SEMANTIC_WIDTH);
+                }
+                return out.data;
+            },
+        };
+    }
+    catch {
+        return null;
+    }
+}