pi-mega-compact 0.20.41 → 0.20.43

package/dist/src/vector-cortex/dedup-attr/rollup.js

@@ -0,0 +1,97 @@
+/**
+ * vector-cortex/dedup-attr/rollup.ts — DEDUP-ATTR pure tier-attribution rollup.
+ *
+ * Pure function: reads an array of parsed dedup-audit events, buckets them by
+ * tier over a query window, and returns the per-tier catch shares. No I/O, no
+ * clock — the route passes `now: Date` (new Date()) at request time, so this
+ * module is deterministically reproducible and trivially testable (DEDUP-ATTR-004).
+ *
+ * Missing `similarity` is fine here: L0/L1 are hash/verify tiers and emit no
+ * score, and the rollup never consults it. Malformed lines (non-object, wrong
+ * type) are skipped silently — the route's events.log reader already guards its
+ * JSON.parse (PREVENT-001), and this layer defends against a hostile/mixed
+ * `dedup_audit` array as well.
+ *
+ * The returned shape is structurally identical to the authoritative contract in
+ * `extensions/dashboard-server/api-contracts/dedup-attribution.ts` (the existing
+ * src-mirrors-dashboard-contract pattern); src/ stays pi-agnostic and never
+ * imports dashboard types. Status here is computed from the pure signal the
+ * rollup owns (a non-empty window) — the route additionally derives the sent
+ * `status` via `deriveVcStatus` from the shared vc-status module.
+ *
+ * Guardrails: PREVENT-PI-004 (zero I/O/network), PREVENT-011 (no `any`).
+ */
+/**
+ * Roll up dedup-audit events over [now - windowMs, now] into per-tier shares.
+ *
+ * Only events whose ISO-8601 `ts` falls inside the window are counted; events of
+ * any other `type` (or a missing/unparseable `ts`) are skipped silently. Shares
+ * are fractions of the window's total decisions, each in [0, 1]; an empty window
+ * yields all-zero shares with `status:"awaiting_data"` — never a fabricated
+ * zero-share table presented as real.
+ */
+export function computeDedupTierRollup(events, windowMs, now) {
+    const winMs = windowMs > 0 ? windowMs : 24 * 60 * 60 * 1000;
+    const windowStart = now.getTime() - winMs;
+    const windowEnd = now.getTime();
+    const acc = {
+        l0: { deduped: 0, passed: 0 },
+        l1: { deduped: 0, passed: 0 },
+        l2: { deduped: 0, passed: 0 },
+        storedNew: 0,
+    };
+    let total = 0;
+    for (const ev of events) {
+        if (!ev || typeof ev !== "object")
+            continue;
+        if (ev.type !== "dedup_audit")
+            continue;
+        const ts = Date.parse(ev.ts);
+        if (Number.isNaN(ts) || ts < windowStart || ts > windowEnd)
+            continue;
+        total += 1;
+        switch (ev.tier) {
+            case "L0":
+                if (ev.status === "deduped")
+                    acc.l0.deduped += 1;
+                else if (ev.status === "passed")
+                    acc.l0.passed += 1;
+                break;
+            case "L1":
+                if (ev.status === "deduped")
+                    acc.l1.deduped += 1;
+                else if (ev.status === "passed")
+                    acc.l1.passed += 1;
+                break;
+            case "L2":
+                if (ev.status === "deduped")
+                    acc.l2.deduped += 1;
+                else if (ev.status === "passed")
+                    acc.l2.passed += 1;
+                break;
+            case "new":
+                acc.storedNew += 1;
+                break;
+            default:
+                break;
+        }
+    }
+    const byTier = {
+        l0: { deduped: acc.l0.deduped, passed: acc.l0.passed },
+        l1: { deduped: acc.l1.deduped, passed: acc.l1.passed },
+        l2: { deduped: acc.l2.deduped, passed: acc.l2.passed },
+        new: acc.storedNew,
+    };
+    const shareOf = (n) => (total > 0 ? n / total : 0);
+    return {
+        schema: "dedup-tier-rollup-v1",
+        windowStart: new Date(windowStart).toISOString(),
+        windowEnd: now.toISOString(),
+        totalDecisions: total,
+        byTier,
+        l0Share: shareOf(acc.l0.deduped + acc.l0.passed),
+        l1Share: shareOf(acc.l1.deduped + acc.l1.passed),
+        l2Share: shareOf(acc.l2.deduped + acc.l2.passed),
+        status: total > 0 ? "live" : "awaiting_data",
+    };
+}

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

@@ -2,7 +2,8 @@
  * vector-cortex/encoder/asset.ts — VC2A asset verification (task 2).
  *
  * Verifies a ModelManifestV1 before any allocation: SHA-256 the ONNX and
- * tokenizer against the manifest digests, require opset 17, batch exactly 1 and
+ * tokenizer against the manifest digests, require opset 21 (ENC-0a re-baseline),
+ * batch exactly 1 and
  * maximum 512 tokens, and confirm the current platform is in the supported
  * matrix. On ANY of these the caller demotes to mode B (asset-free trigram) —
  * never a remote fetch (PREVENT-PI-004). A truncated/unreadable asset during
@@ -73,7 +74,7 @@ function isManifest(m) {
  *
  *   - manifest parse/shape failure      -> ENC_MANIFEST_INVALID -> mode B
  *   - unsupported platform              -> ENC_PLATFORM_UNSUPPORTED -> mode B
- *   - opset != 17                       -> ENC_OPSET_INVALID -> mode B
+ *   - opset != 21                       -> ENC_OPSET_INVALID -> mode B
  *   - batch != 1                        -> ENC_BATCH_INVALID -> mode B
  *   - maxTokens > 512                   -> ENC_TOKENS_EXCEEDED -> mode B
  *   - on-disk digest != manifest digest -> ENC_DIGEST_MISMATCH (one-byte mutation)

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

@@ -0,0 +1,75 @@
+/**
+ * vector-cortex/encoder/decision.ts — ENC-0a backend-decision contract.
+ *
+ * The durable EncoderBackendDecisionV1 record: which ONNX runtime backend the
+ * real learned encoder ships on (transformers.js/WASM vs onnxruntime-node
+ * native), whether the 80 MiB install budget holds, the per-platform install
+ * matrix, the opset baseline (locked 21 by ENC-0a), the license verdict, and
+ * the pinned model/tokenizer sha256 digests.
+ *
+ * ENC-0a is the DECISION + MEASUREMENT sprint: this contract is what the
+ * deterministic resolver (`scripts/encoder/resolve-backend-decision.mjs`) and
+ * the durable record (`docs/vector-cortex/encoder-backend-decision.md`) both
+ * consume. ENC-0a also owns the opset flip: ENCODER_OPSET is re-baselined to 21
+ * in `types.ts` alongside the placeholder manifest (the 2026-08-05 trunk
+ * research dropped the earlier Xenova opset-17 requirement). ENC-0b asserts the
+ * staged real asset is opset 21 — no further constant change.
+ *
+ * Contract-first (ENGINEERING_PRACTICES §3). Pi-agnostic, dependency-free
+ * (PREVENT-PI-004 — local computation only, never a fetch). No `any`
+ * (PREVENT-011).
+ */
+/**
+ * The normative ENC-0a budget: the 80 MiB install/asset cap (MODEL_ASSET.md
+ * §Qualification). Backend qualifies (budgetOk) iff the shipped byte-count fits.
+ */
+export const ENCODER_INSTALL_BUDGET_MIB = 80;
+/** The p95 latency gate at 512 tokens / 4 threads on linux-x64 (ms). */
+export const ENCODER_DECISION_P95_MS = 40;
+/**
+ * buildDecision — assemble a valid, platform-complete EncoderBackendDecisionV1.
+ *
+ * Pure helper consumed by the acceptance aggregator (and any TS consumer of the
+ * decision). Every EncoderPlatform must resolve to a row, and the passed
+ * per-platform rows must be complete (no row omitted) — a partial matrix is a
+ * contract violation, not a valid decision. All fields are passed in; this is a
+ * structural constructor, not a rules engine (the resolver owns the decision
+ * rule).
+ */
+export function buildDecision(input) {
+    const { platformMatrix } = input;
+    const platforms = [
+        "linux-x64",
+        "linux-arm64",
+        "darwin-x64",
+        "darwin-arm64",
+        "win32-x64",
+    ];
+    for (const p of platforms) {
+        if (!Object.prototype.hasOwnProperty.call(platformMatrix, p)) {
+            throw new Error(`platform matrix is incomplete: missing row for ${p}`);
+        }
+    }
+    return {
+        schema: "encoder-backend-decision-v1",
+        backend: input.backend,
+        budgetOk: input.budgetOk,
+        opset: 21,
+        platformMatrix,
+        license: { spdx: "MIT", redistribution: true },
+        artifacts: {
+            model: {
+                path: input.modelPath,
+                bytes: input.modelBytes,
+                sha256: input.modelSha256,
+            },
+            tokenizer: {
+                path: input.tokenizerPath,
+                bytes: input.tokenizerBytes,
+                sha256: input.tokenizerSha256,
+            },
+        },
+        p95Ms: input.p95Ms,
+        blockedBy: input.blockedBy,
+    };
+}

package/dist/src/vector-cortex/encoder/types-vc2c.js

@@ -0,0 +1,41 @@
+/**
+ * vector-cortex/encoder/types-vc2c.ts — VC2C qualification + calibration
+ * contracts (QualifiedEncoderV1 / CalibrationV1 / EVALUATION_THRESHOLDS).
+ *
+ * Extracted from types.ts (delegate-shell split) when types.ts crossed the
+ * 300-line soft limit. types.ts re-exports everything here; consumers import
+ * from types.ts unchanged.
+ *
+ * Pi-agnostic and dependency-free (PREVENT-PI-004). No `any` (PREVENT-011).
+ */
+/** Normative per-head + asset qualification thresholds (MODEL_ASSET §qualification
+ *  + EVALUATION.md §metrics). These are the constants `select.ts` evaluates the
+ *  candidate's held-out metrics against (task 3 atomic check). */
+export const EVALUATION_THRESHOLDS = {
+    semantic: { spearman: 0.75, recallAt10: 0.9 },
+    dependency: { precision: 0.97, recall: 0.95 },
+    contradiction: { precision: 0.98, recall: 0.9, ece: 0.05 },
+    cacheStability: { precision: 0.999, recall: 0.9 },
+    payloadRouting: { macroF1: 0.97, exactAnchorRecall: 1.0 },
+    reconstruction: { dependencyClosureRecall: 1.0 },
+    asset: { maxTokens: 512, maxLatencyP95Ms: 40, maxRssDeltaMib: 150 },
+};
+/** VC2C-specific qualification failure codes (returned, never thrown). */
+export const ENC_QUALIFICATION_FAIL = {
+    /** The qualification manifest hash does not match the calibration that was fit
+     *  (corrupt qualification manifest after calibration before selection). */
+    DIGEST_MISMATCH: "ENC_QUALIFICATION_DIGEST_MISMATCH",
+    /** One or more per-head EVALUATION thresholds failed (demotes all of A). */
+    THRESHOLD_FAILED: "ENC_QUALIFICATION_THRESHOLD_FAILED",
+    /** An asset-field qualification check (asset/latency/RSS) failed. */
+    ASSET_FAILED: "ENC_QUALIFICATION_ASSET_FAILED",
+    /** Calibration was attempted using held-out labels (fit prohibition). */
+    HELD_OUT_IN_FIT: "ENC_QUALIFICATION_HELD_OUT_IN_FIT",
+};
+/** The 4 registered VC2C conformance IDs (task 1: "register ENC-017..020"). */
+export const ENC2C_IDS = [
+    "ENC-017",
+    "ENC-018",
+    "ENC-019",
+    "ENC-020",
+];

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

@@ -24,8 +24,13 @@ export const ENCODER_SUPPORTED_PLATFORMS = [
     "darwin-arm64",
     "win32-x64",
 ];
-/** ONNX opset required by the normative v1 target (opset 17). */
-export const ENCODER_OPSET = 17;
+/** ONNX opset required by the normative v1 target. ENC-0a re-baselines from 17
+ *  to 21: the committed placeholder asset (assets/vector-cortex/encoder-v1/)
+ *  declares opset 21 in its manifest (the 2026-08-05 BAAI/bge-small-en-v1.5
+ *  upstream export is opset 21; the earlier Xenova opset-17 requirement was
+ *  dropped). The locked decision is recorded in
+ *  docs/vector-cortex/encoder-backend-decision.md. */
+export const ENCODER_OPSET = 21;
 /** Batch must be exactly 1 (single-request inference). */
 export const ENCODER_BATCH = 1;
 /** Maximum accepted token count (WordPiece, deterministic truncation). */
@@ -45,7 +50,7 @@ export const ENCODER_LATENCY_P95_MS = 40;
 export const ENCODER_SEMANTIC_WIDTH = 384;
 /** Exact VC2A failure codes (returned, never thrown across the boundary). */
 export const ENC_FAIL = {
-    /** opset != 17. */
+    /** opset != 21 (ENC-0a re-baseline applied; placeholder manifest updated alongside). */
     OPSET_INVALID: "ENC_OPSET_INVALID",
     /** batch != 1. */
     BATCH_INVALID: "ENC_BATCH_INVALID",
@@ -136,34 +141,8 @@ export const ENC2B_IDS = [
     "ENC-015",
     "ENC-016",
 ];
-/** Normative per-head + asset qualification thresholds (MODEL_ASSET §qualification
- *  + EVALUATION.md §metrics). These are the constants `select.ts` evaluates the
- *  candidate's held-out metrics against (task 3 atomic check). */
-export const EVALUATION_THRESHOLDS = {
-    semantic: { spearman: 0.75, recallAt10: 0.9 },
-    dependency: { precision: 0.97, recall: 0.95 },
-    contradiction: { precision: 0.98, recall: 0.9, ece: 0.05 },
-    cacheStability: { precision: 0.999, recall: 0.9 },
-    payloadRouting: { macroF1: 0.97, exactAnchorRecall: 1.0 },
-    reconstruction: { dependencyClosureRecall: 1.0 },
-    asset: { maxTokens: 512, maxLatencyP95Ms: 40, maxRssDeltaMib: 150 },
-};
-/** VC2C-specific qualification failure codes (returned, never thrown). */
-export const ENC_QUALIFICATION_FAIL = {
-    /** The qualification manifest hash does not match the calibration that was fit
-     *  (corrupt qualification manifest after calibration before selection). */
-    DIGEST_MISMATCH: "ENC_QUALIFICATION_DIGEST_MISMATCH",
-    /** One or more per-head EVALUATION thresholds failed (demotes all of A). */
-    THRESHOLD_FAILED: "ENC_QUALIFICATION_THRESHOLD_FAILED",
-    /** An asset-field qualification check (asset/latency/RSS) failed. */
-    ASSET_FAILED: "ENC_QUALIFICATION_ASSET_FAILED",
-    /** Calibration was attempted using held-out labels (fit prohibition). */
-    HELD_OUT_IN_FIT: "ENC_QUALIFICATION_HELD_OUT_IN_FIT",
-};
-/** The 4 registered VC2C conformance IDs (task 1: "register ENC-017..020"). */
-export const ENC2C_IDS = [
-    "ENC-017",
-    "ENC-018",
-    "ENC-019",
-    "ENC-020",
-];
+// ---------------------------------------------------------------------------
+// VC2C — encoder qualification + calibration: extracted to types-vc2c.ts
+// (delegate-shell split, soft-limit compliance). Re-exported here.
+// ---------------------------------------------------------------------------
+export { EVALUATION_THRESHOLDS, ENC_QUALIFICATION_FAIL, ENC2C_IDS, } from "./types-vc2c.js";

package/dist/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/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);
+            }
+        });
+    });
+}