pi-mega-compact 0.20.35 → 0.20.38

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

@@ -19,6 +19,8 @@
  *
  * Pi-agnostic, zero network (PREVENT-PI-004), no `any` (PREVENT-011).
  */
+import { readFileSync } from "node:fs";
+import { ML5A_ENABLED } from "../../config/vector-cortex.js";
 import { ENCODER_HEAD_DIMS, ENCODER_HEAD_ORDER, ENCODER_HEAD_LOSS_WEIGHTS, ENCODER_HEAD_LOSS_SUM, ENCODER_SEED, } from "./types.js";
 import { createEncoderHeadsReporter, NOOP_VC2B_REPORTER, } from "./emit-vc2b.js";
 /** The stable head index of a head name (its position in ENCODER_HEAD_ORDER). */
@@ -110,4 +112,89 @@ export function encodeVectorSet(tokens, options = {}) {
 export function headLossWeights() {
     return { ...ENCODER_HEAD_LOSS_WEIGHTS };
 }
+/** True when every head's output dim + weight length matches the contract. */
+export function headsShapeValid(t) {
+    return ENCODER_HEAD_ORDER.every((h) => t.dims[h] === ENCODER_HEAD_DIMS[h] && t.weights[h].length === ENCODER_HEAD_DIMS[h] * t.trunkDim);
+}
+/**
+ * Load a `trained-heads-v1` artifact into a `HeadProjectionTable`. Gated on
+ * MEGACOMPACT_ML5_A: flag-off, absent file, malformed JSON, wrong schema,
+ * wrong seed, or a shape mismatch each return null (non-fatal). Deterministic
+ * and local (PREVENT-PI-004).
+ */
+export function loadHeadProjections(path) {
+    if (!ML5A_ENABLED())
+        return null;
+    let raw;
+    try {
+        raw = readFileSync(path, "utf8");
+    }
+    catch {
+        return null;
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+    const r = parsed;
+    if (!r || r["schema"] !== "trained-heads-v1")
+        return null;
+    if (r["seed"] !== ENCODER_SEED)
+        return null;
+    const dims = r["dims"];
+    const heads = r["heads"];
+    if (!dims || !heads)
+        return null;
+    const trunkDim = Number(r["trunkDim"] ?? 0);
+    if (!Number.isFinite(trunkDim) || trunkDim <= 0)
+        return null;
+    const weights = {};
+    const temperatures = {};
+    for (const h of ENCODER_HEAD_ORDER) {
+        const hd = heads[h];
+        if (!hd || typeof hd !== "object")
+            return null;
+        const w = hd["weights"];
+        if (!Array.isArray(w))
+            return null;
+        weights[h] = Float32Array.from(w);
+        if (Number(hd["dim"] ?? 0) !== ENCODER_HEAD_DIMS[h])
+            return null;
+        temperatures[h] = Number(hd["temperature"] ?? 1);
+        if (!Number.isFinite(dims[h]))
+            return null;
+    }
+    const table = {
+        schema: "trained-heads-v1",
+        seed: Number(r["seed"]),
+        trunkDim,
+        dims: { semantic: 384, dependency: 128, contradiction: 128, cacheStability: 64, payloadRouting: 32 },
+        weights: weights,
+        temperatures: temperatures,
+    };
+    if (!headsShapeValid(table))
+        return null;
+    return table;
+}
+/**
+ * Project a trunk embedding through a trained head's real weights, applying the
+ * row-major matrix then L2-normalizing (all-zero on zero norm). Returns a
+ * `HeadVector` of the head's normative dimension.
+ */
+export function projectHeadFromTrunk(head, trunk, table) {
+    const dim = ENCODER_HEAD_DIMS[head];
+    const W = table.weights[head];
+    const t = table.trunkDim;
+    const out = new Float32Array(dim);
+    for (let i = 0; i < dim; i++) {
+        let acc = 0;
+        for (let j = 0; j < t; j++)
+            acc += W[i * t + j] * (trunk[j] ?? 0);
+        out[i] = acc;
+    }
+    return { head, dim, values: l2Normalize(out) };
+}
 export { ENCODER_HEAD_ORDER, ENCODER_HEAD_DIMS, ENCODER_HEAD_LOSS_SUM, ENCODER_SEED, NOOP_VC2B_REPORTER };

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

@@ -33,6 +33,8 @@
  * `any` (PREVENT-011).
  */
 import { createHash } from "node:crypto";
+import { ML5A_ENABLED } from "../../config/vector-cortex.js";
+import { loadHeadProjections } from "./heads.js";
 import { ENC_QUALIFICATION_FAIL, EVALUATION_THRESHOLDS, } from "./types.js";
 import { createEncoderQualificationReporter, } from "./emit-vc2c.js";
 /** Canonical digest over a CalibrationV1's stable identity (split digest, heads,
@@ -118,6 +120,14 @@ export function selectQualifiedEncoder(candidate, options = {}) {
     }
     // Atomic: collect EVERY failed field across asset + all heads + reconstruction.
     const failed = [];
+    // ML5-A: real trained-head weights must load for mode A. When the gate is on
+    // and a trained-heads path is pinned, an unloadable/wrong-seed/malformed
+    // artifact is a qualification failure (any failed field demotes ALL of A).
+    if (ML5A_ENABLED() && candidate.trainedHeadsPath !== undefined) {
+        if (loadHeadProjections(candidate.trainedHeadsPath) === null) {
+            failed.push("head.weights.trainedHeadsPath");
+        }
+    }
     assetPasses(candidate.asset, failed);
     const heads = ["semantic", "dependency", "contradiction", "cacheStability", "payloadRouting"];
     for (const h of heads) {

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/vector-cortex/encoder/calibrate.js

@@ -22,6 +22,8 @@
  * (PREVENT-011).
  */
 import { createHash } from "node:crypto";
+import { readFileSync } from "node:fs";
+import { ML5A_ENABLED } from "../../config/vector-cortex.js";
 import { ENCODER_HEAD_ORDER, ENCODER_SEED, ENC_QUALIFICATION_FAIL, } from "./types.js";
 /** Canonical digests of a sorted stable representation (order-invariant). */
 function digestStrings(values) {
@@ -172,3 +174,56 @@ export function fitCalibration(examples, options = {}) {
     };
     return { ok: true, calibration };
 }
+/**
+ * Load a persisted `CalibrationV1` artifact (schema "calibration-v1") from disk.
+ * ML5-A: gated on MEGACOMPACT_ML5_A; flag-off, absent file, malformed JSON,
+ * wrong schema, non-canonical five-head order, or non-finite temp/threshold each
+ * return null (non-fatal, never throws). Deterministic, local (PREVENT-PI-004).
+ */
+export function loadCalibrationV1(path) {
+    if (!ML5A_ENABLED())
+        return null;
+    let raw;
+    try {
+        raw = readFileSync(path, "utf8");
+    }
+    catch {
+        return null;
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+    const r = parsed;
+    if (!r || r["schema"] !== "calibration-v1")
+        return null;
+    const order = r["headOrder"];
+    if (!Array.isArray(order))
+        return null;
+    if (order.length !== ENCODER_HEAD_ORDER.length || !ENCODER_HEAD_ORDER.every((h, i) => order[i] === h)) {
+        return null;
+    }
+    const temperatures = r["temperatures"];
+    const thresholds = r["thresholds"];
+    const splitDigest = r["calibrationSplitDigest"];
+    if (!temperatures || !thresholds || typeof splitDigest !== "string" || splitDigest.length !== 64)
+        return null;
+    for (const h of ENCODER_HEAD_ORDER) {
+        const t = Number(temperatures[h]);
+        const th = Number(thresholds[h]);
+        if (!Number.isFinite(t) || !Number.isFinite(th))
+            return null;
+    }
+    return {
+        schema: "calibration-v1",
+        headOrder: [...ENCODER_HEAD_ORDER],
+        calibrationSplitDigest: splitDigest,
+        fittedOnCalibrationOnly: true,
+        temperatures: { ...temperatures },
+        thresholds: { ...thresholds },
+        seed: Number(r["seed"] ?? ENCODER_SEED),
+    };
+}

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

@@ -19,6 +19,8 @@
  *
  * Pi-agnostic, zero network (PREVENT-PI-004), no `any` (PREVENT-011).
  */
+import { readFileSync } from "node:fs";
+import { ML5A_ENABLED } from "../../config/vector-cortex.js";
 import { ENCODER_HEAD_DIMS, ENCODER_HEAD_ORDER, ENCODER_HEAD_LOSS_WEIGHTS, ENCODER_HEAD_LOSS_SUM, ENCODER_SEED, } from "./types.js";
 import { createEncoderHeadsReporter, NOOP_VC2B_REPORTER, } from "./emit-vc2b.js";
 /** The stable head index of a head name (its position in ENCODER_HEAD_ORDER). */
@@ -110,4 +112,89 @@ export function encodeVectorSet(tokens, options = {}) {
 export function headLossWeights() {
     return { ...ENCODER_HEAD_LOSS_WEIGHTS };
 }
+/** True when every head's output dim + weight length matches the contract. */
+export function headsShapeValid(t) {
+    return ENCODER_HEAD_ORDER.every((h) => t.dims[h] === ENCODER_HEAD_DIMS[h] && t.weights[h].length === ENCODER_HEAD_DIMS[h] * t.trunkDim);
+}
+/**
+ * Load a `trained-heads-v1` artifact into a `HeadProjectionTable`. Gated on
+ * MEGACOMPACT_ML5_A: flag-off, absent file, malformed JSON, wrong schema,
+ * wrong seed, or a shape mismatch each return null (non-fatal). Deterministic
+ * and local (PREVENT-PI-004).
+ */
+export function loadHeadProjections(path) {
+    if (!ML5A_ENABLED())
+        return null;
+    let raw;
+    try {
+        raw = readFileSync(path, "utf8");
+    }
+    catch {
+        return null;
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+    const r = parsed;
+    if (!r || r["schema"] !== "trained-heads-v1")
+        return null;
+    if (r["seed"] !== ENCODER_SEED)
+        return null;
+    const dims = r["dims"];
+    const heads = r["heads"];
+    if (!dims || !heads)
+        return null;
+    const trunkDim = Number(r["trunkDim"] ?? 0);
+    if (!Number.isFinite(trunkDim) || trunkDim <= 0)
+        return null;
+    const weights = {};
+    const temperatures = {};
+    for (const h of ENCODER_HEAD_ORDER) {
+        const hd = heads[h];
+        if (!hd || typeof hd !== "object")
+            return null;
+        const w = hd["weights"];
+        if (!Array.isArray(w))
+            return null;
+        weights[h] = Float32Array.from(w);
+        if (Number(hd["dim"] ?? 0) !== ENCODER_HEAD_DIMS[h])
+            return null;
+        temperatures[h] = Number(hd["temperature"] ?? 1);
+        if (!Number.isFinite(dims[h]))
+            return null;
+    }
+    const table = {
+        schema: "trained-heads-v1",
+        seed: Number(r["seed"]),
+        trunkDim,
+        dims: { semantic: 384, dependency: 128, contradiction: 128, cacheStability: 64, payloadRouting: 32 },
+        weights: weights,
+        temperatures: temperatures,
+    };
+    if (!headsShapeValid(table))
+        return null;
+    return table;
+}
+/**
+ * Project a trunk embedding through a trained head's real weights, applying the
+ * row-major matrix then L2-normalizing (all-zero on zero norm). Returns a
+ * `HeadVector` of the head's normative dimension.
+ */
+export function projectHeadFromTrunk(head, trunk, table) {
+    const dim = ENCODER_HEAD_DIMS[head];
+    const W = table.weights[head];
+    const t = table.trunkDim;
+    const out = new Float32Array(dim);
+    for (let i = 0; i < dim; i++) {
+        let acc = 0;
+        for (let j = 0; j < t; j++)
+            acc += W[i * t + j] * (trunk[j] ?? 0);
+        out[i] = acc;
+    }
+    return { head, dim, values: l2Normalize(out) };
+}
 export { ENCODER_HEAD_ORDER, ENCODER_HEAD_DIMS, ENCODER_HEAD_LOSS_SUM, ENCODER_SEED, NOOP_VC2B_REPORTER };

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

@@ -33,6 +33,8 @@
  * `any` (PREVENT-011).
  */
 import { createHash } from "node:crypto";
+import { ML5A_ENABLED } from "../../config/vector-cortex.js";
+import { loadHeadProjections } from "./heads.js";
 import { ENC_QUALIFICATION_FAIL, EVALUATION_THRESHOLDS, } from "./types.js";
 import { createEncoderQualificationReporter, } from "./emit-vc2c.js";
 /** Canonical digest over a CalibrationV1's stable identity (split digest, heads,
@@ -118,6 +120,14 @@ export function selectQualifiedEncoder(candidate, options = {}) {
     }
     // Atomic: collect EVERY failed field across asset + all heads + reconstruction.
     const failed = [];
+    // ML5-A: real trained-head weights must load for mode A. When the gate is on
+    // and a trained-heads path is pinned, an unloadable/wrong-seed/malformed
+    // artifact is a qualification failure (any failed field demotes ALL of A).
+    if (ML5A_ENABLED() && candidate.trainedHeadsPath !== undefined) {
+        if (loadHeadProjections(candidate.trainedHeadsPath) === null) {
+            failed.push("head.weights.trainedHeadsPath");
+        }
+    }
     assetPasses(candidate.asset, failed);
     const heads = ["semantic", "dependency", "contradiction", "cacheStability", "payloadRouting"];
     for (const h of heads) {

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/extensions/dashboard-server/routes-rag-settings-vector-cortex.ts

@@ -222,5 +222,11 @@ export const VECTOR_CORTEX_SETTINGS: SettingGroup = {
 			"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,
+		),
 	],
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-mega-compact",
-  "version": "0.20.35",
+  "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-ml5a.ts

@@ -0,0 +1,30 @@
+/**
+ * config/vector-cortex-ml5a.ts — ML5-A five-head training + calibration flag.
+ *
+ * Extracted from vector-cortex.ts so that file stays under the 300-line soft
+ * limit (soft-as-hard gate), exactly as vector-cortex-vc9a.ts..vector-cortex-vc9d.ts
+ * were. This is the ML5 training sprint flag. vector-cortex.ts re-exports the
+ * ENUM below and root src/config.ts re-exports it, so no consumer import path
+ * changes.
+ *
+ * The split is purely mechanical: ML5A_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";
+
+/**
+ * ML5-A — five-head training + calibrated onnx asset. Default ON.
+ * `MEGACOMPACT_ML5_A=0` disables and is byte-identical to the placeholder
+ * predecessor (VC2C-era): `calibrate.ts`/`heads.ts` keep serving the LCG fake
+ * projections and the placeholder `fitTemperature`/`fitThreshold`, mode B
+ * trigram continues serving, and no trained artifact is loaded (a fresh/no
+ * corpus also no-ops gracefully — asset_emitted:false, placeholder behavior,
+ * byte-identical). This flag MUST also be a dashboard SETTINGS toggle (visible
+ * in config UI, never in EXCLUDED_SETTINGS), mirroring VC4A..VC9D.
+ */
+export const ML5A_ENABLED = (): boolean => sprintFlag("MEGACOMPACT_ML5_A");

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

@@ -269,18 +269,18 @@ export const VC8A_ENABLED = (): boolean => sprintFlag("MEGACOMPACT_VC8A");
  */
 export const VC8B_ENABLED = (): boolean => sprintFlag("MEGACOMPACT_VC8B");
 
-// VC8C (canary selection + external Rust parity) extracted to
-// vector-cortex-vc8c.ts to keep this file under the 300-line soft limit.
-// Re-exported here so every existing `from "./config/vector-cortex.js"`
-// import keeps resolving unchanged.
+// 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 split to vector-cortex-vc9{a,b,c,d}.ts to stay under the 300-line soft limit.
+// VC9A/VC9B/VC9C/VC9D/PCC/ML5A split to sibling files 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";
 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

@@ -183,6 +183,8 @@ export {
   VC9C_ENABLED,
   VC9D_ENABLED,
   PCC_ENABLED,
+  ML5A_ENABLED,
+  ML5B_ENABLED,
   BREAKER_WINDOW_MS,
   BREAKER_MIN_ATTEMPTS,
   BREAKER_PERF_FAILURES,