pi-mega-compact 0.20.36 → 0.20.38

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

@@ -0,0 +1,26 @@
+/**
+ * config/vector-cortex-ml5b.ts — ML5-B production bench harness flag.
+ *
+ * Sibling extract mirroring vector-cortex-ml5a.ts, so vector-cortex.ts stays
+ * under its 300-line soft limit (soft-as-hard gate). This is the ONNX Runtime
+ * evaluation/benchmark 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-B introduces NO runtime code path: the bench harness and corpus export
+ * are developer/evidence tooling (scripts/) plus a consumer-facing TypeScript
+ * shell (src/vector-cortex/encoder/bench.ts) that only writes monitoring
+ * events. The flag records intent and scopes the sprint's evidence assets; it
+ * gates nothing at runtime today. There is no HTTP endpoint and no dashboard
+ * change, so there is no SETTINGS toggle and no EXCLUDED_SETTINGS interaction.
+ *
+ * Pi-agnostic, dependency-free (PREVENT-PI-004 / PREVENT-011).
+ */
+import { sprintFlag } from "./vector-cortex-flag.js";
+/**
+ * ML5-B — production bench harness (ONNX Runtime eval). Default ON.
+ * `MEGACOMPACT_ML5_B=0` disables and is byte-identical to the ML5-A survivor:
+ * no bench endpoint exists and mode B continues to serve all clients exactly as
+ * before. The flag does not gate the harness itself — the harness is an on-demand
+ * developer tool with no runtime path.
+ */
+export const ML5B_ENABLED = () => sprintFlag("MEGACOMPACT_ML5_B");

package/dist/config/vector-cortex.js

@@ -249,5 +249,6 @@ export { VC9C_ENABLED } from "./vector-cortex-vc9c.js";
 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";
 // 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, 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, 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/monitoring.js

@@ -0,0 +1,172 @@
+/**
+ * monitoring.ts — local dedup monitoring + alerting (Sprint 14, Phase 7).
+ *
+ * Per-decision structured events go to `events.log` (append-only JSON).
+ * Aggregate metrics (hit rate, FP rate, per-tier p95 latency, storage) go to
+ * `dashboard.json` — the SAME local-only file the /dashboard UI reads. There is
+ * NO Prometheus port and NO network listener (PREVENT-PI-004). Alerting is local
+ * only: an FP-rate breach flips the tier to MARK_ONLY and writes a warning.
+ *
+ * Best-effort: logging/metrics never throw into the add()/search() path.
+ */
+import { readFileSync, writeFileSync, existsSync, mkdirSync, appendFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { STATE_DIR_DEFAULT } from "./config.js";
+const TIERS = ["L0", "L1", "L2", "RAPTOR"];
+function emptyMetrics() {
+    const dec = {};
+    const dp = {};
+    const fp = {};
+    const lat = {};
+    for (const t of TIERS) {
+        dec[t] = 0;
+        dp[t] = 0;
+        fp[t] = 0;
+        lat[t] = [];
+    }
+    return { decisions: dec, deduped: dp, falsePositives: fp, latency: lat, storageBytes: 0 };
+}
+/** Append a structured decision event to events.log (best-effort). */
+export function logDecision(path, ev) {
+    try {
+        mkdirSync(dirname(path), { recursive: true });
+        appendFileSync(path, `${JSON.stringify(ev)}\n`);
+    }
+    catch {
+        /* never break the extension on a log failure */
+    }
+}
+/**
+ * Load metrics from dashboard.json, or return a fresh empty snapshot.
+ * Kept simple + synchronous (no network).
+ */
+export function loadMetrics(path) {
+    try {
+        if (existsSync(path)) {
+            const raw = readFileSync(path, "utf-8");
+            const parsed = JSON.parse(raw);
+            const base = emptyMetrics();
+            return {
+                decisions: { ...base.decisions, ...(parsed.decisions ?? {}) },
+                deduped: { ...base.deduped, ...(parsed.deduped ?? {}) },
+                falsePositives: { ...base.falsePositives, ...(parsed.falsePositives ?? {}) },
+                latency: { ...base.latency, ...(parsed.latency ?? {}) },
+                storageBytes: parsed.storageBytes ?? 0,
+            };
+        }
+    }
+    catch {
+        /* corrupt metrics → fresh */
+    }
+    return emptyMetrics();
+}
+/** Persist metrics to dashboard.json (best-effort). */
+export function saveMetrics(path, m) {
+    try {
+        mkdirSync(dirname(path), { recursive: true });
+        writeFileSync(path, JSON.stringify(m));
+    }
+    catch {
+        /* never break the extension */
+    }
+}
+/** Compute the p95 latency (ms) for a tier from its samples. */
+export function p95(samples) {
+    if (samples.length === 0)
+        return 0;
+    const sorted = [...samples].sort((a, b) => a - b);
+    const idx = Math.min(sorted.length - 1, Math.floor(sorted.length * 0.95));
+    return sorted[idx];
+}
+/** FP rate for a tier over the current window (0..1). */
+export function fpRate(m, tier) {
+    const decisions = m.decisions[tier] ?? 0;
+    if (decisions === 0)
+        return 0;
+    return (m.falsePositives[tier] ?? 0) / decisions;
+}
+/**
+ * Evaluate FP-rate breaches against the config thresholds. A breached fuzzy tier
+ * (L0 vs L1/L2 have different thresholds) is auto-downgraded to MARK_ONLY — the
+ * local re-map of "alertmanager" (QA #18/#19): record but don't collapse, no
+ * remote alert. Returns the tiers flipped so the caller can mutate its config.
+ */
+export function evaluateAlerts(m, cfg) {
+    const breached = [];
+    const warnings = [];
+    for (const tier of TIERS) {
+        const rate = fpRate(m, tier);
+        const limit = tier === "L0" ? cfg.FP_RATE_L0 : cfg.FP_RATE_L1L2;
+        if (rate > limit) {
+            breached.push(tier);
+            warnings.push(`DEDUP FP BREACH tier=${tier} rate=${rate.toFixed(4)} > ${limit}`);
+        }
+    }
+    return { breached, warnings };
+}
+/**
+ * Record one decision into the metrics snapshot (mutates `m` in place) and
+ * returns the updated snapshot. Caps stored latency samples to keep memory
+ * bounded (last 1000 per tier).
+ */
+export function recordDecision(m, tier, result, latencyMs, falsePositive = false) {
+    m.decisions[tier] = (m.decisions[tier] ?? 0) + 1;
+    if (result === "deduped")
+        m.deduped[tier] = (m.deduped[tier] ?? 0) + 1;
+    if (falsePositive)
+        m.falsePositives[tier] = (m.falsePositives[tier] ?? 0) + 1;
+    const arr = m.latency[tier] ?? (m.latency[tier] = []);
+    arr.push(latencyMs);
+    if (arr.length > 1000)
+        arr.shift();
+    return m;
+}
+/** Default metrics path alongside the state dir. */
+export function defaultMetricsPath(stateDir = STATE_DIR_DEFAULT) {
+    return join(stateDir, "dashboard.json");
+}
+/** Default events-log path alongside the state dir. */
+export function defaultEventsPath(stateDir = STATE_DIR_DEFAULT) {
+    return join(stateDir, "events.log");
+}
+/**
+ * Append a RecallQualityEvent to events.log (best-effort, non-fatal).
+ * Follows the same append-one-JSON-line pattern as logDecision.
+ */
+export function logRecallQuality(path, ev) {
+    try {
+        mkdirSync(dirname(path), { recursive: true });
+        appendFileSync(path, JSON.stringify(ev) + "\n", "utf-8");
+    }
+    catch {
+        /* best-effort — never break the extension */
+    }
+}
+// ---------------------------------------------------------------------------
+// ML5-B encoder bench events (consumer-facing for the dashboard + evidence)
+// ---------------------------------------------------------------------------
+/**
+ * Append a structured ML5-B bench event to events.log (best-effort, non-fatal).
+ * Mirrors the extension's appendEvent schema ({ ts, event, ...fields }) so the
+ * dashboard live-stream tail and evidence tooling parse the four
+ * `vector_cortex_encoder_bench_*` events identically. The bench is developer/
+ * evidence tooling with no runtime gating; this only records its results.
+ */
+export function logBenchEvent(path, event, fields) {
+    try {
+        mkdirSync(dirname(path), { recursive: true });
+        appendFileSync(path, JSON.stringify({ ts: Date.now(), event, ...fields }) + "\n", "utf8");
+    }
+    catch {
+        /* best-effort — never break the caller */
+    }
+}
+// ---------------------------------------------------------------------------
+// Dedup audit trail (external-audit item #2)
+// ---------------------------------------------------------------------------
+// The event shape and its append helper are DEFINED in vectorStore/dedup-audit.ts,
+// co-located with the only recorder that emits them (this file already carries
+// decision events + the metrics snapshot + FP alerting and must stay under its
+// 300-line soft limit). Re-exported here so callers that treat monitoring.ts as
+// the events.log barrel — including the dashboard SSE tail — keep one import.
+export { logDedupAudit } from "./vectorStore/dedup-audit.js";

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

@@ -0,0 +1,26 @@
+/**
+ * config/vector-cortex-ml5b.ts — ML5-B production bench harness flag.
+ *
+ * Sibling extract mirroring vector-cortex-ml5a.ts, so vector-cortex.ts stays
+ * under its 300-line soft limit (soft-as-hard gate). This is the ONNX Runtime
+ * evaluation/benchmark 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-B introduces NO runtime code path: the bench harness and corpus export
+ * are developer/evidence tooling (scripts/) plus a consumer-facing TypeScript
+ * shell (src/vector-cortex/encoder/bench.ts) that only writes monitoring
+ * events. The flag records intent and scopes the sprint's evidence assets; it
+ * gates nothing at runtime today. There is no HTTP endpoint and no dashboard
+ * change, so there is no SETTINGS toggle and no EXCLUDED_SETTINGS interaction.
+ *
+ * Pi-agnostic, dependency-free (PREVENT-PI-004 / PREVENT-011).
+ */
+import { sprintFlag } from "./vector-cortex-flag.js";
+/**
+ * ML5-B — production bench harness (ONNX Runtime eval). Default ON.
+ * `MEGACOMPACT_ML5_B=0` disables and is byte-identical to the ML5-A survivor:
+ * no bench endpoint exists and mode B continues to serve all clients exactly as
+ * before. The flag does not gate the harness itself — the harness is an on-demand
+ * developer tool with no runtime path.
+ */
+export const ML5B_ENABLED = () => sprintFlag("MEGACOMPACT_ML5_B");

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

@@ -249,5 +249,6 @@ export { VC9C_ENABLED } from "./vector-cortex-vc9c.js";
 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";
 // 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, 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, 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/monitoring.js

@@ -143,6 +143,25 @@ export function logRecallQuality(path, ev) {
     }
 }
 // ---------------------------------------------------------------------------
+// ML5-B encoder bench events (consumer-facing for the dashboard + evidence)
+// ---------------------------------------------------------------------------
+/**
+ * Append a structured ML5-B bench event to events.log (best-effort, non-fatal).
+ * Mirrors the extension's appendEvent schema ({ ts, event, ...fields }) so the
+ * dashboard live-stream tail and evidence tooling parse the four
+ * `vector_cortex_encoder_bench_*` events identically. The bench is developer/
+ * evidence tooling with no runtime gating; this only records its results.
+ */
+export function logBenchEvent(path, event, fields) {
+    try {
+        mkdirSync(dirname(path), { recursive: true });
+        appendFileSync(path, JSON.stringify({ ts: Date.now(), event, ...fields }) + "\n", "utf8");
+    }
+    catch {
+        /* best-effort — never break the caller */
+    }
+}
+// ---------------------------------------------------------------------------
 // Dedup audit trail (external-audit item #2)
 // ---------------------------------------------------------------------------
 // The event shape and its append helper are DEFINED in vectorStore/dedup-audit.ts,

package/dist/src/store/backfill.js

@@ -94,6 +94,7 @@ export function backfillContentHashes(stateDir = getStateDir()) {
     }
     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 };
 }

package/dist/src/vector-cortex/encoder/bench-export.js

@@ -0,0 +1,13 @@
+/**
+ * vector-cortex/encoder/bench-export.ts — ML5-B bench result contract.
+ *
+ * BenchResultV1 is the typed surface `bench.ts` parses from the qualification
+ * harness (`scripts/ml5/bench-onnx-prod.mjs`) and the dashboard / evidence
+ * tooling consume. It carries AGGREGATE measurements + a digest only — never
+ * chunk/message content (EVAL-REDACT-002).
+ *
+ * Contract-first (ENGINEERING_PRACTICES §3): this types file is the reviewed
+ * gate; implementations import from it. Pi-agnostic, dependency-free
+ * (PREVENT-PI-004 / PREVENT-011).
+ */
+export {};

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

@@ -0,0 +1,100 @@
+/**
+ * vector-cortex/encoder/bench.ts — ML5-B bench runner (consumer-facing shell).
+ *
+ * Calls `scripts/ml5/bench-onnx-prod.mjs` via child_process, parses the
+ * BenchResultV1 it emits, and writes the four `vector_cortex_encoder_bench_*`
+ * events to the monitoring events.log (the dashboard / ML5-D surface consume
+ * them later). This is NOT a runtime path — it is developer/evidence tooling.
+ *
+ * Events written (all best-effort / non-fatal):
+ *   - vector_cortex_encoder_bench_p95_ms
+ *   - vector_cortex_encoder_bench_rss_mib
+ *   - vector_cortex_encoder_bench_opset_ok
+ *   - vector_cortex_encoder_bench_deterministic
+ *
+ * Pi-agnostic, dependency-free (PREVENT-PI-004 — the child bench is pure local
+ * computation). No `any` (PREVENT-011).
+ */
+import { spawnSync } from "node:child_process";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { getStateDir } from "../../store.js";
+import { defaultEventsPath, logBenchEvent } from "../../monitoring.js";
+const HERE = dirname(fileURLToPath(import.meta.url));
+const REPO_ROOT = join(HERE, "..", "..", "..");
+const BENCH_SCRIPT = join(REPO_ROOT, "scripts", "ml5", "bench-onnx-prod.mjs");
+/** Default events.log beside the state dir (mirrors defaultEventsPath). */
+function benchEventsPath(stateDir) {
+    return defaultEventsPath(stateDir);
+}
+/**
+ * Run the ONNX bench once and record its four events. Returns the parsed
+ * BenchResultV1. On any failure (script missing, non-zero exit, unparsable
+ * output) it returns a degraded result with gates.all:false — never throws, so
+ * the caller's agent loop is never broken (non-fatal store/write contract).
+ */
+export function runBench(stateDir = getStateDir()) {
+    const noop = (error) => ({
+        timestamp: Date.now(),
+        platform: `${process.platform}-${process.arch}`,
+        encoderNative: false,
+        threads: 4,
+        tokens: 512,
+        corpusTokens: 0,
+        p95Ms: null,
+        rssMib: null,
+        rssBaselineMib: null,
+        rssMarginalMib: null,
+        opset: null,
+        deterministic: false,
+        digest: null,
+        gates: { latency: false, rss: false, opset: false, determinism: false, all: false },
+        error,
+    });
+    const fallback = (error) => {
+        const r = noop(error);
+        emitEvents(stateDir, r);
+        return r;
+    };
+    try {
+        const res = spawnSync(process.execPath, ["--expose-gc", BENCH_SCRIPT], {
+            cwd: REPO_ROOT,
+            encoding: "utf8",
+            timeout: 600_000,
+        });
+        const stdout = (res.stdout ?? "").trim();
+        if (res.status === null) {
+            return fallback("bench timed out or failed to spawn");
+        }
+        const parsed = JSON.parse(stdout || "");
+        if (!isBenchResultV1(parsed)) {
+            return fallback("bench output was not a BenchResultV1");
+        }
+        emitEvents(stateDir, parsed);
+        return parsed;
+    }
+    catch (e) {
+        return fallback(`bench failed: ${e?.message ?? String(e)}`);
+    }
+}
+function isBenchResultV1(v) {
+    if (typeof v !== "object" || v === null)
+        return false;
+    const o = v;
+    return (typeof o.timestamp === "number" &&
+        typeof o.platform === "string" &&
+        typeof o.encoderNative === "boolean" &&
+        typeof o.threads === "number" &&
+        typeof o.tokens === "number" &&
+        typeof o.corpusTokens === "number" &&
+        typeof o.gates === "object" && o.gates !== null &&
+        typeof o.gates.all === "boolean");
+}
+function emitEvents(stateDir, r) {
+    const path = benchEventsPath(stateDir);
+    const run = { platform: r.platform, encoderNative: r.encoderNative, threads: r.threads, tokens: r.tokens, digest: r.digest, corpusTokens: r.corpusTokens };
+    logBenchEvent(path, "vector_cortex_encoder_bench_p95_ms", { ...run, p95Ms: r.p95Ms, pass: r.gates.latency });
+    logBenchEvent(path, "vector_cortex_encoder_bench_rss_mib", { ...run, rssMib: r.rssMib, rssBaselineMib: r.rssBaselineMib, rssMarginalMib: r.rssMarginalMib, pass: r.gates.rss });
+    logBenchEvent(path, "vector_cortex_encoder_bench_opset_ok", { ...run, opset: r.opset, pass: r.gates.opset });
+    logBenchEvent(path, "vector_cortex_encoder_bench_deterministic", { ...run, deterministic: r.deterministic, pass: r.gates.determinism });
+}

package/dist/vector-cortex/encoder/bench-export.js

@@ -0,0 +1,13 @@
+/**
+ * vector-cortex/encoder/bench-export.ts — ML5-B bench result contract.
+ *
+ * BenchResultV1 is the typed surface `bench.ts` parses from the qualification
+ * harness (`scripts/ml5/bench-onnx-prod.mjs`) and the dashboard / evidence
+ * tooling consume. It carries AGGREGATE measurements + a digest only — never
+ * chunk/message content (EVAL-REDACT-002).
+ *
+ * Contract-first (ENGINEERING_PRACTICES §3): this types file is the reviewed
+ * gate; implementations import from it. Pi-agnostic, dependency-free
+ * (PREVENT-PI-004 / PREVENT-011).
+ */
+export {};

package/dist/vector-cortex/encoder/bench.js

@@ -0,0 +1,100 @@
+/**
+ * vector-cortex/encoder/bench.ts — ML5-B bench runner (consumer-facing shell).
+ *
+ * Calls `scripts/ml5/bench-onnx-prod.mjs` via child_process, parses the
+ * BenchResultV1 it emits, and writes the four `vector_cortex_encoder_bench_*`
+ * events to the monitoring events.log (the dashboard / ML5-D surface consume
+ * them later). This is NOT a runtime path — it is developer/evidence tooling.
+ *
+ * Events written (all best-effort / non-fatal):
+ *   - vector_cortex_encoder_bench_p95_ms
+ *   - vector_cortex_encoder_bench_rss_mib
+ *   - vector_cortex_encoder_bench_opset_ok
+ *   - vector_cortex_encoder_bench_deterministic
+ *
+ * Pi-agnostic, dependency-free (PREVENT-PI-004 — the child bench is pure local
+ * computation). No `any` (PREVENT-011).
+ */
+import { spawnSync } from "node:child_process";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { getStateDir } from "../../store.js";
+import { defaultEventsPath, logBenchEvent } from "../../monitoring.js";
+const HERE = dirname(fileURLToPath(import.meta.url));
+const REPO_ROOT = join(HERE, "..", "..", "..");
+const BENCH_SCRIPT = join(REPO_ROOT, "scripts", "ml5", "bench-onnx-prod.mjs");
+/** Default events.log beside the state dir (mirrors defaultEventsPath). */
+function benchEventsPath(stateDir) {
+    return defaultEventsPath(stateDir);
+}
+/**
+ * Run the ONNX bench once and record its four events. Returns the parsed
+ * BenchResultV1. On any failure (script missing, non-zero exit, unparsable
+ * output) it returns a degraded result with gates.all:false — never throws, so
+ * the caller's agent loop is never broken (non-fatal store/write contract).
+ */
+export function runBench(stateDir = getStateDir()) {
+    const noop = (error) => ({
+        timestamp: Date.now(),
+        platform: `${process.platform}-${process.arch}`,
+        encoderNative: false,
+        threads: 4,
+        tokens: 512,
+        corpusTokens: 0,
+        p95Ms: null,
+        rssMib: null,
+        rssBaselineMib: null,
+        rssMarginalMib: null,
+        opset: null,
+        deterministic: false,
+        digest: null,
+        gates: { latency: false, rss: false, opset: false, determinism: false, all: false },
+        error,
+    });
+    const fallback = (error) => {
+        const r = noop(error);
+        emitEvents(stateDir, r);
+        return r;
+    };
+    try {
+        const res = spawnSync(process.execPath, ["--expose-gc", BENCH_SCRIPT], {
+            cwd: REPO_ROOT,
+            encoding: "utf8",
+            timeout: 600_000,
+        });
+        const stdout = (res.stdout ?? "").trim();
+        if (res.status === null) {
+            return fallback("bench timed out or failed to spawn");
+        }
+        const parsed = JSON.parse(stdout || "");
+        if (!isBenchResultV1(parsed)) {
+            return fallback("bench output was not a BenchResultV1");
+        }
+        emitEvents(stateDir, parsed);
+        return parsed;
+    }
+    catch (e) {
+        return fallback(`bench failed: ${e?.message ?? String(e)}`);
+    }
+}
+function isBenchResultV1(v) {
+    if (typeof v !== "object" || v === null)
+        return false;
+    const o = v;
+    return (typeof o.timestamp === "number" &&
+        typeof o.platform === "string" &&
+        typeof o.encoderNative === "boolean" &&
+        typeof o.threads === "number" &&
+        typeof o.tokens === "number" &&
+        typeof o.corpusTokens === "number" &&
+        typeof o.gates === "object" && o.gates !== null &&
+        typeof o.gates.all === "boolean");
+}
+function emitEvents(stateDir, r) {
+    const path = benchEventsPath(stateDir);
+    const run = { platform: r.platform, encoderNative: r.encoderNative, threads: r.threads, tokens: r.tokens, digest: r.digest, corpusTokens: r.corpusTokens };
+    logBenchEvent(path, "vector_cortex_encoder_bench_p95_ms", { ...run, p95Ms: r.p95Ms, pass: r.gates.latency });
+    logBenchEvent(path, "vector_cortex_encoder_bench_rss_mib", { ...run, rssMib: r.rssMib, rssBaselineMib: r.rssBaselineMib, rssMarginalMib: r.rssMarginalMib, pass: r.gates.rss });
+    logBenchEvent(path, "vector_cortex_encoder_bench_opset_ok", { ...run, opset: r.opset, pass: r.gates.opset });
+    logBenchEvent(path, "vector_cortex_encoder_bench_deterministic", { ...run, deterministic: r.deterministic, pass: r.gates.determinism });
+}

package/dist/vectorStore/dedup-audit.js

@@ -0,0 +1,104 @@
+/**
+ * dedup-audit.ts — durable audit trail for dedup tier decisions
+ * (external-audit item #2).
+ *
+ * Before this module a tier decision existed only as the in-process `onTier`
+ * callback that paints the live UI; nothing survived the process, so an
+ * operator could not answer "which layer collapsed this region, onto what, at
+ * what similarity?" — the inputs needed to tune the thresholds in
+ * config/dedup.ts. Here each decision is appended to the repo's events.log as
+ * one structured JSON line (see `DedupAuditEvent` below).
+ *
+ * The event type and its append helper live HERE rather than in monitoring.ts:
+ * monitoring.ts already owns three concerns (decision events, the dashboard.json
+ * metrics snapshot, FP alerting) and sits close to its 300-line soft limit, so
+ * co-locating the shape with the only recorder that produces it keeps both files
+ * under the headroom gate. monitoring.ts re-exports both for callers (and the
+ * dashboard SSE tail) that treat it as the events.log barrel.
+ *
+ * Design constraints:
+ *  - PURE INSTRUMENTATION. Nothing in this file may influence a dedup outcome.
+ *  - Best-effort/non-fatal: `logDedupAudit` swallows IO errors, and the emitter
+ *    itself is wrapped so a malformed field can never break add().
+ *  - Honest fields only: a value is emitted only where the caller actually
+ *    computed it. L0/L1 are hash/verify tiers and pass no `similarity`.
+ *  - Signal, not chatter: callers emit on DECISIONS (a match, a scored
+ *    candidate, the final outcome), never on every "scanning" transition.
+ *  - Flag-gated by cfg.DEDUP_AUDIT (default ON; OFF writes nothing at all).
+ *
+ * PREVENT-PI-004: local filesystem append only, no network.
+ */
+import { appendFileSync, mkdirSync } from "node:fs";
+import { dirname } from "node:path";
+import { defaultEventsPath } from "../monitoring.js";
+/**
+ * Append one audit event to events.log (best-effort, never throws).
+ *
+ * Same append-one-JSON-line contract as monitoring.ts's logDecision — an
+ * unwritable path is swallowed so instrumentation can never break add().
+ */
+export function logDedupAudit(path, ev) {
+    try {
+        mkdirSync(dirname(path), { recursive: true });
+        appendFileSync(path, `${JSON.stringify(ev)}\n`, "utf-8");
+    }
+    catch {
+        /* best-effort — never break the extension on a log failure */
+    }
+}
+/** Build a recorder bound to one add() cascade. */
+export function dedupAuditRecorder(ctx, scope) {
+    const base = {
+        sessionId: scope.sessionId,
+        originalTokenEstimate: scope.originalTokenEstimate,
+        tokenEstimate: scope.tokenEstimate,
+    };
+    return {
+        deduped: (tier, matchedEntry, dedupReason, similarity) => emitDedupAudit(ctx, {
+            ...base,
+            tier,
+            status: "deduped",
+            matchedEntry,
+            dedupReason,
+            ...(similarity === undefined ? {} : { similarity }),
+        }),
+        passed: (tier, matchedEntry, similarity) => emitDedupAudit(ctx, {
+            ...base,
+            tier,
+            status: "passed",
+            matchedEntry,
+            similarity,
+        }),
+        stored: (storedEntry, dedupReason, tokenEstimate) => emitDedupAudit(ctx, {
+            ...base,
+            tier: "new",
+            status: "stored",
+            storedEntry,
+            dedupReason,
+            tokenEstimate,
+        }),
+    };
+}
+/**
+ * Append one dedup decision to events.log.
+ *
+ * Resolves the target path from the explicit `eventsPath` when a caller opted
+ * in (Sprint 14 monitoring / tests), otherwise from the store's own per-repo
+ * state dir — production never passes `eventsPath`, so defaulting is what makes
+ * the audit trail actually exist on a real device.
+ */
+export function emitDedupAudit(ctx, input) {
+    if (!ctx.auditEnabled)
+        return;
+    try {
+        const path = ctx.eventsPath ?? defaultEventsPath(ctx.stateDir);
+        logDedupAudit(path, {
+            type: "dedup_audit",
+            ts: new Date().toISOString(),
+            ...input,
+        });
+    }
+    catch {
+        /* instrumentation must never break the add() path */
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-mega-compact",
-  "version": "0.20.36",
+  "version": "0.20.38",
   "description": "Layered, local, vector-backed context compressor for pi — supersede/collapse/cluster compaction with deduped inline recall.",
   "type": "module",
   "license": "BSD-3-Clause",

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

@@ -0,0 +1,28 @@
+/**
+ * config/vector-cortex-ml5b.ts — ML5-B production bench harness flag.
+ *
+ * Sibling extract mirroring vector-cortex-ml5a.ts, so vector-cortex.ts stays
+ * under its 300-line soft limit (soft-as-hard gate). This is the ONNX Runtime
+ * evaluation/benchmark 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-B introduces NO runtime code path: the bench harness and corpus export
+ * are developer/evidence tooling (scripts/) plus a consumer-facing TypeScript
+ * shell (src/vector-cortex/encoder/bench.ts) that only writes monitoring
+ * events. The flag records intent and scopes the sprint's evidence assets; it
+ * gates nothing at runtime today. There is no HTTP endpoint and no dashboard
+ * change, so there is no SETTINGS toggle and no EXCLUDED_SETTINGS interaction.
+ *
+ * Pi-agnostic, dependency-free (PREVENT-PI-004 / PREVENT-011).
+ */
+
+import { sprintFlag } from "./vector-cortex-flag.js";
+
+/**
+ * ML5-B — production bench harness (ONNX Runtime eval). Default ON.
+ * `MEGACOMPACT_ML5_B=0` disables and is byte-identical to the ML5-A survivor:
+ * no bench endpoint exists and mode B continues to serve all clients exactly as
+ * before. The flag does not gate the harness itself — the harness is an on-demand
+ * developer tool with no runtime path.
+ */
+export const ML5B_ENABLED = (): boolean => sprintFlag("MEGACOMPACT_ML5_B");

package/src/config/vector-cortex.ts

@@ -280,6 +280,7 @@ export { VC9C_ENABLED } from "./vector-cortex-vc9c.js";
 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";
 
 // Breaker constants (TRIAD_RESILIENCE.md §breaker) extracted to vector-cortex-breakers.ts.
 export {

package/src/config.ts

@@ -184,6 +184,7 @@ export {
   VC9D_ENABLED,
   PCC_ENABLED,
   ML5A_ENABLED,
+  ML5B_ENABLED,
   BREAKER_WINDOW_MS,
   BREAKER_MIN_ATTEMPTS,
   BREAKER_PERF_FAILURES,

package/src/monitoring.ts

@@ -205,6 +205,30 @@ export function logRecallQuality(path: string, ev: RecallQualityEvent): void {
   }
 }
 
+// ---------------------------------------------------------------------------
+// ML5-B encoder bench events (consumer-facing for the dashboard + evidence)
+// ---------------------------------------------------------------------------
+
+/**
+ * Append a structured ML5-B bench event to events.log (best-effort, non-fatal).
+ * Mirrors the extension's appendEvent schema ({ ts, event, ...fields }) so the
+ * dashboard live-stream tail and evidence tooling parse the four
+ * `vector_cortex_encoder_bench_*` events identically. The bench is developer/
+ * evidence tooling with no runtime gating; this only records its results.
+ */
+export function logBenchEvent(
+  path: string,
+  event: string,
+  fields: Record<string, unknown>,
+): void {
+  try {
+    mkdirSync(dirname(path), { recursive: true });
+    appendFileSync(path, JSON.stringify({ ts: Date.now(), event, ...fields }) + "\n", "utf8");
+  } catch {
+    /* best-effort — never break the caller */
+  }
+}
+
 // ---------------------------------------------------------------------------
 // Dedup audit trail (external-audit item #2)
 // ---------------------------------------------------------------------------

package/src/store/backfill.ts

@@ -134,6 +134,7 @@ export function backfillContentHashes(stateDir: string = getStateDir()): Backfil
 
   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 };

package/src/vector-cortex/encoder/bench-export.ts

@@ -0,0 +1,65 @@
+/**
+ * vector-cortex/encoder/bench-export.ts — ML5-B bench result contract.
+ *
+ * BenchResultV1 is the typed surface `bench.ts` parses from the qualification
+ * harness (`scripts/ml5/bench-onnx-prod.mjs`) and the dashboard / evidence
+ * tooling consume. It carries AGGREGATE measurements + a digest only — never
+ * chunk/message content (EVAL-REDACT-002).
+ *
+ * Contract-first (ENGINEERING_PRACTICES §3): this types file is the reviewed
+ * gate; implementations import from it. Pi-agnostic, dependency-free
+ * (PREVENT-PI-004 / PREVENT-011).
+ */
+
+/** The four ML5-B bench gates, each independently measured. */
+export interface BenchGatesV1 {
+  /** p95 latency at 512 tokens on `threads` threads <= 40 ms. */
+  readonly latency: boolean;
+  /** steady-state marginal RSS over the process baseline <= 150 MiB. */
+  readonly rss: boolean;
+  /** the loaded model's declared opset_import equals 17. */
+  readonly opset: boolean;
+  /** SHA-256 of the embedding output identical across 3 runs (maxAbsDelta=0). */
+  readonly determinism: boolean;
+  /** conjunctive: every gate passed. */
+  readonly all: boolean;
+}
+
+/**
+ * BenchResultV1 — one qualification run of the ONNX encoder bench.
+ *
+ * Shape is fixed by the ML5-B spec (task 4). `p95Ms`/`rssMib`/`rssMarginalMib`/
+ * `digest` are null when the runtime package is absent (degraded run) or a
+ * gate could not be measured; `gates.all` is false in that case and `error`
+ * (optional) records the honest degradation reason.
+ */
+export interface BenchResultV1 {
+  readonly timestamp: number;
+  /** `${process.platform}-${process.arch}` (e.g. linux-x64, darwin-arm64). */
+  readonly platform: string;
+  /** true = onnxruntime-node (native); false = onnxruntime-web (WASM). */
+  readonly encoderNative: boolean;
+  /** intraOpNumThreads used for the latency gate (normative 4). */
+  readonly threads: number;
+  /** token count per inference (normative 512). */
+  readonly tokens: number;
+  /** total tokens in the corpus the bench streamed over. */
+  readonly corpusTokens: number;
+  /** p95 latency in ms (null on degraded/absent runtime). */
+  readonly p95Ms: number | null;
+  /** steady-state RSS (MiB) over the process baseline, post-GC. */
+  readonly rssMib: number | null;
+  /** RSS (MiB) sampled at process start before loading the encoder. */
+  readonly rssBaselineMib: number | null;
+  /** rssMib - rssBaselineMib: the encoder's marginal footprint. */
+  readonly rssMarginalMib: number | null;
+  /** declared opset_import (17); null when no asset manifest is readable. */
+  readonly opset: number | null;
+  /** true when the output SHA-256 is identical across 3 runs. */
+  readonly deterministic: boolean;
+  /** SHA-256 of the embedding output buffer (null on degraded/absent). */
+  readonly digest: string | null;
+  readonly gates: BenchGatesV1;
+  /** Optional: honest degradation / failure reason (no runtime package, etc.). */
+  readonly error?: string;
+}

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

@@ -0,0 +1,109 @@
+/**
+ * vector-cortex/encoder/bench.ts — ML5-B bench runner (consumer-facing shell).
+ *
+ * Calls `scripts/ml5/bench-onnx-prod.mjs` via child_process, parses the
+ * BenchResultV1 it emits, and writes the four `vector_cortex_encoder_bench_*`
+ * events to the monitoring events.log (the dashboard / ML5-D surface consume
+ * them later). This is NOT a runtime path — it is developer/evidence tooling.
+ *
+ * Events written (all best-effort / non-fatal):
+ *   - vector_cortex_encoder_bench_p95_ms
+ *   - vector_cortex_encoder_bench_rss_mib
+ *   - vector_cortex_encoder_bench_opset_ok
+ *   - vector_cortex_encoder_bench_deterministic
+ *
+ * Pi-agnostic, dependency-free (PREVENT-PI-004 — the child bench is pure local
+ * computation). No `any` (PREVENT-011).
+ */
+
+import { spawnSync } from "node:child_process";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { getStateDir } from "../../store.js";
+import { defaultEventsPath, logBenchEvent } from "../../monitoring.js";
+import type { BenchResultV1 } from "./bench-export.js";
+
+const HERE = dirname(fileURLToPath(import.meta.url));
+const REPO_ROOT = join(HERE, "..", "..", "..");
+const BENCH_SCRIPT = join(REPO_ROOT, "scripts", "ml5", "bench-onnx-prod.mjs");
+
+/** Default events.log beside the state dir (mirrors defaultEventsPath). */
+function benchEventsPath(stateDir: string): string {
+  return defaultEventsPath(stateDir);
+}
+
+/**
+ * Run the ONNX bench once and record its four events. Returns the parsed
+ * BenchResultV1. On any failure (script missing, non-zero exit, unparsable
+ * output) it returns a degraded result with gates.all:false — never throws, so
+ * the caller's agent loop is never broken (non-fatal store/write contract).
+ */
+export function runBench(stateDir: string = getStateDir()): BenchResultV1 {
+  const noop = (error: string): BenchResultV1 => ({
+    timestamp: Date.now(),
+    platform: `${process.platform}-${process.arch}`,
+    encoderNative: false,
+    threads: 4,
+    tokens: 512,
+    corpusTokens: 0,
+    p95Ms: null,
+    rssMib: null,
+    rssBaselineMib: null,
+    rssMarginalMib: null,
+    opset: null,
+    deterministic: false,
+    digest: null,
+    gates: { latency: false, rss: false, opset: false, determinism: false, all: false },
+    error,
+  });
+
+  const fallback = (error: string): BenchResultV1 => {
+    const r = noop(error);
+    emitEvents(stateDir, r);
+    return r;
+  };
+
+  try {
+    const res = spawnSync(process.execPath, ["--expose-gc", BENCH_SCRIPT], {
+      cwd: REPO_ROOT,
+      encoding: "utf8",
+      timeout: 600_000,
+    });
+    const stdout = (res.stdout ?? "").trim();
+    if (res.status === null) {
+      return fallback("bench timed out or failed to spawn");
+    }
+    const parsed: unknown = JSON.parse(stdout || "");
+    if (!isBenchResultV1(parsed)) {
+      return fallback("bench output was not a BenchResultV1");
+    }
+    emitEvents(stateDir, parsed);
+    return parsed;
+  } catch (e) {
+    return fallback(`bench failed: ${(e as Error)?.message ?? String(e)}`);
+  }
+}
+
+function isBenchResultV1(v: unknown): v is BenchResultV1 {
+  if (typeof v !== "object" || v === null) return false;
+  const o = v as Record<string, unknown>;
+  return (
+    typeof o.timestamp === "number" &&
+    typeof o.platform === "string" &&
+    typeof o.encoderNative === "boolean" &&
+    typeof o.threads === "number" &&
+    typeof o.tokens === "number" &&
+    typeof o.corpusTokens === "number" &&
+    typeof o.gates === "object" && o.gates !== null &&
+    typeof (o.gates as Record<string, unknown>).all === "boolean"
+  );
+}
+
+function emitEvents(stateDir: string, r: BenchResultV1): void {
+  const path = benchEventsPath(stateDir);
+  const run = { platform: r.platform, encoderNative: r.encoderNative, threads: r.threads, tokens: r.tokens, digest: r.digest, corpusTokens: r.corpusTokens };
+  logBenchEvent(path, "vector_cortex_encoder_bench_p95_ms", { ...run, p95Ms: r.p95Ms, pass: r.gates.latency });
+  logBenchEvent(path, "vector_cortex_encoder_bench_rss_mib", { ...run, rssMib: r.rssMib, rssBaselineMib: r.rssBaselineMib, rssMarginalMib: r.rssMarginalMib, pass: r.gates.rss });
+  logBenchEvent(path, "vector_cortex_encoder_bench_opset_ok", { ...run, opset: r.opset, pass: r.gates.opset });
+  logBenchEvent(path, "vector_cortex_encoder_bench_deterministic", { ...run, deterministic: r.deterministic, pass: r.gates.determinism });
+}