pi-mega-compact 0.20.38 → 0.20.40

package/extensions/dashboard-client/src/types/cortex-improve.ts

@@ -0,0 +1,42 @@
+/**
+ * dashboard-client/src/types/cortex-improve.ts — ML5-D Improve Cortex client types.
+ *
+ * Client-side mirrors of the server contract (extensions/dashboard-server/
+ * api-contracts/cortex-improve.ts), kept in lockstep so the ModelImprovementCard
+ * is fully typed end-to-end. The client bundle does not import the server tree,
+ * so these are redeclared here (PREVENT-011: no `any`; every type explicit).
+ * Aggregate values only — mode/verdict/digest/reason/progress, never payload
+ * bytes or corpus content (EVAL-REDACT-002).
+ */
+
+/** The five-head qualification verdict projected by an improve job. */
+export interface QualificationV1 {
+  readonly mode: "A" | "B" | "C";
+  readonly assetDigestPrefix: string | null;
+  readonly verdict: "qualified" | "demoted";
+  readonly reasonCode?: string;
+}
+
+/** Response body for POST /api/cortex/improve. */
+export interface CortexImproveStart {
+  readonly status: "improving";
+  readonly jobId: string;
+}
+
+/** Response body for GET /api/cortex/improve/status/:jobId. */
+export type CortexImproveStatus =
+  | {
+      readonly status: "improving";
+      readonly progress: number;
+    }
+  | {
+      readonly status: "qualified";
+      readonly progress: number;
+      readonly verdict: QualificationV1;
+      readonly assetDigest: string;
+    }
+  | {
+      readonly status: "demoted_to_B";
+      readonly progress: number;
+      readonly reason: string;
+    };

package/extensions/dashboard-server/api-contracts/cortex-improve.ts

@@ -0,0 +1,82 @@
+/**
+ * api-contracts/cortex-improve.ts — ML5-D "Improve Cortex" job API types.
+ *
+ * Types for POST /api/cortex/improve (launch a local ML5-A training job that
+ * re-qualifies the five heads against the latest local corpus) and GET
+ * /api/cortex/improve/status/:jobId (poll the in-process job state to a
+ * terminal qualified / demoted_to_B verdict). Local-only, aggregate surfaces:
+ * mode / verdict / digest / reason / progress — never message content or corpus
+ * rows (EVAL-REDACT-002).
+ *
+ * PREVENT-PI-004: type definitions only, no network code.
+ * PREVENT-011: no `any` type — all types are explicit.
+ */
+
+/**
+ * The five-head qualification verdict projected from the improve job.
+ * Aggregate-only: current surrogate mode + asset digest prefix + a reason code
+ * when the asset failed to qualify (never weights or corpus content).
+ */
+export interface QualificationV1 {
+  /** Surrogate encoder mode the improve job would promote to on success. */
+  readonly mode: "A" | "B" | "C";
+  /** First 12 hex chars of the produced asset manifest digest, or null. */
+  readonly assetDigestPrefix: string | null;
+  /** Terminal verdict: qualified when the heads fit within gate, else demoted. */
+  readonly verdict: "qualified" | "demoted";
+  /** A stable reason code when verdict is "demoted" (e.g. ENC_ASSET_UNREADABLE). */
+  readonly reasonCode?: string;
+}
+
+/** Response body for POST /api/cortex/improve (confirmation-gated). */
+export interface CortexImproveStart {
+  /** Always "improving" immediately after the job is spawned. */
+  readonly status: "improving";
+  /** Opaque job token (sha256 of ts+random, hex-sliced), pollable via status. */
+  readonly jobId: string;
+}
+
+/** Lifecycle status of a Cortex improve job (in-process, restart-scoped). */
+export type CortexImproveJobStatus =
+  | "improving"
+  | "qualified"
+  | "demoted_to_B";
+
+/** Progressing (non-terminal) response for GET /api/cortex/improve/status/:jobId. */
+export interface CortexImproveProgress {
+  readonly status: "improving";
+  /** 0..1 progress through the local ML5-A training run. */
+  readonly progress: number;
+}
+
+/** Terminal success: the five heads re-qualified under mode A. */
+export interface CortexImproveQualified {
+  readonly status: "qualified";
+  readonly progress: number;
+  readonly verdict: QualificationV1;
+  readonly assetDigest: string;
+}
+
+/** Terminal demotion: the re-trained heads failed to qualify — stay mode B. */
+export interface CortexImproveDemoted {
+  readonly status: "demoted_to_B";
+  readonly progress: number;
+  readonly reason: string;
+}
+
+/** Response body for GET /api/cortex/improve/status/:jobId. */
+export type CortexImproveStatus =
+  | CortexImproveProgress
+  | CortexImproveQualified
+  | CortexImproveDemoted;
+
+/** Error body returned when the improve surface is disabled (flag off). */
+export interface CortexImproveDisabled {
+  readonly error: "disabled";
+}
+
+/** Request body for POST /api/cortex/improve. `confirm:true` is the server-side hard requirement. */
+export interface CortexImproveStartRequest {
+  /** Required explicit confirmation. Absent/false → 400 confirmation_required. */
+  readonly confirm: boolean;
+}

package/extensions/dashboard-server/api-contracts/endpoints/registry-ext.ts

@@ -25,6 +25,11 @@ import type {
   SetupCortexActionLogResponse,
 } from "../setup-cortex.js";
 import type { PrefixStabilityResponse } from "../prefix-stability.js";
+import type {
+  CortexImproveStartRequest,
+  CortexImproveStart,
+  CortexImproveStatus,
+} from "../cortex-improve.js";
 
 /** Additive endpoint entries spread into the ENDPOINTS registry. */
 export const EXTRA_ENDPOINTS = {
@@ -123,4 +128,30 @@ export const EXTRA_ENDPOINTS = {
 		undefined,
 		PrefixStabilityResponse
 	>,
+
+	// ─── ML5-D Improve Cortex (dashboard Vector Cortex tab) ───────────
+
+	/** POST /api/cortex/improve — launch a local ML5-A training job. */
+	improveCortex: {
+		method: "POST",
+		path: "/api/cortex/improve",
+		description:
+			"Launch a local ML5-A training job that re-qualifies the five heads against the latest local corpus and returns an opaque jobId. Requires confirm:true; flag-off returns 404. Local-only — never fetches anything.",
+	} as const satisfies EndpointDef<
+		"POST",
+		CortexImproveStartRequest,
+		CortexImproveStart
+	>,
+
+	/** GET /api/cortex/improve/status/:jobId — poll an improve job. */
+	improveCortexStatus: {
+		method: "GET",
+		path: "/api/cortex/improve/status/:jobId",
+		description:
+			"Poll an in-process Cortex improve job to terminal qualified / demoted_to_B. Unknown jobId or flag-off returns 404. Read-only, in-memory job state.",
+	} as const satisfies EndpointDef<
+		"GET",
+		undefined,
+		CortexImproveStatus
+	>,
 } as const;

package/extensions/dashboard-server/api-contracts/index.ts

@@ -323,3 +323,15 @@ export type {
 	ModelThresholdDeleteResponse,
 	ModelThresholdsError,
 } from "./model-thresholds.js";
+
+// ML5-D — dashboard "Improve Cortex" job API
+export type {
+	QualificationV1,
+	CortexImproveStart,
+	CortexImproveStatus,
+	CortexImproveProgress,
+	CortexImproveQualified,
+	CortexImproveDemoted,
+	CortexImproveDisabled,
+	CortexImproveStartRequest,
+} from "./cortex-improve.js";

package/extensions/dashboard-server/route-dispatch.ts

@@ -60,6 +60,8 @@ import {
 	handleSetupCortexStatus,
 	handleSetupCortexAction,
 	handleSetupCortexActionLog,
+	handleImproveCortex,
+	handleImproveCortexStatus,
 } from "./routes.js";
 // VC6C repair lives in its own module (routes-vector-cortex-repair.ts) so the
 // heal route file stays well under the 400-line extension soft limit.
@@ -154,5 +156,7 @@ export function dispatchRoutes(
 	if (handleSetupCortexStatus(req, res, ctx)) return true;
 	if (handleSetupCortexAction(req, res, ctx)) return true;
 	if (handleSetupCortexActionLog(req, res, ctx)) return true;
+	if (handleImproveCortex(req, res, ctx)) return true;
+	if (handleImproveCortexStatus(req, res, ctx)) return true;
 	return false;
 }

package/extensions/dashboard-server/routes-cortex-improve.ts

@@ -0,0 +1,256 @@
+/**
+ * dashboard-server/routes-cortex-improve.ts — ML5-D "Improve Cortex" job routes.
+ *
+ *   POST /api/cortex/improve          — confirmation-gated local ML5-A training
+ *   GET  /api/cortex/improve/status/:jobId — poll an in-process job to terminal
+ *
+ * The Improve action launches the committed ML5-A training pipeline
+ * (training/vector-cortex/train.py) as a background child_process against the
+ * latest local corpus, then re-qualifies the five heads. Job state is kept
+ * in-process in a Map<jobId, JobState> on this module; nothing is persisted
+ * across restarts (the status endpoint is read-only, in-memory).
+ *
+ * LOCAL ONLY (PREVENT-PI-004): the job spawns a local python process and reads
+ * local files — never a fetch. The `onnxruntime-node` native path is attempted
+ * only when MEGACOMPACT_ENCODER_NATIVE=1 (default OFF); otherwise the harness
+ * uses the WASM/trigram fallback. The status payload surfaces mode/verdict/
+ * digest/reason/progress only — never message or corpus content (EVAL-REDACT-002).
+ *
+ * Guardrails: PREVENT-011 (no `any`), PREVENT-001 (guarded JSON.parse via
+ * readJsonBody), flag-off byte-identical (no card + endpoints 404).
+ */
+
+import type { IncomingMessage, ServerResponse } from "node:http";
+import { spawn } from "node:child_process";
+import { createHash, randomBytes } from "node:crypto";
+import { readFileSync, existsSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import type { RouteContext } from "./routes-core.js";
+import { sendJson, readJsonBody } from "./routes-vector-cortex-shared.js";
+import { ML5D_ENABLED } from "../../src/config.js";
+import { qualifyDecision } from "../../src/vector-cortex/improve.js";
+import type {
+  CortexImproveStart,
+  CortexImproveStatus,
+  QualificationV1,
+} from "./api-contracts/cortex-improve.js";
+
+/** Resolve the committed training entry by walking up to the repo root. */
+function trainingScript(): string | null {
+  let dir = dirname(fileURLToPath(import.meta.url));
+  const rel = join("training", "vector-cortex", "train.py");
+  for (let i = 0; i < 8; i++) {
+    // guardrails-allow PREVENT-PI-004: local script read (loopback)
+    const candidate = join(dir, rel);
+    if (existsSync(candidate)) return candidate;
+    const next = dirname(dir);
+    if (next === dir) break;
+    dir = next;
+  }
+  return null;
+}
+
+/** An in-process improve job (restart-scoped, never persisted). */
+interface JobState {
+  status: "improving" | "qualified" | "demoted_to_B";
+  progress: number;
+  verdict?: QualificationV1;
+  assetDigest?: string;
+  reason?: string;
+  updatedAt: string;
+}
+
+/** In-process job registry; nothing survives a server restart. */
+const JOBS = new Map<string, JobState>();
+
+/** Opaque job token: sha256(ts+random) hex-sliced. */
+function newJobId(): string {
+  return createHash("sha256")
+    .update(`${Date.now()}:${randomBytes(16).toString("hex")}`)
+    .digest("hex")
+    .slice(0, 24);
+}
+
+/**
+ * Spawn the ML5-A training pipeline in the background and drive the job state
+ * to a terminal qualified / demoted_to_B verdict. Honest: an empty corpus (the
+ * host state) makes train.py no-op and the job ends demoted_to_B.
+ */
+function startJob(jobId: string): void {
+  const script = trainingScript();
+  const boot = Date.now();
+  JOBS.set(jobId, { status: "improving", progress: 0, updatedAt: new Date().toISOString() });
+
+  if (script === null) {
+    settle(jobId, { status: "demoted_to_B", reason: "ENC_TRAIN_PIPELINE_ABSENT", progress: 1 });
+    return;
+  }
+
+  const env = { ...process.env };
+  const proc = spawn("python3", [script], {
+    env,
+    cwd: join(dirname(script), "..", ".."),
+    stdio: ["ignore", "pipe", "pipe"],
+  });
+
+  let output = "";
+  const step = () => {
+    const pct = Math.min(0.9, 0.1 + ((Date.now() - boot) / 60000) * 0.6);
+    const cur = JOBS.get(jobId);
+    if (cur && cur.status === "improving" && pct > cur.progress) {
+      JOBS.set(jobId, { ...cur, progress: pct, updatedAt: new Date().toISOString() });
+    }
+  };
+  const timer = setInterval(step, 2000);
+  const stop = () => clearInterval(timer);
+
+  proc.stdout?.on("data", (d: Buffer) => {
+    output += d.toString();
+  });
+  proc.stderr?.on("data", (d: Buffer) => {
+    output += d.toString();
+  });
+  proc.on("error", (err) => {
+    stop();
+    settle(jobId, {
+      status: "demoted_to_B",
+      reason: `ENC_TRAIN_SPAWN_FAILED:${err.message}`,
+      progress: 1,
+    });
+  });
+  proc.on("close", (code) => {
+    stop();
+    // Read the produced trained-heads artifact digest. The report line includes
+    // `trainedHeadsPath`; verify the file exists after a successful run.
+    const match = /trainedHeadsPath":\s*"([^"]+)"/.exec(output);
+    const assetPath = match?.[1];
+    let digest: string | null = null;
+    if (assetPath) {
+      // guardrails-allow PREVENT-PI-004: local artifact read (loopback)
+      try {
+        digest = createHash("sha256")
+          .update(readFileSync(assetPath))
+          .digest("hex")
+          .slice(0, 12);
+      } catch {
+        digest = null;
+      }
+    }
+    const decision = qualifyDecision(code ?? -1, digest);
+    if (decision === "qualified") {
+      settle(jobId, {
+        status: "qualified",
+        progress: 1,
+        assetDigest: digest ?? undefined,
+        verdict: { mode: "A", assetDigestPrefix: digest ?? null, verdict: "qualified" },
+      });
+    } else {
+      settle(jobId, {
+        status: "demoted_to_B",
+        reason: assetPath
+          ? "trained asset did not verify — demoted to mode B"
+          : "empty corpus (no groups) — no qualified asset emitted",
+        progress: 1,
+      });
+    }
+  });
+}
+
+/** Write a terminal job state (idempotent — only advances from improving). */
+function settle(
+  jobId: string,
+  terminal: { status: "qualified" | "demoted_to_B"; progress: number; verdict?: QualificationV1; assetDigest?: string; reason?: string },
+): void {
+  const cur = JOBS.get(jobId);
+  if (cur && cur.status !== "improving") return;
+  JOBS.set(jobId, { ...terminal, updatedAt: new Date().toISOString() });
+}
+
+/** Flag-off response, byte-identical regardless of request (ML5-D absent). */
+function sendDisabled(res: ServerResponse): void {
+  sendJson(res, 404, { error: "disabled" });
+}
+
+/**
+ * POST /api/cortex/improve (ML5-D). Returns true when it claims the request.
+ * Requires `confirm:true` server-side (mirrors the client window.confirm).
+ */
+export function handleImproveCortex(
+  req: IncomingMessage,
+  res: ServerResponse,
+  _ctx: RouteContext,
+): boolean {
+  const url = req.url ?? "";
+  if (url !== "/api/cortex/improve") return false;
+  if (req.method !== "POST") {
+    sendJson(res, 405, { error: "method_not_allowed" });
+    return true;
+  }
+  if (!ML5D_ENABLED()) {
+    sendDisabled(res);
+    return true;
+  }
+  readJsonBody(req, (parsed) => {
+    if (!parsed.ok) {
+      sendJson(res, 400, { error: "invalid_body" });
+      return;
+    }
+    if (parsed.value.confirm !== true) {
+      sendJson(res, 400, { error: "confirmation_required" });
+      return;
+    }
+    const jobId = newJobId();
+    startJob(jobId);
+    const body: CortexImproveStart = { status: "improving", jobId };
+    sendJson(res, 200, body);
+  });
+  return true;
+}
+
+/**
+ * GET /api/cortex/improve/status/:jobId (ML5-D). Returns true when it claims the
+ * request. Flag-off or unknown jobId → 404. Read-only in-memory.
+ */
+export function handleImproveCortexStatus(
+  req: IncomingMessage,
+  res: ServerResponse,
+  _ctx: RouteContext,
+): boolean {
+  const url = req.url ?? "";
+  const match = /^\/api\/cortex\/improve\/status\/([A-Za-z0-9]+)$/.exec(url);
+  if (!match) return false;
+  if (req.method !== "GET") {
+    sendJson(res, 405, { error: "method_not_allowed" });
+    return true;
+  }
+  if (!ML5D_ENABLED()) {
+    sendDisabled(res);
+    return true;
+  }
+  const job = JOBS.get(match[1]);
+  if (!job) {
+    sendJson(res, 404, { error: "job_not_found" });
+    return true;
+  }
+  // Narrow job.status into the discriminated CortexImproveStatus variant. The
+  // terminal shapes require their payload fields, so construct per-state.
+  const body: CortexImproveStatus =
+    job.status === "improving"
+      ? { status: "improving", progress: job.progress }
+      : job.status === "qualified"
+        ? {
+            status: "qualified",
+            progress: job.progress,
+            verdict:
+              job.verdict ?? { mode: "A", assetDigestPrefix: null, verdict: "qualified" },
+            assetDigest: job.assetDigest ?? "",
+          }
+        : {
+            status: "demoted_to_B",
+            progress: job.progress,
+            reason: job.reason ?? "UNKNOWN_TERMINAL",
+          };
+  sendJson(res, 200, body);
+  return true;
+}

package/extensions/dashboard-server/routes-rag-settings-vector-cortex.ts

@@ -228,5 +228,17 @@ export const VECTOR_CORTEX_SETTINGS: SettingGroup = {
 			"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,
 		),
+		boolDirect(
+			"MEGACOMPACT_ML5_C",
+			"ML5-C Runtime Decision + Packaging",
+			"ML5-C runtime backend selection (WASM vs native): selects the ONNX runtime backend based on the ML5-B bench record and platform support. ON (default) = the runtime-selection dispatch runs and emits vector_cortex_runtime_selected. OFF = no selection runs — encoder serves mode B trigram, byte-identical to ML5-B.",
+			true,
+		),
+		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,
+		),
 	],
 };

package/extensions/dashboard-server/routes.ts

@@ -62,3 +62,7 @@ export {
 	handleSetupCortexAction,
 	handleSetupCortexActionLog,
 } from "./routes-setup-cortex-actions.js";
+export {
+	handleImproveCortex,
+	handleImproveCortexStatus,
+} from "./routes-cortex-improve.js";

package/extensions/mega-runtime/dashboard-snapshot.ts

@@ -159,8 +159,8 @@ export function buildDashboardSnapshot(ctx: SnapshotBuildContext): DashboardSnap
 			// per-session in rt and there's no cumulative counter yet.
 			total: ctx.repo.dedupCollapsed,
 			sessionTokensSaved: ctx.rt.cacheHitTokens,
-			// Cumulative tokens saved across all sessions in this repo —
-			// was a placeholder (dedupCollapsed * 100).
+			// Cumulative tokens saved across all sessions in this repo = the
+			// real repo counter (audit Table 1 stub 8 closed — no rolled-up math).
 			totalTokensSaved: ctx.repo.tokensSaved,
 		},
 		compacts: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-mega-compact",
-  "version": "0.20.38",
+  "version": "0.20.40",
   "description": "Layered, local, vector-backed context compressor for pi — supersede/collapse/cluster compaction with deduped inline recall.",
   "type": "module",
   "license": "BSD-3-Clause",

package/src/config/vector-cortex-ml5c.ts

@@ -0,0 +1,30 @@
+/**
+ * config/vector-cortex-ml5c.ts — ML5-C runtime decision + packaging flag.
+ *
+ * Sibling extract mirroring vector-cortex-ml5a.ts / vector-cortex-ml5b.ts, so
+ * vector-cortex.ts stays under its 300-line soft limit (soft-as-hard gate).
+ * This is the ONNX Runtime backend selection + packaging sprint flag.
+ * vector-cortex.ts re-exports the ENUM below and root src/config.ts re-exports
+ * it, so no consumer import path changes.
+ *
+ * ML5-C selects the ONNX runtime backend (WASM vs native) based on the ML5-B
+ * bench record and platform support. The flag gates the runtime-selection
+ * dispatch only; when OFF the encoder serves mode B trigram exactly as before
+ * (byte-identical to the ML5-B survivor — no `vector_cortex_runtime_selected`
+ * event is emitted, no session-selection dispatch runs).
+ *
+ * Pi-agnostic, dependency-free (PREVENT-PI-004 / PREVENT-011).
+ */
+
+import { sprintFlag } from "./vector-cortex-flag.js";
+
+/**
+ * ML5-C — runtime decision + packaging (WASM vs native). Default ON.
+ * `MEGACOMPACT_ML5_C=0` disables and is byte-identical to the ML5-B survivor:
+ * no runtime selection runs — the encoder continues to serve mode B trigram,
+ * exactly as before, with no `vector_cortex_runtime_selected` event emitted.
+ * The flag gates the runtime-selection dispatch only; it does not gate the
+ * underlying WASM/native backends (which are exercised by ML5-B's bench
+ * harness and ML5-A's trained asset independently).
+ */
+export const ML5C_ENABLED = (): boolean => sprintFlag("MEGACOMPACT_ML5_C");

package/src/config/vector-cortex-ml5d.ts

@@ -0,0 +1,30 @@
+/**
+ * config/vector-cortex-ml5d.ts — ML5-D dashboard "Improve Cortex" flag.
+ *
+ * Sibling extract mirroring vector-cortex-ml5a.ts / vector-cortex-ml5b.ts /
+ * vector-cortex-ml5c.ts, so vector-cortex.ts stays under its 300-line soft
+ * limit (soft-as-hard gate). This is the dashboard "Improve Cortex" surface +
+ * promote workflow sprint flag.
+ * vector-cortex.ts re-exports the ENUM below and root src/config.ts re-exports
+ * it, so no consumer import path changes.
+ *
+ * ML5-D adds the dashboard ModelImprovementCard + the POST /api/cortex/improve
+ * and GET /api/cortex/improve/status/:jobId endpoints. The flag gates that
+ * surface only; when OFF the endpoints return 404/disabled and VectorCortexTab
+ * renders exactly as before (byte-identical to the ML5-C-era tab — no
+ * ModelImprovementCard, no improve job is ever spawned).
+ *
+ * Pi-agnostic, dependency-free (PREVENT-PI-004 / PREVENT-011).
+ */
+
+import { sprintFlag } from "./vector-cortex-flag.js";
+
+/**
+ * ML5-D — dashboard "Improve Cortex" surface + promote workflow. Default ON.
+ * `MEGACOMPACT_ML5_D=0` disables and is byte-identical to the ML5-C survivor:
+ * both `/api/cortex/improve*` endpoints return 404 and VectorCortexTab omits the
+ * ModelImprovementCard. The flag gates the dashboard surface only; it does not
+ * gate the underlying ML5-A training pipeline or the encoder's mode-A/B/C
+ * selection (those are governed by ML5-A and the encoder independently).
+ */
+export const ML5D_ENABLED = (): boolean => sprintFlag("MEGACOMPACT_ML5_D");

package/src/config/vector-cortex.ts

@@ -269,11 +269,9 @@ export const VC8A_ENABLED = (): boolean => sprintFlag("MEGACOMPACT_VC8A");
  */
 export const VC8B_ENABLED = (): boolean => sprintFlag("MEGACOMPACT_VC8B");
 
-// VC8C (canary selection + Rust parity) extracted to vector-cortex-vc8c.ts;
-// re-exported so existing `./config/vector-cortex.js` imports keep resolving.
+// VC8C (canary selection + Rust parity) extracted to vector-cortex-vc8c.ts; re-exported so existing imports keep resolving.
 export { VC8C_ENABLED } from "./vector-cortex-vc8c.js";
-
-// VC9A/VC9B/VC9C/VC9D/PCC/ML5A split to sibling files to stay under the 300-line soft limit.
+// Sibling extracts 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";
@@ -281,6 +279,8 @@ export { VC9D_ENABLED } from "./vector-cortex-vc9d.js";
 export { PCC_ENABLED } from "./vector-cortex-pcc.js";
 export { ML5A_ENABLED } from "./vector-cortex-ml5a.js";
 export { ML5B_ENABLED } from "./vector-cortex-ml5b.js";
+export { ML5C_ENABLED } from "./vector-cortex-ml5c.js";
+export { ML5D_ENABLED } from "./vector-cortex-ml5d.js";
 
 // Breaker constants (TRIAD_RESILIENCE.md §breaker) extracted to vector-cortex-breakers.ts.
 export {

package/src/config.ts

@@ -185,6 +185,8 @@ export {
   PCC_ENABLED,
   ML5A_ENABLED,
   ML5B_ENABLED,
+  ML5C_ENABLED,
+  ML5D_ENABLED,
   BREAKER_WINDOW_MS,
   BREAKER_MIN_ATTEMPTS,
   BREAKER_PERF_FAILURES,

package/src/store/backfill.ts

@@ -28,7 +28,6 @@ import { defaultEmbedder } from "../embedder.js";
 import { getStateDir } from "../store.js";
 
 const BATCH = 1000;
-const THROTTLE_MS = 0; // synchronous backfill; no cross-process yield needed
 
 /** Backfill phases, in order (Sprint 14 full-pipeline wiring). */
 export type BackfillPhase = "L0" | "L1" | "L2" | "RAPTOR";
@@ -132,11 +131,6 @@ export function backfillContentHashes(stateDir: string = getStateDir()): Backfil
     ).run(lastSid, lastId, updated, duplicatesResolved);
   }
 
-  if (THROTTLE_MS > 0) {
-    // No-op in this synchronous build; placeholder for future streaming backfill.
-    // guardrails-allow PREVENT-STUB-001: ML5-C
-  }
-
   return { processed, updated, duplicatesResolved };
 }
 
@@ -220,7 +214,6 @@ export function backfillPhase(
     });
     savePhaseCursor(db, phase, cursor ?? null, processed);
     batches++;
-    if (THROTTLE_MS > 0) { const end = Date.now() + THROTTLE_MS; while (Date.now() < end) { /* throttle */ } }
     if (opts.interruptAfterBatches && batches >= opts.interruptAfterBatches) {
       interrupted = true;
       break;