pi-mega-compact 0.20.70 → 0.20.71

package/dist/extensions/dashboard-server/routes-vector-cortex-crystals.js

@@ -25,18 +25,18 @@
  */
 import { VC7A_ENABLED } from "../../src/config.js";
 import { sendJson } from "./routes-vector-cortex-shared.js";
-import { countVcEvents, vcCount } from "./vc-event-counts.js";
 import { deriveVcStatus } from "./vc-status.js";
-// Actual events emitted by src/vector-cortex/cache/crystal-emit.ts.
-const CRYSTAL_EVENTS = [
-    "vector_cortex_crystal_written",
-    "vector_cortex_crystal_collision",
-];
+import { readLivewireSnapshot } from "../../src/vector-cortex/livewire/livewire-registry.js";
+// The flag-off deferred reason, kept byte-identical to the pre-LIVEWIRE
+// predecessor (VC7A: `crystal_store_not_instantiated_v0_20_23`).
+const DEFERRED_REASON = "crystal_store_not_instantiated_v0_20_23";
 /**
  * Reader-only GET /api/vector-cortex/cache-crystals (VC7A).
  *
- * Counts, byte volumes, and CRY_* codes only — a static reader-only aggregate
- * seam with the same shape as the VC6A/VC6B/VC6C handlers.
+ * Counts, byte volumes, and CRY_* codes only. With the flag ON it surfaces the
+ * LIVEWIRE `CrystalStore` aggregate (live reads/writes/collisions accumulated at
+ * runtime); with the flag OFF it returns the byte-identical legacy deferred view
+ * (mode C, deferredReason present) so flag-off parity holds.
  */
 export function handleVectorCortexCrystals(req, res, ctx) {
     const url = req.url ?? "";
@@ -48,31 +48,46 @@ export function handleVectorCortexCrystals(req, res, ctx) {
         return true;
     }
     const enabled = VC7A_ENABLED();
-    const counts = countVcEvents(ctx.stateDir, CRYSTAL_EVENTS);
-    // Flag-off routes to mode C: with VC7A off nothing is served from the crystal
-    // cache, which is exactly the spec's "cache bypass" outcome. Reporting A (hit)
-    // or B (fresh render forced by a miss) would imply a cache path that is not
-    // wired at all. Mirrors how VC6C's OFF view reports the mode it actually takes.
-    const mode = enabled ? "A" : "C";
+    if (!enabled) {
+        // Flag-off parity: byte-identical to the predecessor (mode C + deferred).
+        const body = {
+            enabled: false,
+            mode: "C",
+            crystalCount: 0,
+            totalBytes: 0,
+            hits: 0,
+            misses: 0,
+            hitBytes: 0,
+            writes: 0,
+            duplicateWrites: 0,
+            collisions: 0,
+            lastFailure: null,
+            updatedAt: new Date().toISOString(),
+            deferredReason: DEFERRED_REASON,
+            status: deriveVcStatus({ enabled: false, hasData: false }),
+        };
+        sendJson(res, 200, body);
+        return true;
+    }
+    const snap = readLivewireSnapshot(ctx.stateDir);
+    const crystal = snap.crystals;
+    const hasData = crystal.crystalCount > 0;
     const body = {
-        enabled,
-        mode,
-        crystalCount: vcCount(counts, "vector_cortex_crystal_written"),
-        totalBytes: 0,
-        hits: 0,
-        misses: 0,
-        hitBytes: 0,
-        writes: 0,
-        duplicateWrites: 0,
-        collisions: vcCount(counts, "vector_cortex_crystal_collision"),
+        enabled: true,
+        // Surface the store's honest triad mode (B until a hit, A after, C when the
+        // store was set unavailable) rather than a hardcoded A.
+        mode: crystal.mode,
+        crystalCount: crystal.crystalCount,
+        totalBytes: crystal.totalBytes,
+        hits: crystal.hits,
+        misses: crystal.misses,
+        hitBytes: crystal.hitBytes,
+        writes: crystal.writes,
+        duplicateWrites: crystal.duplicateWrites,
+        collisions: crystal.collisions,
         lastFailure: null,
         updatedAt: new Date().toISOString(),
-        deferredReason: "crystal_store_not_instantiated_v0_20_23",
-        status: deriveVcStatus({
-            enabled,
-            deferredReason: "crystal_store_not_instantiated_v0_20_23",
-            hasData: vcCount(counts, "vector_cortex_crystal_written") > 0,
-        }),
+        status: deriveVcStatus({ enabled: true, hasData }),
     };
     sendJson(res, 200, body);
     return true;

package/dist/extensions/dashboard-server/routes-vector-cortex-diagnostics.js

@@ -27,15 +27,18 @@
  */
 import { VC7C_ENABLED } from "../../src/config.js";
 import { sendJson } from "./routes-vector-cortex-shared.js";
-import { countVcEvents, vcCount } from "./vc-event-counts.js";
 import { deriveVcStatus } from "./vc-status.js";
-// Actual events emitted by src/vector-cortex/cache/diagnostics-emit.ts.
-const DIAGNOSTICS_EVENTS = ["vector_cortex_cache_serve_blocked"];
+import { readLivewireSnapshot } from "../../src/vector-cortex/livewire/livewire-registry.js";
+// The flag-off deferred reason, kept byte-identical to the pre-LIVEWIRE
+// predecessor (VC7C: `cache_classifier_not_wired_v0_20_23`).
+const DEFERRED_REASON = "cache_classifier_not_wired_v0_20_23";
 /**
  * Reader-only GET /api/vector-cortex/cache-diagnostics (VC7C).
  *
- * Per-miss-class counts, breaker state, and CACHE and M5 codes only — a static
- * reader-only aggregate seam with the same shape as the VC7B economics handler.
+ * Per-miss-class counts, serveBlocked, breaker state, and CACHE/M5 codes only.
+ * With the flag ON it surfaces the LIVEWIRE classifier/breaker tallies
+ * accumulated at runtime; with the flag OFF it returns the byte-identical legacy
+ * deferred view (mode C, deferredReason present).
  */
 export function handleVectorCortexDiagnostics(req, res, ctx) {
     const url = req.url ?? "";
@@ -47,32 +50,50 @@ export function handleVectorCortexDiagnostics(req, res, ctx) {
         return true;
     }
     const enabled = VC7C_ENABLED();
-    const counts = countVcEvents(ctx.stateDir, DIAGNOSTICS_EVENTS);
-    // Flag-off routes to mode C: with VC7C off the diagnostics/breaker reporter is
-    // suppressed, so no cache serve is attested here and the surface reports the
-    // all-cache bypass outcome. Reporting A (crystal served) or B (fresh render
-    // forced by a breaker) would attest a cache decision this seam is not wired to
-    // observe. Mirrors how the VC7A/VC7B OFF views report the mode they take.
-    const mode = enabled ? "A" : "C";
+    if (!enabled) {
+        // Flag-off parity: byte-identical to the predecessor (mode C + deferred).
+        const body = {
+            enabled: false,
+            mode: "C",
+            profileMisses: 0,
+            rangeMisses: 0,
+            dependencyMisses: 0,
+            requestMisses: 0,
+            generationMisses: 0,
+            unknownMisses: 0,
+            serveBlocked: 0,
+            breakerState: "closed",
+            lastFailure: null,
+            updatedAt: new Date().toISOString(),
+            deferredReason: DEFERRED_REASON,
+            status: deriveVcStatus({ enabled: false, hasData: false }),
+        };
+        sendJson(res, 200, body);
+        return true;
+    }
+    const diag = readLivewireSnapshot(ctx.stateDir).diagnostics;
+    const hasData = diag.profileMisses +
+        diag.rangeMisses +
+        diag.dependencyMisses +
+        diag.requestMisses +
+        diag.generationMisses +
+        diag.unknownMisses +
+        diag.serveBlocked >
+        0;
     const body = {
-        enabled,
-        mode,
-        profileMisses: 0,
-        rangeMisses: 0,
-        dependencyMisses: 0,
-        requestMisses: 0,
-        generationMisses: 0,
-        unknownMisses: 0,
-        serveBlocked: vcCount(counts, "vector_cortex_cache_serve_blocked"),
-        breakerState: "closed",
-        lastFailure: null,
+        enabled: true,
+        mode: "A",
+        profileMisses: diag.profileMisses,
+        rangeMisses: diag.rangeMisses,
+        dependencyMisses: diag.dependencyMisses,
+        requestMisses: diag.requestMisses,
+        generationMisses: diag.generationMisses,
+        unknownMisses: diag.unknownMisses,
+        serveBlocked: diag.serveBlocked,
+        breakerState: diag.breakerState,
+        lastFailure: diag.lastFailure,
         updatedAt: new Date().toISOString(),
-        deferredReason: "cache_classifier_not_wired_v0_20_23",
-        status: deriveVcStatus({
-            enabled,
-            deferredReason: "cache_classifier_not_wired_v0_20_23",
-            hasData: vcCount(counts, "vector_cortex_cache_serve_blocked") > 0,
-        }),
+        status: deriveVcStatus({ enabled: true, hasData }),
     };
     sendJson(res, 200, body);
     return true;

package/dist/extensions/dashboard-server/routes-vector-cortex-economics.js

@@ -25,13 +25,19 @@
 import { VC7B_ENABLED } from "../../src/config.js";
 import { sendJson } from "./routes-vector-cortex-shared.js";
 import { deriveVcStatus } from "./vc-status.js";
+import { readLivewireSnapshot } from "../../src/vector-cortex/livewire/livewire-registry.js";
+// The flag-off deferred reason, kept byte-identical to the pre-LIVEWIRE
+// predecessor (VC7B: `economics_not_computed_v0_20_23`).
+const DEFERRED_REASON = "economics_not_computed_v0_20_23";
 /**
  * Reader-only GET /api/vector-cortex/cache-economics (VC7B).
  *
- * Counts, profile tallies, and ECON_* codes only — a static reader-only
- * aggregate seam with the same shape as the VC7A crystals handler.
+ * Counts, profile tallies, and ECON_* codes only. With the flag ON it surfaces
+ * the LIVEWIRE-provided profile economics tallies + the runtime `computed` bit;
+ * with the flag OFF it returns the byte-identical legacy deferred view (mode C,
+ * deferredReason present).
  */
-export function handleVectorCortexEconomics(req, res, _ctx) {
+export function handleVectorCortexEconomics(req, res, ctx) {
     const url = req.url ?? "";
     const path = url.split("?")[0] ?? url;
     if (path !== "/api/vector-cortex/cache-economics")
@@ -41,25 +47,32 @@ export function handleVectorCortexEconomics(req, res, _ctx) {
         return true;
     }
     const enabled = VC7B_ENABLED();
-    // Flag-off routes to mode C: with VC7B off no cache economics are served, which
-    // is exactly the spec's "economics bypass" outcome. Reporting A (cached render
-    // priced) or B (fresh render priced) would imply an economics path that is not
-    // wired at all. Mirrors how VC6C/VC7A OFF views report the mode they take.
-    const mode = enabled ? "A" : "C";
+    if (!enabled) {
+        // Flag-off parity: byte-identical to the predecessor (mode C + deferred).
+        const body = {
+            enabled: false,
+            mode: "C",
+            profileCount: 0,
+            provenExclusions: 0,
+            unprovenExclusions: 0,
+            lastFailure: null,
+            updatedAt: new Date().toISOString(),
+            deferredReason: DEFERRED_REASON,
+            status: deriveVcStatus({ enabled: false, hasData: false }),
+        };
+        sendJson(res, 200, body);
+        return true;
+    }
+    const econ = readLivewireSnapshot(ctx.stateDir).economics;
     const body = {
-        enabled,
-        mode,
-        profileCount: 0,
-        provenExclusions: 0,
-        unprovenExclusions: 0,
-        lastFailure: null,
+        enabled: true,
+        mode: "A",
+        profileCount: econ.profileCount,
+        provenExclusions: econ.provenExclusions,
+        unprovenExclusions: econ.unprovenExclusions,
+        lastFailure: econ.lastFailure,
         updatedAt: new Date().toISOString(),
-        deferredReason: "economics_not_computed_v0_20_23",
-        status: deriveVcStatus({
-            enabled,
-            deferredReason: "economics_not_computed_v0_20_23",
-            hasData: false,
-        }),
+        status: deriveVcStatus({ enabled: true, hasData: econ.computed }),
     };
     sendJson(res, 200, body);
     return true;

package/dist/extensions/dashboard-server/routes-vector-cortex-helpers.js

@@ -98,3 +98,57 @@ export async function seedEval(dir) {
         { session: "s1", seq: 4, event: "encode", value: 12, unit: "ms", mode: "A" },
     ]);
 }
+/**
+ * Seed a LIVEWIRE aggregate snapshot directly on disk so the spawned dashboard
+ * server (a separate process) rehydrates real subsystem counts and its reader-only
+ * routes report LIVE (non-deferred) data. This is how the LIVEWIRE route tests
+ * prove the wiring: the runtimes' persisted counts are exactly what a reader
+ * process reconstructs. Counts + codes + triad mode only (SECURITY_PRIVACY).
+ */
+export async function seedLivewireSnapshot(dir, overrides) {
+    const { saveLivewireSnapshot } = await import("../../src/vector-cortex/livewire/livewire-snapshot.js");
+    const c = overrides?.crystals ?? {};
+    const d = overrides?.diagnostics ?? {};
+    const e = overrides?.economics ?? {};
+    const p = overrides?.policy ?? {};
+    saveLivewireSnapshot(dir, {
+        schema: "vector-cortex-livewire-v1",
+        crystals: {
+            mode: "A",
+            crystalCount: c.crystalCount ?? 3,
+            totalBytes: c.totalBytes ?? 1024,
+            hits: c.hits ?? 0,
+            misses: c.misses ?? 0,
+            hitBytes: c.hitBytes ?? 0,
+            writes: c.writes ?? 0,
+            duplicateWrites: c.duplicateWrites ?? 0,
+            collisions: c.collisions ?? 0,
+        },
+        diagnostics: {
+            profileMisses: d.profileMisses ?? 0,
+            rangeMisses: d.rangeMisses ?? 0,
+            dependencyMisses: d.dependencyMisses ?? 0,
+            requestMisses: d.requestMisses ?? 0,
+            generationMisses: d.generationMisses ?? 0,
+            unknownMisses: d.unknownMisses ?? 0,
+            serveBlocked: d.serveBlocked ?? 0,
+            breakerState: d.breakerState ?? "CLOSED_A",
+            lastFailure: null,
+        },
+        economics: {
+            profileCount: e.profileCount ?? 4,
+            provenExclusions: e.provenExclusions ?? 1,
+            unprovenExclusions: e.unprovenExclusions ?? 0,
+            computed: e.computed ?? true,
+            lastFailure: null,
+        },
+        policy: {
+            shadowDecisions: p.shadowDecisions ?? 0,
+            clampedDecisions: p.clampedDecisions ?? 0,
+            rejectedInputs: p.rejectedInputs ?? 0,
+            liveMutations: p.liveMutations ?? 0,
+            pressureVersion: (p.pressureVersion ?? 1),
+            lastFailure: null,
+        },
+    });
+}

package/dist/extensions/dashboard-server/routes-vector-cortex-policy.js

@@ -18,8 +18,12 @@
 import { VC8B_ENABLED } from "../../src/config.js";
 import { sendJson } from "./routes-vector-cortex-shared.js";
 import { deriveVcStatus } from "./vc-status.js";
+import { readLivewireSnapshot } from "../../src/vector-cortex/livewire/livewire-registry.js";
+// The flag-off deferred reason, kept byte-identical to the pre-LIVEWIRE
+// predecessor (VC8B: `shadow_controller_not_instantiated_v0_20_23`).
+const DEFERRED_REASON = "shadow_controller_not_instantiated_v0_20_23";
 /** GET /api/vector-cortex/policy — reader-only policy + shadow aggregate (VC8B). */
-export function handleVectorCortexPolicy(req, res, _ctx) {
+export function handleVectorCortexPolicy(req, res, ctx) {
     const url = req.url ?? "";
     const path = url.split("?")[0] ?? url;
     if (path !== "/api/vector-cortex/policy")
@@ -29,23 +33,36 @@ export function handleVectorCortexPolicy(req, res, _ctx) {
         return true;
     }
     const enabled = VC8B_ENABLED();
-    const mode = enabled ? "A" : "C";
+    if (!enabled) {
+        // Flag-off parity: byte-identical to the predecessor (mode C + deferred).
+        const body = {
+            enabled: false,
+            mode: "C",
+            shadowDecisions: 0,
+            clampedDecisions: 0,
+            rejectedInputs: 0,
+            liveMutations: 0,
+            pressureVersion: 1,
+            lastFailure: null,
+            updatedAt: new Date().toISOString(),
+            deferredReason: DEFERRED_REASON,
+            status: deriveVcStatus({ enabled: false, hasData: false }),
+        };
+        sendJson(res, 200, body);
+        return true;
+    }
+    const policy = readLivewireSnapshot(ctx.stateDir).policy;
     const body = {
-        enabled,
-        mode,
-        shadowDecisions: 0,
-        clampedDecisions: 0,
-        rejectedInputs: 0,
-        liveMutations: 0,
-        pressureVersion: 1,
-        lastFailure: null,
+        enabled: true,
+        mode: "A",
+        shadowDecisions: policy.shadowDecisions,
+        clampedDecisions: policy.clampedDecisions,
+        rejectedInputs: policy.rejectedInputs,
+        liveMutations: policy.liveMutations,
+        pressureVersion: policy.pressureVersion,
+        lastFailure: policy.lastFailure,
         updatedAt: new Date().toISOString(),
-        deferredReason: "shadow_controller_not_instantiated_v0_20_23",
-        status: deriveVcStatus({
-            enabled,
-            deferredReason: "shadow_controller_not_instantiated_v0_20_23",
-            hasData: false,
-        }),
+        status: deriveVcStatus({ enabled: true, hasData: policy.shadowDecisions > 0 }),
     };
     sendJson(res, 200, body);
     return true;

package/dist/src/vector-cortex/cache/store.js

@@ -70,6 +70,11 @@ export class CrystalStore {
     writes = 0;
     duplicateWrites = 0;
     collisions = 0;
+    /** Restart-survival crystal count/bytes (LIVEWIRE rehydrate). The `committed`
+     *  map is empty in a fresh process; these offsets carry the persisted totals
+     *  so the dashboard does not reset to zero on restart. */
+    rehydratedCrystalCount = 0;
+    rehydratedTotalBytes = 0;
     /** Freeze a crystal object for a key/bytes pair (digest computed here). */
     static freeze(keyDigest, bytes, key) {
         const copy = new Uint8Array(bytes);
@@ -178,12 +183,12 @@ export class CrystalStore {
     }
     /** Reader-only aggregate for the dashboard seam — counts and bytes only. */
     stats() {
-        let totalBytes = 0;
+        let totalBytes = this.rehydratedTotalBytes;
         for (const c of this.committed.values())
             totalBytes += c.byteCount;
         return {
             mode: this.mode(),
-            crystalCount: this.committed.size,
+            crystalCount: this.rehydratedCrystalCount + this.committed.size,
             totalBytes,
             hits: this.hits,
             misses: this.misses,
@@ -193,4 +198,22 @@ export class CrystalStore {
             collisions: this.collisions,
         };
     }
+    /**
+     * Restart survival: seed the CUMULATIVE counters from a previously-persisted
+     * aggregate (LIVEWIRE). The in-memory `committed` map is naturally empty in a
+     * fresh process — this only restores the running totals the dashboard reports,
+     * so a process restart does not reset the dashboard to zero. It deliberately
+     * does NOT reconstruct crystals: frozen bytes are never persisted to the
+     * reader aggregate, only the counts.
+     */
+    rehydrate(stats) {
+        this.rehydratedCrystalCount = stats.crystalCount;
+        this.rehydratedTotalBytes = stats.totalBytes;
+        this.hits = stats.hits;
+        this.misses = stats.misses;
+        this.hitBytes = stats.hitBytes;
+        this.writes = stats.writes;
+        this.duplicateWrites = stats.duplicateWrites;
+        this.collisions = stats.collisions;
+    }
 }

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

@@ -67,7 +67,14 @@ function isManifest(m) {
         typeof o.onnx.path === "string" &&
         typeof o.onnx.sha256 === "string" &&
         typeof o.tokenizer.path === "string" &&
-        typeof o.tokenizer.sha256 === "string");
+        typeof o.tokenizer.sha256 === "string" &&
+        // ML5-A (VC2B-2): optional headWeights must, when present, be a valid
+        // ManifestAssetFile (path basename + sha256 + bytes).
+        (o.headWeights === undefined ||
+            (!!o.headWeights &&
+                typeof o.headWeights.path === "string" &&
+                typeof o.headWeights.sha256 === "string" &&
+                typeof o.headWeights.bytes === "number")));
 }
 /**
  * Verify the asset manifest + digest + constraints BEFORE allocation.
@@ -107,6 +114,11 @@ export function verifyEncoderAsset(assetDir, manifest, platform = detectPlatform
     if (!isBasename(manifest.onnx.path) || !isBasename(manifest.tokenizer.path)) {
         return { ok: false, code: ENC_FAIL.MANIFEST_INVALID };
     }
+    // ML5-A (VC2B-2): a manifest-declared headWeights path must also be a bare
+    // basename (no traversal into arbitrary paths off the asset dir).
+    if (manifest.headWeights !== undefined && !isBasename(manifest.headWeights.path)) {
+        return { ok: false, code: ENC_FAIL.MANIFEST_INVALID };
+    }
     const onnxPath = join(assetDir, manifest.onnx.path);
     const onnxDigest = digestFile(onnxPath);
     if (onnxDigest === null)
@@ -119,6 +131,19 @@ export function verifyEncoderAsset(assetDir, manifest, platform = detectPlatform
         return { ok: false, code: ENC_FAIL.ASSET_UNREADABLE };
     if (tokDigest !== manifest.tokenizer.sha256)
         return { ok: false, code: ENC_FAIL.DIGEST_MISMATCH };
+    // ML5-A (VC2B-2): verify the manifest-pinned trained-heads sibling when the
+    // manifest declares it. Absent declaration -> headWeightsDigest: null and no
+    // failure (committed placeholder bundle ships no trained weights).
+    let headWeightsDigest = null;
+    if (manifest.headWeights !== undefined) {
+        const hwPath = join(assetDir, manifest.headWeights.path);
+        const hwDigest = digestFile(hwPath);
+        if (hwDigest === null)
+            return { ok: false, code: ENC_FAIL.ASSET_UNREADABLE };
+        if (hwDigest !== manifest.headWeights.sha256)
+            return { ok: false, code: ENC_FAIL.DIGEST_MISMATCH };
+        headWeightsDigest = hwDigest;
+    }
     let embeddedBytes = 0;
     try {
         embeddedBytes = statSync(onnxPath).size + statSync(tokPath).size;
@@ -126,7 +151,14 @@ export function verifyEncoderAsset(assetDir, manifest, platform = detectPlatform
     catch {
         return { ok: false, code: ENC_FAIL.ASSET_UNREADABLE };
     }
-    return { ok: true, embeddedBytes, maxTokens: manifest.maxTokens, onnxDigest, tokenizerDigest: tokDigest };
+    return {
+        ok: true,
+        embeddedBytes,
+        maxTokens: manifest.maxTokens,
+        onnxDigest,
+        tokenizerDigest: tokDigest,
+        headWeightsDigest,
+    };
 }
 /**
  * Read + shape-check a committed ModelManifestV1 from an asset directory.

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

@@ -25,11 +25,12 @@
  * Pi-agnostic, zero network (PREVENT-PI-004), no `any` (PREVENT-011).
  */
 import { createEncoderRuntime } from "./runtime.js";
-import { encodeVectorSet } from "./heads.js";
+import { encodeVectorSet, loadHeadProjections, projectHeadFromTrunk, } from "./heads.js";
 import { embedTrigram512, selectTrigramBFallback } from "./trigram.js";
 import { embedLexical, selectLexicalC } from "./lexical.js";
 import { createEncoderHeadsReporter } from "./emit-vc2b.js";
-import { ENC_FAIL, } from "./types.js";
+import { ML5A_ENABLED } from "../../config/vector-cortex.js";
+import { ENC_FAIL, ENCODER_HEAD_ORDER, } from "./types.js";
 /** Deterministic text derived from an int token sequence so the asset-free
  *  fallback producers operate on the same authority the learned path encoded. */
 function textFromTokens(tokens) {
@@ -92,9 +93,36 @@ export function encodeOrFallback(input, assetDir, options = {}) {
     if (!inferred.ok) {
         return fallbackFromLoad({ ok: false, mode: "B", code: inferred.code }, reporter, tokens);
     }
-    const vectorSet = encodeVectorSet(tokens, { reporter, seed: options.seed });
+    const vectorSet = produceVectorSet(inferred.semantic, tokens, options, reporter);
     return { ok: true, mode: "A", vectorSet, code: null };
 }
+/**
+ * Produce a mode-A `VectorSetV1` from the [1,384] trunk embedding (the
+ * `runtime.infer` result). VC2B-2 ML5-A: when real trained heads are loaded
+ * (`MEGACOMPACT_ML5_A` on + a `trainedHeadsPath` that loads), the multi-head
+ * output is projected through the real trained projection matrices via
+ * `projectHeadFromTrunk`. Otherwise (flag-off / absent / unloadable artifact)
+ * the deterministic LCG placeholder `encodeVectorSet` serves mode A —
+ * byte-identical to the VC2B predecessor. Non-fatal: an unloadable artifact
+ * degrades to the placeholder, never a throw.
+ */
+function produceVectorSet(trunkEmbedding, tokens, options, reporter) {
+    const table = ML5A_ENABLED() && options.trainedHeadsPath !== undefined
+        ? loadHeadProjections(options.trainedHeadsPath)
+        : null;
+    if (table !== null) {
+        const heads = ENCODER_HEAD_ORDER.map((h) => projectHeadFromTrunk(h, trunkEmbedding, table));
+        reporter.headsEmitted({
+            heads: heads.length,
+            dims: heads.map((h) => h.dim).join("/"),
+            normalized: true,
+            tokens: tokens.length,
+        });
+        return { schema: "vector-set-v1", inputTokens: [...tokens], heads, normalized: true };
+    }
+    // ML5-A placeholder fallback (byte-identical predecessor).
+    return encodeVectorSet(tokens, { reporter, seed: options.seed });
+}
 /**
  * Catch a (real or forced) A load failure (ok === false only) and select the
  * B/C fallback that emits `vector_cortex_encoder_fallback_selected` from the