pi-mega-compact 0.20.34 → 0.20.36

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

@@ -0,0 +1,28 @@
+/**
+ * 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 = () => sprintFlag("MEGACOMPACT_ML5_A");

package/dist/config/vector-cortex.js

@@ -239,16 +239,15 @@ export const VC8A_ENABLED = () => sprintFlag("MEGACOMPACT_VC8A");
  * mirroring VC4A..VC8A.
  */
 export const VC8B_ENABLED = () => 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";
 // 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, 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, 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

@@ -53,5 +53,6 @@ export const VECTOR_CORTEX_SETTINGS = {
         boolDirect("MEGACOMPACT_VC9C", "VC9C SetupTab Cortex Sub-tab", "SetupTab Cortex sub-tab (client UI): a Cortex sub-tab inside SetupTab that consumes the VC9A status endpoint (GET /api/setup-cortex-status) + the VC9B action endpoints. It surfaces the encoder mode A/B/C, asset digest prefix, qualification verdict + threshold failures, the open hard-gate blockers, and the confirmation-gated fetch/bench/verify actions. OFF = byte-identical predecessor (VC9B-era): the Cortex sub-tab is filtered from SUB_TABS and the Setup tab renders exactly as before.", true),
         boolDirect("MEGACOMPACT_VC9D", "VC9D Embedder Detect Consolidation", "Embedder-detect consolidation + VC9 workstream roll-up: memoizes /api/setup-detect against the mutable input (resolved binary path + mtime) so consecutive requests reuse the result without re-spawning, and unifies the embedder + cortex sub-tabs' 5s poll contract. OFF = byte-identical predecessor (VC9C-era): detect spawns fresh per request and the embedder poll keeps its previous cadence.", true),
         boolDirect("MEGACOMPACT_PC_C", "PC-C Dashboard Cache Visibility", "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/dist/extensions/mega-events/context-handler/afterCompact.js

@@ -7,6 +7,7 @@
  * raw_transcript, and fire-and-forgets the dedup pipeline. All best-effort +
  * non-fatal — a failure never breaks the agent loop.
  */
+import { createHash } from "node:crypto";
 import { openStore, writeCheckpointEpoch, } from "../../../src/store/sqlite.js";
 import { epochIdFor } from "../../../src/mirror/epoch.js";
 import { stampTurnsEpochFor } from "../../mega-turn-store.js";
@@ -17,6 +18,7 @@ import { assignNewMemoriesIncremental } from "../../../src/wiki/index.js";
 import { TrigramEmbedder } from "../../../src/embedder.js";
 import { reportClosureOptimized } from "../../../src/vector-cortex/heal/emit.js";
 import { reportRepairPlanned } from "../../../src/vector-cortex/heal/repair-emit.js";
+import { buildPostCompactViews, drivePostCompactRepair, } from "./controller.js";
 import { VC6A_ENABLED, VC6C_ENABLED } from "../../../src/config/vector-cortex.js";
 /**
  * Persist the checkpoint_epoch, stamp turns, rebuild the auto-wiki, seed the
@@ -215,9 +217,8 @@ export async function persistEpochAndMaintain(runtime, config, ran) {
             runtime.logger.warn("db-mirror-epoch-fail", { error: String(e) });
         }
     }
-    // VC6 Heal lifecycle emits (post-compact). Wiring stubs — dashboard graph +
-    // event counts move; real gap detection/rebuild is a future sprint.
-    // VC6A: closure-optimization savings from the compact token delta.
+    // VC6 Heal lifecycle emits (post-compact). VC6A: closure-optimization
+    // savings from the compact token delta.
     const savings = Math.max(0, (ran.result.originalTokenEstimate ?? 0) - (ran.result.tokenEstimate ?? 0));
     if (VC6A_ENABLED()) {
         try {
@@ -232,8 +233,36 @@ export async function persistEpochAndMaintain(runtime, config, ran) {
             /* non-fatal: VC6A heal emit never breaks compaction */
         }
     }
-    // VC6C: repair-planner placeholder (no real gap detection yet).
+    // VC6C: real post-compact gap detection + atomic repair drive (VC6C-IMPL).
+    // Builds each derived subsystem's pre/post compact view against the durable
+    // authority high-water, runs the heal eligibility policy (gap-ness, frozen
+    // authority, mode C, the 5-min rate limit), and only on a REAL gap routes
+    // plan -> rebuild -> emit the three repair events. No real gap => emit
+    // NOTHING (VC6C-IMPL-006: no rebuild without a real gap). Flag OFF keeps the
+    // predecessor placeholder byte-identical (reportRepairPlanned with hardcoded
+    // backoffMs:0, gapSize:compactedFrom) and rebuild is a no-op — the reported
+    // seam is flag-gated, so the placeholder emits nothing, exactly as before.
     if (VC6C_ENABLED()) {
+        try {
+            const emit = (name, payload) => runtime.appendEvent(name, payload);
+            const views = buildPostCompactViews(ran.result.compactedFrom, runtime.rt.compactCount);
+            drivePostCompactRepair(views, BigInt(Date.now()), emit, () => {
+                // The derived generation for the repaired range is re-materialized
+                // from the compact summary and verified as a strict successor.
+                const bytes = new Uint8Array(Buffer.from(ran.result.summary, "utf8"));
+                const digest = createHash("sha256")
+                    .update(bytes)
+                    .digest("hex");
+                return { sourceBytes: bytes, expectedDigest: digest };
+            });
+        }
+        catch {
+            /* non-fatal: VC6C heal repair never breaks compaction */
+        }
+    }
+    else {
+        // Flag-off: predecessor placeholder, byte-identical (emits nothing via
+        // the flag-gated reporter seam).
         try {
             reportRepairPlanned((name, payload) => runtime.appendEvent(name, payload), {
                 subsystem: "post_compact",

package/dist/extensions/mega-events/context-handler/controller.js

@@ -0,0 +1,161 @@
+/**
+ * context-handler/controller.ts — VC6C-IMPL production post-compact gap
+ * detection + repair drive.
+ *
+ * The production seam that makes the VC6C self-healing controller REAL: after a
+ * compact, compare each derived subsystem's POST-compact chunk count against the
+ * durable authority high-water. A subsystem whose derived high-water fell behind
+ * authority has a REAL gap; only then does the drive route through the plan →
+ * rebuild → emit pipeline. When there is no real gap, NOTHING is emitted (no
+ * rebuild without a real gap — VC6C-IMPL-006).
+ *
+ * PURE POLICY DEFERS TO heal/. Gap-ness, the four refusal rules (frozen
+ * authority / no gap / mode C / rate limit), and the deterministic backoff are
+ * the VC6C heal primitives' job (`detectGaps`, `isPlannable`, `computeBackoff`
+ * — 74 tested lines). This file owns ONLY the production mapping: `PostCompactView`
+ * → `RepairState` (so heal policy can judge it) → `RepairPlanV1` (production
+ * shape) → `AtomicRebuild` (atomic pointer switch) → the three repair events.
+ * Flag OFF = the placeholder continues firing exactly as today and rebuild is a
+ * no-op; see `drivePostCompactRepair`'s caller in afterCompact.ts.
+ *
+ * THE AUTHORITY IS NEVER WRITTEN. `PostCompactView.authorityHighWater` is read to
+ * decide gap-ness; no code here has a write path to the durable authority.
+ *
+ * PURE-ish + CONSTANT-FREE. `nowMs` is always injected (fake-clock fixtures).
+ * Backoff/gap come from the plan, never a literal. No console, no network
+ * (PREVENT-PI-004). Emit is an injected callback so the drive is unit-testable
+ * without a runtime.
+ */
+import { isPlannable } from "../../../src/vector-cortex/heal/controller.js";
+import { reportRepairBackoff, reportRepairPlanned, reportRepairPointerSwitched, } from "../../../src/vector-cortex/heal/repair-emit.js";
+import { buildRepairPlan, gapSizeOf, } from "../../../src/vector-cortex/reconstruct/repair-plan.js";
+import { rebuildRepairRange, } from "../../../src/vector-cortex/reconstruct/rebuild.js";
+/**
+ * Detect the subsystems whose POST-compact derived high-water fell behind the
+ * durable authority. `left` is the pre-compact view, `right` the post-compact
+ * view (aligned by subsystem name); a subsystem qualifies when its POST count
+ * is strictly below its durable authority high-water. Pure — no clock, no
+ * writes.
+ */
+export function detectPostCompactGaps(left, right) {
+    const byName = new Map(right.map((v) => [v.subsystem, v]));
+    const gapped = [];
+    for (const l of left) {
+        const r = byName.get(l.subsystem);
+        if (r === undefined)
+            continue;
+        if (r.postCount < r.authorityHighWater)
+            gapped.push(r);
+    }
+    return gapped;
+}
+/** Map a production post-compact view into the heal `RepairState` judge shape. */
+export function toRepairState(view) {
+    return {
+        subsystem: view.subsystem,
+        derivedHighWater: BigInt(view.postCount),
+        authorityHighWater: BigInt(view.authorityHighWater),
+        lastRebuildAt: view.lastRebuildAtMs,
+        generation: view.generation,
+        mode: view.mode,
+        ...(view.failedAttempts !== undefined ? { failedAttempts: view.failedAttempts } : {}),
+        ...(view.authorityFrozen !== undefined ? { authorityFrozen: view.authorityFrozen } : {}),
+    };
+}
+/** Build the production plan for one gapped view. */
+export function planFor(view) {
+    return buildRepairPlan(view);
+}
+function rebuildInputFor(plan, src) {
+    return {
+        subsystem: plan.subsystem,
+        range: {
+            sessionId: plan.subsystem,
+            seqStart: BigInt(plan.range[0]),
+            seqEnd: BigInt(plan.range[1]),
+            byteStart: 0,
+            byteEnd: 0,
+        },
+        generation: plan.generation,
+        sourceBytes: src.sourceBytes,
+        expectedDigest: src.expectedDigest,
+    };
+}
+/**
+ * Drive one repair for a gapped subsystem: plan → rebuild → emit.
+ *
+ * Emits `reportRepairPlanned` first (the plan with its deterministic backoff),
+ * then executes the atomic rebuild; a verified strict-successor switch emits
+ * `reportRepairPointerSwitched`, a failed rebuild emits `reportRepairBackoff`.
+ * `currentGeneration` (the live generation) is read for the monotonic switch.
+ */
+export function driveOneRepair(view, emit, rebuildSource) {
+    const plan = planFor(view);
+    reportRepairPlanned(emit, {
+        subsystem: plan.subsystem,
+        generation: plan.generation,
+        backoffMs: plan.backoffMs,
+        gapSize: gapSizeOf(view),
+    });
+    const rebuilt = rebuildRepairRange(plan, rebuildInputFor(plan, rebuildSource), view.generation, view.mode);
+    if (rebuilt.pointer.switched) {
+        reportRepairPointerSwitched(emit, {
+            subsystem: plan.subsystem,
+            fromGeneration: view.generation,
+            toGeneration: plan.generation,
+            mode: view.mode,
+        });
+    }
+    else {
+        reportRepairBackoff(emit, {
+            subsystem: plan.subsystem,
+            code: rebuilt.result.ok ? "HEAL_REPAIR_RATE_LIMITED" : (rebuilt.result.code ?? "HEAL_REBUILD_FAILED"),
+            backoffMs: plan.backoffMs,
+            attempt: view.failedAttempts ?? 0,
+        });
+    }
+    return { plan, rebuilt };
+}
+/**
+ * The full post-compact repair drive. Applies heal's eligibility policy
+ * (`isPlannable` — rate limit, no gap, frozen authority, mode C) per subsystem,
+ * and only runs `driveOneRepair` for subsystems with a REAL, actionable gap. A
+ * subsystem with no real gap, or inside its rate-limit window, emits NOTHING.
+ *
+ * `rebuildSourceFor` is an injected executor that materializes a new generation
+ * for a plannable subsystem (the handler supplies the real one; fixtures supply
+ * a deterministic one), keeping the drive testable without a runtime.
+ */
+export function drivePostCompactRepair(views, nowMs, emit, rebuildSourceFor) {
+    for (const view of views) {
+        const state = toRepairState(view);
+        if (!isPlannable(state, nowMs))
+            continue;
+        driveOneRepair(view, emit, rebuildSourceFor(view));
+    }
+}
+/**
+ * Build the production post-compact subsystem views from a compact result.
+ *
+ * `compactedFrom` is the committed seq frontier after compaction. In a NORMAL
+ * compact the derived post-count equals the durable authority high-water (they
+ * advance together), so the resulting view has NO real gap — the drive emits
+ * nothing (VC6C-IMPL-006). A caller that derives per-subsystem counts where a
+ * derived tier fell behind authority supplies those lower counts here, and the
+ * drive will detect the gap and repair it. `currentGeneration` seeds the derived
+ * generation counter.
+ */
+export function buildPostCompactViews(compactedFrom, currentGeneration, authorityHighWater = compactedFrom, postCount = compactedFrom) {
+    return [
+        {
+            subsystem: "post_compact",
+            preCount: compactedFrom,
+            postCount,
+            authorityHighWater,
+            generation: currentGeneration,
+            failedAttempts: 0,
+            mode: "A",
+            lastRebuildAtMs: null,
+        },
+    ];
+}

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

@@ -0,0 +1,28 @@
+/**
+ * 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 = () => sprintFlag("MEGACOMPACT_ML5_A");

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

@@ -239,16 +239,15 @@ export const VC8A_ENABLED = () => sprintFlag("MEGACOMPACT_VC8A");
  * mirroring VC4A..VC8A.
  */
 export const VC8B_ENABLED = () => 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";
 // 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, 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, 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/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/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/src/vector-cortex/heal/_vc6c-impl-fixture.js

@@ -0,0 +1,29 @@
+/**
+ * heal/_vc6c-impl-fixture.ts — conformance fixture I/O for VC6C-IMPL
+ * self-healing-controller rows.
+ *
+ * VC6C's base corpus lives under `healing-controller/` (read by
+ * `_repair-fixture.ts`); VC6C-IMPL emits its six fixtures under
+ * `self-healing/` per the sprint brief. Both share the one canonical
+ * `healing-controller-fixture.schema.json`, so this loader reuses the
+ * `RepairFx` envelope (`_repair-fixture.ts`) but resolves fixture paths from
+ * the `self-healing/` directory. No mocks — the committed fixtures are fed
+ * verbatim into the real heal / reconstruct production modules.
+ */
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import assert from "node:assert/strict";
+import { V2, readManifest } from "./_acceptance-fixture.js";
+const PREFIX = "self-healing";
+/** Read one registered VC6C-IMPL fixture (asserting it IS registered). */
+export function vc6cImplFixture(id) {
+    const m = readManifest();
+    const row = m.fixtures.find((f) => f.id === id && f.path.startsWith(`${PREFIX}/`));
+    assert.ok(row, `fixture ${id} registered under ${PREFIX}/ in manifest`);
+    return JSON.parse(readFileSync(join(V2, row.path), "utf8"));
+}
+/**
+ * The six VC6C-IMPL fixture ids, in corpus order. The acceptance test drives
+ * each through the real production seam and asserts its pinned verdict.
+ */
+export const VC6C_IMPL_IDS = Array.from({ length: 6 }, (_v, i) => `VC6C-IMPL-${String(i + 1).padStart(3, "0")}`);

package/dist/src/vector-cortex/reconstruct/rebuild.js

@@ -0,0 +1,43 @@
+/**
+ * vector-cortex/reconstruct/rebuild.ts — VC6C-IMPL production atomic rebuild.
+ *
+ * The thin *production executor* over the pure `heal/rebuild.ts` copy-verify-
+ * switch primitives. It materializes a NEW derived generation for the planned
+ * range, verifies the root manifest digest is a STRICT SUCCESSOR (the planned
+ * `generation` is `current + 1` and the switch refuses any non-monotonic move),
+ * and swaps the pointer in a single atomic commit. A failed verification keeps
+ * the old pointer and DELETES NO EVIDENCE: the orphaned generation is retained
+ * for inspection (heal/rebuild.ts crash-safety contract).
+ *
+ * REUSES, DOES NOT FORK. `rebuildGeneration` + `switchPointer` are the same
+ * functions VC6C shipped and tested (74 tests). This file only binds them to
+ * the production `RepairPlanV1` shape and the atomic-commit framing the
+ * post-compact handler calls — the whole point of VC6C-IMPL is that the pure
+ * primitives already exist and only the production seam was missing.
+ *
+ * STRICT SUCCESSOR. The pointer moves only when (a) verification passed and
+ * (b) the new generation is STRICTLY greater than the current one. Replaying a
+ * stale plan after a restart cannot roll the pointer backwards — the same
+ * monotonic guard `heal/rebuild.ts#switchPointer` enforces.
+ *
+ * THE AUTHORITY IS NEVER MUTATED. This rebuild only swaps the DERIVED generation
+ * pointer; the durable authority is untouched. `currentGeneration` is read to
+ * enforce monotonicity, never written.
+ *
+ * PURE. No storage, no console, no network (PREVENT-PI-004 / PREVENT-011);
+ * `node:crypto` comes via the heal digest helper.
+ */
+import { rebuildAndSwitch, } from "../heal/rebuild.js";
+/**
+ * Materialize + atomically switch a planned repair range.
+ *
+ * `rebuildInput` carries the materialized new-generation bytes and the root
+ * digest the plan pinned. The helper reuses `heal/rebuild.ts#rebuildAndSwitch`,
+ * which verifies the digest FIRST and refuses to switch under any combination of
+ * failed verification or non-strict generation — "switch without verifying" is
+ * not expressible.
+ */
+export function rebuildRepairRange(plan, rebuildInput, currentGeneration, mode = "A") {
+    const { result, pointer } = rebuildAndSwitch(rebuildInput, currentGeneration, mode);
+    return { plan, result, pointer };
+}