pi-mega-compact 0.20.42 → 0.20.43

package/assets/vector-cortex/encoder-v1/manifest.json

@@ -1 +1 @@
-{"batch":1,"heads":{"cacheStability":64,"contradiction":128,"dependency":128,"payloadRouting":32,"semantic":384},"hiddenWidth":384,"maxTokens":512,"modelVersion":"encoder-v1-placeholder","onnx":{"bytes":42,"path":"model.onnx","sha256":"01cbed8b0b301609542ff8c392c3e7d927b0d848ac53a768dfffd33bfe6005ff"},"opset":17,"platform":"linux-x64","schema":"model-manifest-v1","semanticWidth":384,"tokenizer":{"bytes":8518,"path":"tokenizer.json","sha256":"ada18e5c4dfcb5c369c05f4ffc10bc40298ce707e78f16135c6d33019f6db8cd"},"totalBytes":8560,"trainingManifestDigest":"e9b2550dbb79141af84440dda65ca21d3509904b2c09a89316145137a5b5e3de"}
+{"batch":1,"heads":{"cacheStability":64,"contradiction":128,"dependency":128,"payloadRouting":32,"semantic":384},"hiddenWidth":384,"maxTokens":512,"modelVersion":"encoder-v1-placeholder","onnx":{"bytes":42,"path":"model.onnx","sha256":"01cbed8b0b301609542ff8c392c3e7d927b0d848ac53a768dfffd33bfe6005ff"},"opset":21,"platform":"linux-x64","schema":"model-manifest-v1","semanticWidth":384,"tokenizer":{"bytes":8518,"path":"tokenizer.json","sha256":"ada18e5c4dfcb5c369c05f4ffc10bc40298ce707e78f16135c6d33019f6db8cd"},"totalBytes":8560,"trainingManifestDigest":"e9b2550dbb79141af84440dda65ca21d3509904b2c09a89316145137a5b5e3de"}

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

@@ -0,0 +1,32 @@
+/**
+ * config/vector-cortex-enc0a.ts — ENC-0a learned-encoder backend-decision 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 first ENC (real learned encoder) sprint flag. vector-cortex.ts
+ * re-exports the ENUM below and root src/config.ts re-exports it, so no consumer
+ * import path changes.
+ *
+ * ENC-0a locks the runtime-backend choice (transformers.js/WASM vs
+ * onnxruntime-node native), the per-platform install-size matrix, the opset
+ * baseline (re-baselined 17 -> 21) and the license/pinning audit. It writes a
+ * durable decision record and bench JSON but touches neither the store schema
+ * nor stateDir tables (pure migration).
+ *
+ * The split is purely mechanical: ENC_0A_ENABLED is byte-identical in name,
+ * semantics, and default to the definition it replaces, and vector-cortex.ts
+ * re-exports it so every existing `from "./config/vector-cortex.js"` import
+ * keeps resolving unchanged.
+ *
+ * Pi-agnostic, dependency-free (PREVENT-PI-004 / PREVENT-011).
+ */
+import { sprintFlag } from "./vector-cortex-flag.js";
+/**
+ * ENC-0a — learned-encoder backend-decision lock. Default ON.
+ * `MEGACOMPACT_ENC_0A=0` disables and is byte-identical to the predecessor
+ * (placeholder encoder): no decision record is written and no newer
+ * backend-resolution script runs — the runtime keeps serving mode B trigram
+ * exactly as before. This flag MUST also be a dashboard SETTINGS toggle (visible
+ * in config UI, never in EXCLUDED_SETTINGS), mirroring VC4A..VC9D.
+ */
+export const ENC_0A_ENABLED = () => sprintFlag("MEGACOMPACT_ENC_0A");

package/dist/config/vector-cortex.js

@@ -5,8 +5,7 @@
  * `=0`/`_DISABLED` off. Flag-OFF is byte-identical to the predecessor sprint's
  * behavior (for VC0A: mode C — observer absent, zero evaluation writes).
  *
- * The breaker/triad constants (TRIAD_RESILIENCE.md) live here so VC0C consumes
- * them without re-declaring the ownership boundary. Pi-agnostic, dependency-free.
+ * Breaker/triad constants (TRIAD_RESILIENCE.md) live here; pi-agnostic, dep-free.
  */
 import { sprintFlag } from "./vector-cortex-flag.js";
 // VC0/VC1/VC2 foundation-phase flags in vector-cortex-early.ts; re-exported
@@ -251,5 +250,6 @@ export { ML5C_ENABLED } from "./vector-cortex-ml5c.js";
 export { ML5D_ENABLED } from "./vector-cortex-ml5d.js";
 export { ML5E_ENABLED } from "./vector-cortex-ml5e.js";
 export { DEDUP_ATTR_ENABLED } from "./vector-cortex-dedup-attr.js";
+export { ENC_0A_ENABLED } from "./vector-cortex-enc0a.js";
 // Breaker constants (TRIAD_RESILIENCE.md §breaker) extracted to vector-cortex-breakers.ts.
 export { BREAKER_WINDOW_MS, BREAKER_MIN_ATTEMPTS, BREAKER_PERF_FAILURES, BREAKER_PERF_FAILURE_RATE, BREAKER_CORRECTNESS_FAILURES, BREAKER_COOLDOWN_MS, BREAKER_PROBE_COUNT, BREAKER_RETRY_BASE_MS, BREAKER_RETRY_CAP_MS, BREAKER_RETRY_JITTER, BREAKER_HYSTERESIS_FAILURE_RATE, BREAKER_HYSTERESIS_BUDGET_P95_MS, BREAKER_MIN_HEALTHY_RESIDENCE_MS, } from "./vector-cortex-breakers.js";

package/dist/config.js

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

@@ -58,5 +58,6 @@ export const VECTOR_CORTEX_SETTINGS = {
         boolDirect("MEGACOMPACT_ML5_D", "ML5-D Dashboard Improve Cortex", "ML5-D dashboard 'Improve Cortex' surface: the ModelImprovementCard + POST /api/cortex/improve + GET /api/cortex/improve/status/:jobId. ON (default) = the card renders and Improve launches a local ML5-A training job. OFF = both improve endpoints return 404 and VectorCortexTab omits the card, byte-identical to ML5-C.", true),
         boolDirect("MEGACOMPACT_ML5_E", "ML5-E Nightly Retraining Cron", "ML5-E nightly retraining + feedback loop: the user's own post-redaction conversation turns become fresh training signal, the five heads are re-fit nightly via system cron, calibration is re-validated, and mode-A promotion is re-checked without human intervention. The cron is system-configured (crontab -e); the extension never installs or writes a crontab. Candidates are written to ~/.pi/mega-compact-encoder/candidates/ and promoted via the ML5-D Improve Cortex flow. ON (default) = the scripts may be invoked by the system cron. OFF = scripts are never invoked; byte-identical to ML5-D.", true),
         boolDirect("MEGACOMPACT_DEDUP_ATTR", "Dedup Tier Attribution Rollup", "Dedup tier-attribution rollup: per-tier dedup catch shares (L0/L1/L2/new percent of dedup decisions) read from the local events.log dedup_audit stream (GET /api/dedup-tier-attribution). OFF = 404 + no cache file, byte-identical predecessor.", true),
+        boolDirect("MEGACOMPACT_ENC_0A", "ENC-0a Encoder Backend Decision", "ENC-0a learned-encoder backend-decision lock: records the transformers.js/WASM vs onnxruntime-node choice, per-platform install matrix, opset-21 baseline and pinned digests in docs/vector-cortex/encoder-backend-decision.md. OFF = no decision record written / no resolver runs, mode B trigram byte-identical predecessor.", true),
     ],
 };

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

@@ -0,0 +1,32 @@
+/**
+ * config/vector-cortex-enc0a.ts — ENC-0a learned-encoder backend-decision 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 first ENC (real learned encoder) sprint flag. vector-cortex.ts
+ * re-exports the ENUM below and root src/config.ts re-exports it, so no consumer
+ * import path changes.
+ *
+ * ENC-0a locks the runtime-backend choice (transformers.js/WASM vs
+ * onnxruntime-node native), the per-platform install-size matrix, the opset
+ * baseline (re-baselined 17 -> 21) and the license/pinning audit. It writes a
+ * durable decision record and bench JSON but touches neither the store schema
+ * nor stateDir tables (pure migration).
+ *
+ * The split is purely mechanical: ENC_0A_ENABLED is byte-identical in name,
+ * semantics, and default to the definition it replaces, and vector-cortex.ts
+ * re-exports it so every existing `from "./config/vector-cortex.js"` import
+ * keeps resolving unchanged.
+ *
+ * Pi-agnostic, dependency-free (PREVENT-PI-004 / PREVENT-011).
+ */
+import { sprintFlag } from "./vector-cortex-flag.js";
+/**
+ * ENC-0a — learned-encoder backend-decision lock. Default ON.
+ * `MEGACOMPACT_ENC_0A=0` disables and is byte-identical to the predecessor
+ * (placeholder encoder): no decision record is written and no newer
+ * backend-resolution script runs — the runtime keeps serving mode B trigram
+ * exactly as before. This flag MUST also be a dashboard SETTINGS toggle (visible
+ * in config UI, never in EXCLUDED_SETTINGS), mirroring VC4A..VC9D.
+ */
+export const ENC_0A_ENABLED = () => sprintFlag("MEGACOMPACT_ENC_0A");

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

@@ -5,8 +5,7 @@
  * `=0`/`_DISABLED` off. Flag-OFF is byte-identical to the predecessor sprint's
  * behavior (for VC0A: mode C — observer absent, zero evaluation writes).
  *
- * The breaker/triad constants (TRIAD_RESILIENCE.md) live here so VC0C consumes
- * them without re-declaring the ownership boundary. Pi-agnostic, dependency-free.
+ * Breaker/triad constants (TRIAD_RESILIENCE.md) live here; pi-agnostic, dep-free.
  */
 import { sprintFlag } from "./vector-cortex-flag.js";
 // VC0/VC1/VC2 foundation-phase flags in vector-cortex-early.ts; re-exported
@@ -251,5 +250,6 @@ export { ML5C_ENABLED } from "./vector-cortex-ml5c.js";
 export { ML5D_ENABLED } from "./vector-cortex-ml5d.js";
 export { ML5E_ENABLED } from "./vector-cortex-ml5e.js";
 export { DEDUP_ATTR_ENABLED } from "./vector-cortex-dedup-attr.js";
+export { ENC_0A_ENABLED } from "./vector-cortex-enc0a.js";
 // Breaker constants (TRIAD_RESILIENCE.md §breaker) extracted to vector-cortex-breakers.ts.
 export { BREAKER_WINDOW_MS, BREAKER_MIN_ATTEMPTS, BREAKER_PERF_FAILURES, BREAKER_PERF_FAILURE_RATE, BREAKER_CORRECTNESS_FAILURES, BREAKER_COOLDOWN_MS, BREAKER_PROBE_COUNT, BREAKER_RETRY_BASE_MS, BREAKER_RETRY_CAP_MS, BREAKER_RETRY_JITTER, BREAKER_HYSTERESIS_FAILURE_RATE, BREAKER_HYSTERESIS_BUDGET_P95_MS, BREAKER_MIN_HEALTHY_RESIDENCE_MS, } from "./vector-cortex-breakers.js";

package/dist/src/config.js

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

package/dist/src/vector-cortex/_acceptance-enc0a-contract.js

@@ -0,0 +1,60 @@
+/** ENC-0a buildDecision contract constructor suite — extracted from
+ *  enc0a-acceptance.test.ts for soft-limit compliance. Receives the contract
+ *  constructor + constants from the aggregator (no import cycle).
+ */
+import { test, describe } from "node:test";
+import assert from "node:assert/strict";
+export function registerEnc0aContract(ctx) {
+    const { buildDecision, PLATFORMS } = ctx;
+    describe("buildDecision contract constructor", () => {
+        test("rejects an incomplete platform matrix", () => {
+            const matrix = {
+                "linux-x64": { runtime: "onnxruntime-web", installMiB: 33, demotion: "none" },
+                "linux-arm64": { runtime: "onnxruntime-web", installMiB: 33, demotion: "none" },
+                "darwin-x64": { runtime: "onnxruntime-web", installMiB: 33, demotion: "wasm" },
+                "darwin-arm64": { runtime: "onnxruntime-web", installMiB: 33, demotion: "none" },
+                // win32-x64 omitted
+            };
+            assert.throws(() => buildDecision({
+                backend: "wasm",
+                budgetOk: true,
+                p95Ms: 18.2,
+                platformMatrix: matrix,
+                modelPath: "model.onnx",
+                modelBytes: 1,
+                modelSha256: "a".repeat(64),
+                tokenizerPath: "tokenizer.json",
+                tokenizerBytes: 1,
+                tokenizerSha256: "b".repeat(64),
+                blockedBy: [],
+            }));
+        });
+        test("builds a valid decision with opset 21 + MIT license for a complete matrix", () => {
+            const matrix = {
+                "linux-x64": { runtime: "onnxruntime-web", installMiB: 33, demotion: "none" },
+                "linux-arm64": { runtime: "onnxruntime-web", installMiB: 33, demotion: "none" },
+                "darwin-x64": { runtime: "onnxruntime-web", installMiB: 33, demotion: "wasm" },
+                "darwin-arm64": { runtime: "onnxruntime-web", installMiB: 33, demotion: "none" },
+                "win32-x64": { runtime: "onnxruntime-web", installMiB: 33, demotion: "none" },
+            };
+            const d = buildDecision({
+                backend: "wasm",
+                budgetOk: true,
+                p95Ms: 18.2,
+                platformMatrix: matrix,
+                modelPath: "model.onnx",
+                modelBytes: 24117248,
+                modelSha256: "a".repeat(64),
+                tokenizerPath: "tokenizer.json",
+                tokenizerBytes: 50000,
+                tokenizerSha256: "b".repeat(64),
+                blockedBy: [],
+            });
+            assert.equal(d.schema, "encoder-backend-decision-v1");
+            assert.equal(d.opset, 21);
+            assert.equal(d.backend, "wasm");
+            assert.deepEqual(d.license, { spdx: "MIT", redistribution: true });
+            assert.equal(d.platformMatrix["darwin-x64"].demotion, "wasm");
+        });
+    });
+}

package/dist/src/vector-cortex/_acceptance-vc2a-conformance.js

@@ -0,0 +1,90 @@
+/**
+ * _acceptance-vc2a-conformance.ts — ENC-001..008 conformance rows + the named
+ * assertions (ENC-ASSET-001 / ENC-DIGEST-002 / ENC-PLATFORM-003), each driven
+ * through the REAL encoder asset/runtime (no mocks). Extracted from
+ * vc2a-acceptance.test.ts so the aggregator stays under the tests/ soft limit.
+ *
+ * The aggregator passes its shared imports/helpers as a context object, so this
+ * sibling never imports the aggregator (no import cycle at module load).
+ */
+import { test, describe } from "node:test";
+import assert from "node:assert/strict";
+export function registerVc2aConformance(ctx) {
+    const { ENC_IDS, ENC_FAIL, fixture, buildDir, rmBuilt, optionsFor, createEncoderRuntime, verifyEncoderAsset, readEncoderManifest, } = ctx;
+    // -------------------------------------------------------------------------
+    // ENC-001..008 conformance rows through the real runtime
+    // -------------------------------------------------------------------------
+    describe("ENC-001..008 conformance rows", () => {
+        for (const id of ENC_IDS) {
+            test(`${id}: resolves through the real runtime to the documented result`, () => {
+                const fx = fixture(id);
+                const built = buildDir(fx.input.scenario);
+                try {
+                    const rt = createEncoderRuntime(optionsFor(fx.input.scenario));
+                    const load = rt.load(built.dir);
+                    assert.equal(load.ok, fx.expected.ok, `${id} ok`);
+                    if (!load.ok) {
+                        assert.equal(load.code, fx.expected.code, `${id} exact failure code`);
+                        if (fx.expected.mode)
+                            assert.equal(load.mode, fx.expected.mode, `${id} mode`);
+                    }
+                    else {
+                        assert.equal(load.mode, "A", `${id} should be mode A`);
+                    }
+                }
+                finally {
+                    rmBuilt(built);
+                }
+            });
+        }
+    });
+    // -------------------------------------------------------------------------
+    // VC2A named assertions
+    // -------------------------------------------------------------------------
+    describe("VC2A named assertions", () => {
+        test("ENC-ASSET-001: opset21 manifest + matching digests load as mode A", () => {
+            const fx = fixture("ENC-ASSET-001");
+            assert.equal(fx.expected.ok, true);
+            const built = buildDir("valid");
+            try {
+                const load = createEncoderRuntime().load(built.dir);
+                assert.equal(load.ok, true);
+                if (load.ok)
+                    assert.equal(load.mode, "A");
+            }
+            finally {
+                rmBuilt(built);
+            }
+        });
+        test("ENC-DIGEST-002: one-byte model mutation demotes before load", () => {
+            const fx = fixture("ENC-DIGEST-002");
+            assert.equal(fx.expected.code, ENC_FAIL.DIGEST_MISMATCH);
+            const built = buildDir("mutate-onnx");
+            try {
+                const res = verifyEncoderAsset(built.dir, readEncoderManifest(built.dir));
+                assert.equal(res.ok, false);
+                if (!res.ok)
+                    assert.equal(res.code, ENC_FAIL.DIGEST_MISMATCH);
+            }
+            finally {
+                rmBuilt(built);
+            }
+        });
+        test("ENC-PLATFORM-003: unsupported architecture selects trigram B", () => {
+            const fx = fixture("ENC-PLATFORM-003");
+            assert.equal(fx.expected.mode, "B");
+            const built = buildDir("valid");
+            try {
+                const load = createEncoderRuntime({ platform: () => null }).load(built.dir);
+                assert.equal(load.ok, false);
+                if (!load.ok) {
+                    assert.equal(load.mode, "B", "trigram B selected");
+                    assert.equal(load.code, ENC_FAIL.PLATFORM_UNSUPPORTED);
+                }
+            }
+            finally {
+                rmBuilt(built);
+            }
+        });
+    });
+}

package/dist/src/vector-cortex/_acceptance-vc2a-runtime.js

@@ -0,0 +1,285 @@
+/** VC2A runtime invariant + injection + triad + budget acceptance suites.
+ *  Extracted from vc2a-acceptance.test.ts (soft-limit compliance). Context injected. */
+import { test, describe } from "node:test";
+import assert from "node:assert/strict";
+import { mkdirSync, writeFileSync, rmSync } from "node:fs";
+import { join } from "node:path";
+export function registerVc2aRuntime(ctx) {
+    const { ENC_FAIL, ENCODER_RSS_BUDGET_BYTES, ENCODER_LATENCY_P95_MS, tmpAsset, baseManifest, buildDir, rmBuilt, sha256, percentile, createEncoderRuntime, verifyEncoderAsset, readEncoderManifest, } = ctx;
+    // -------------------------------------------------------------------------
+    // Invariant + unique failure injection + forced triad
+    // -------------------------------------------------------------------------
+    describe("encoder runtime invariant + injection + triad", () => {
+        test("invariant: only batch1/max512 verified assets reach inference", () => {
+            const built = buildDir("valid");
+            try {
+                const rt = createEncoderRuntime();
+                const load = rt.load(built.dir);
+                assert.equal(load.ok, true);
+                if (load.ok)
+                    assert.equal(load.mode, "A");
+                // dims 1..512 infer; 0 and 513+ are shape-rejected.
+                for (const n of [1, 64, 512]) {
+                    const inf = rt.infer({ tokens: Array.from({ length: n }, (_, i) => i % 500) });
+                    assert.equal(inf.ok, true, `dim ${n} infers`);
+                }
+                for (const n of [0, 513, 1000]) {
+                    const inf = rt.infer({ tokens: Array.from({ length: n }) });
+                    assert.equal(inf.ok, false, `dim ${n} shape-rejected`);
+                    if (!inf.ok)
+                        assert.equal(inf.code, ENC_FAIL.SHAPE_INVALID);
+                }
+                // A batch>1 manifest never reaches inference: verification demotes to B.
+                const bad = buildDir("batch-2");
+                try {
+                    const checker = createEncoderRuntime();
+                    const check = checker.load(bad.dir);
+                    assert.equal(check.ok, false);
+                    if (!check.ok)
+                        assert.equal(check.code, ENC_FAIL.BATCH_INVALID);
+                }
+                finally {
+                    rmBuilt(bad);
+                }
+            }
+            finally {
+                rmBuilt(built);
+            }
+        });
+        test("1..513 maxTokens manifests: 1..512 verify+infer, 513 demotes TOKENS_EXCEEDED", () => {
+            for (const maxTok of [1, 64, 512]) {
+                const dir = tmpAsset("vc2a-dim");
+                mkdirSync(dir, { recursive: true });
+                const onnx = Buffer.from(`dim-${maxTok}`, "binary");
+                const tok = Buffer.from('{"vocab":[]}', "utf8");
+                writeFileSync(join(dir, "model.onnx"), onnx);
+                writeFileSync(join(dir, "tokenizer.json"), tok);
+                const m = baseManifest({
+                    maxTokens: maxTok,
+                    onnx: { path: "model.onnx", sha256: sha256(onnx), bytes: onnx.length },
+                    tokenizer: { path: "tokenizer.json", sha256: sha256(tok), bytes: tok.length },
+                });
+                writeFileSync(join(dir, "manifest.json"), JSON.stringify(m));
+                assert.equal(verifyEncoderAsset(dir, readEncoderManifest(dir)).ok, true, `maxTokens ${maxTok} verifies`);
+                const rt = createEncoderRuntime();
+                assert.equal(rt.load(dir).ok, true, `maxTokens ${maxTok} loads`);
+                const inf = rt.infer({ tokens: Array.from({ length: maxTok }) });
+                assert.equal(inf.ok, true, `cap ${maxTok} infers`);
+                rmSync(dir, { recursive: true, force: true });
+            }
+            // 513 demotes.
+            const dir513 = tmpAsset("vc2a-dim-513");
+            mkdirSync(dir513, { recursive: true });
+            const onnx513 = Buffer.from("dim-513", "binary");
+            const tok513 = Buffer.from('{"vocab":[]}', "utf8");
+            writeFileSync(join(dir513, "model.onnx"), onnx513);
+            writeFileSync(join(dir513, "tokenizer.json"), tok513);
+            const m513 = baseManifest({
+                maxTokens: 513,
+                onnx: { path: "model.onnx", sha256: sha256(onnx513), bytes: onnx513.length },
+                tokenizer: { path: "tokenizer.json", sha256: sha256(tok513), bytes: tok513.length },
+            });
+            writeFileSync(join(dir513, "manifest.json"), JSON.stringify(m513));
+            const res = verifyEncoderAsset(dir513, readEncoderManifest(dir513));
+            assert.equal(res.ok, false);
+            if (!res.ok)
+                assert.equal(res.code, ENC_FAIL.TOKENS_EXCEEDED);
+            rmSync(dir513, { recursive: true, force: true });
+        });
+        test("truncated ONNX during digest read demotes ENC_ASSET_UNREADABLE", () => {
+            // LIVE-platform manifest with absent model.onnx -> unreadable -> ASSET_UNREADABLE.
+            const built = buildDir("missing-onnx");
+            try {
+                const load = createEncoderRuntime().load(built.dir);
+                assert.equal(load.ok, false);
+                if (!load.ok) {
+                    assert.equal(load.code, ENC_FAIL.ASSET_UNREADABLE);
+                    assert.equal(load.mode, "B");
+                }
+            }
+            finally {
+                rmBuilt(built);
+            }
+        });
+        test("allocator failure after verification demotes ENC_ASSET_UNREADABLE", () => {
+            const built = buildDir("valid");
+            try {
+                const load = createEncoderRuntime({ host: { allocatorFails: () => true } }).load(built.dir);
+                assert.equal(load.ok, false);
+                if (!load.ok)
+                    assert.equal(load.code, ENC_FAIL.ASSET_UNREADABLE);
+            }
+            finally {
+                rmBuilt(built);
+            }
+        });
+        test("forced triad A / B / C", () => {
+            const dirA = buildDir("valid");
+            try {
+                assert.equal(createEncoderRuntime().load(dirA.dir).ok, true);
+            }
+            finally {
+                rmBuilt(dirA);
+            }
+            // B: missing asset => asset-free trigram.
+            const dirB = buildDir("missing-onnx");
+            try {
+                const load = createEncoderRuntime().load(dirB.dir);
+                assert.equal(load.ok, false);
+                if (!load.ok)
+                    assert.equal(load.mode, "B");
+            }
+            finally {
+                rmBuilt(dirB);
+            }
+            // C: lexical forced by mode C (rollback path).
+            const dirC = tmpAsset("vc2a-C");
+            mkdirSync(dirC, { recursive: true });
+            try {
+                const load = createEncoderRuntime({ forcedMode: "C" }).load(dirC);
+                assert.equal(load.ok, false);
+                if (!load.ok)
+                    assert.equal(load.mode, "C");
+            }
+            finally {
+                rmSync(dirC, { recursive: true, force: true });
+            }
+        });
+        test("acceptance budgets: infer p95 <=40ms and encoder marginal footprint <=150MiB", () => {
+            // Q02: rssBytes = encoder MARGINAL footprint, never whole-process RSS.
+            // p95 via linear interpolation — not max sample.
+            const built = buildDir("valid");
+            try {
+                const rt = createEncoderRuntime();
+                assert.equal(rt.load(built.dir).ok, true);
+                const latencies = [];
+                for (let i = 0; i < 200; i++) {
+                    const inf = rt.infer({ tokens: Array.from({ length: 128 }, (_, k) => k) });
+                    assert.equal(inf.ok, true);
+                    if (inf.ok) {
+                        latencies.push(inf.latencyMs);
+                        assert.ok(inf.rssBytes <= ENCODER_RSS_BUDGET_BYTES, "encoder marginal footprint <=150MiB");
+                    }
+                }
+                const p95 = percentile(latencies, 0.95);
+                assert.ok(p95 <= ENCODER_LATENCY_P95_MS, `p95 ${p95} <= 40ms`);
+            }
+            finally {
+                rmBuilt(built);
+            }
+        });
+        test("Q01: a long-lived runtime cannot drift over the 150MiB marginal budget", () => {
+            // selfAllocated models a REUSABLE projection buffer — must not accumulate.
+            // 100k inferences prove no irreversible budget demotion.
+            const built = buildDir("valid");
+            try {
+                const rt = createEncoderRuntime();
+                assert.equal(rt.load(built.dir).ok, true);
+                let firstRss = 0;
+                for (let i = 0; i < 100_000; i++) {
+                    const inf = rt.infer({ tokens: Array.from({ length: 4 }, () => i % 500) });
+                    assert.equal(inf.ok, true, `infer #${i} still ok`);
+                    if (inf.ok) {
+                        if (i === 0)
+                            firstRss = inf.rssBytes;
+                        assert.equal(inf.rssBytes, firstRss, `marginal footprint flat at infer #${i}`);
+                        assert.ok(inf.rssBytes <= ENCODER_RSS_BUDGET_BYTES, `still within budget at infer #${i}`);
+                    }
+                }
+                assert.equal(rt.mode, "A", "mode A survives 100k inferences (no irreversible budget demotion)");
+            }
+            finally {
+                rmBuilt(built);
+            }
+        });
+        test("Q03: per-manifest maxTokens is enforced at inference (over-cap rejected)", () => {
+            // maxTokens=64 manifest: 65..512 tokens must be SHAPE_INVALID.
+            const dir = tmpAsset("vc2a-q03");
+            mkdirSync(dir, { recursive: true });
+            const onnx = Buffer.from("q03-lowcap", "binary");
+            const tok = Buffer.from('{"vocab":[]}', "utf8");
+            writeFileSync(join(dir, "model.onnx"), onnx);
+            writeFileSync(join(dir, "tokenizer.json"), tok);
+            const m = baseManifest({
+                maxTokens: 64,
+                onnx: { path: "model.onnx", sha256: sha256(onnx), bytes: onnx.length },
+                tokenizer: { path: "tokenizer.json", sha256: sha256(tok), bytes: tok.length },
+            });
+            writeFileSync(join(dir, "manifest.json"), JSON.stringify(m));
+            try {
+                const rt = createEncoderRuntime();
+                assert.equal(rt.load(dir).ok, true, "maxTokens=64 manifest loads (mode A)");
+                assert.equal(rt.infer({ tokens: Array.from({ length: 64 }, (_, k) => k) }).ok, true, "cap 64 infers");
+                for (const over of [65, 128, 512]) {
+                    const inf = rt.infer({ tokens: Array.from({ length: over }) });
+                    assert.equal(inf.ok, false, `${over} tokens rejected against a 64-cap manifest`);
+                    if (!inf.ok)
+                        assert.equal(inf.code, ENC_FAIL.SHAPE_INVALID);
+                }
+            }
+            finally {
+                rmSync(dir, { recursive: true, force: true });
+            }
+        });
+        test("Q04: MEGACOMPACT_VC2A=0 makes the default factory select mode C (rollback)", () => {
+            // Flag OFF => default factory is fixed at mode C (byte-identical predecessor).
+            const saved = process.env.MEGACOMPACT_VC2A;
+            process.env.MEGACOMPACT_VC2A = "0";
+            try {
+                // An explicitly forced "C" also reports ROLLBACK (existing contract).
+                const forced = createEncoderRuntime({ forcedMode: "C" });
+                // The default factory under flag-off must match that exactly.
+                const byFlag = createEncoderRuntime();
+                for (const rt of [forced, byFlag]) {
+                    assert.equal(rt.mode, "C", "flag-off / forced runtime starts in mode C");
+                    const built = buildDir("valid");
+                    try {
+                        const load = rt.load(built.dir);
+                        assert.equal(load.ok, false);
+                        if (!load.ok) {
+                            assert.equal(load.mode, "C", "flag-off default factory reports mode C");
+                            assert.equal(load.code, ENC_FAIL.ROLLBACK, "ROLLBACK, not MANIFEST_INVALID");
+                        }
+                    }
+                    finally {
+                        rmBuilt(built);
+                    }
+                    const inf = rt.infer({ tokens: [1, 2, 3] });
+                    assert.equal(inf.ok, false, "no learned infer on the flag-off path");
+                }
+            }
+            finally {
+                if (saved === undefined)
+                    delete process.env.MEGACOMPACT_VC2A;
+                else
+                    process.env.MEGACOMPACT_VC2A = saved;
+            }
+            // Restore the module-scope pin (flag ON) for subsequent scenarios.
+            process.env.MEGACOMPACT_VC2A = "1";
+        });
+        test("all digest corruptions demote before load", () => {
+            for (const which of ["onnx", "tokenizer", "both"]) {
+                const dir = tmpAsset("vc2a-corr");
+                mkdirSync(dir, { recursive: true });
+                const onnx = Buffer.from("corrupt-me-onnx", "binary");
+                const tok = Buffer.from('{"vocab":[]}', "utf8");
+                writeFileSync(join(dir, "model.onnx"), onnx);
+                writeFileSync(join(dir, "tokenizer.json"), tok);
+                const m = baseManifest({
+                    onnx: { path: "model.onnx", sha256: sha256(onnx), bytes: onnx.length },
+                    tokenizer: { path: "tokenizer.json", sha256: sha256(tok), bytes: tok.length },
+                });
+                if (which === "onnx" || which === "both")
+                    writeFileSync(join(dir, "model.onnx"), Buffer.concat([onnx, Buffer.from("X")]));
+                if (which === "tokenizer" || which === "both")
+                    writeFileSync(join(dir, "tokenizer.json"), Buffer.concat([tok, Buffer.from("X")]));
+                writeFileSync(join(dir, "manifest.json"), JSON.stringify(m));
+                const res = verifyEncoderAsset(dir, readEncoderManifest(dir));
+                assert.equal(res.ok, false, `corrupt ${which} demotes`);
+                if (!res.ok)
+                    assert.equal(res.code, ENC_FAIL.DIGEST_MISMATCH, `corrupt ${which} code`);
+                rmSync(dir, { recursive: true, force: true });
+            }
+        });
+    });
+}