pi-mega-compact 0.20.41 → 0.20.43

package/src/vector-cortex/dedup-attr/rollup.ts

@@ -0,0 +1,136 @@
+/**
+ * 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`).
+ */
+
+import type { DedupAuditEvent } from "../../vectorStore/dedup-audit.js";
+
+/** Per-tier dedup/passed counts (same shape as the api-contract DedupTierCounts). */
+export interface DedupTierRollupCounts {
+  /** Decisions this tier collapsed onto a matched checkpoint. */
+  readonly deduped: number;
+  /** Decisions this tier scored a candidate but did not collapse. */
+  readonly passed: number;
+}
+
+/** The status the rollup can produce from its pure signal. */
+export type RollupStatus = "live" | "awaiting_data";
+
+/** Purely-computed tier attribution for one window (mirrors DedupTierRollupV1). */
+export interface DedupTierRollup {
+  readonly schema: "dedup-tier-rollup-v1";
+  readonly windowStart: string;
+  readonly windowEnd: string;
+  readonly totalDecisions: number;
+  readonly byTier: {
+    readonly l0: DedupTierRollupCounts;
+    readonly l1: DedupTierRollupCounts;
+    readonly l2: DedupTierRollupCounts;
+    readonly new: number;
+  };
+  readonly l0Share: number;
+  readonly l1Share: number;
+  readonly l2Share: number;
+  readonly status: RollupStatus;
+}
+
+interface Accumulator {
+  l0: { deduped: number; passed: number };
+  l1: { deduped: number; passed: number };
+  l2: { deduped: number; passed: number };
+  storedNew: number;
+}
+
+/**
+ * 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: readonly DedupAuditEvent[],
+  windowMs: number,
+  now: Date,
+): DedupTierRollup {
+  const winMs = windowMs > 0 ? windowMs : 24 * 60 * 60 * 1000;
+  const windowStart = now.getTime() - winMs;
+  const windowEnd = now.getTime();
+
+  const acc: Accumulator = {
+    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: number): number => (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/src/vector-cortex/encoder/asset.ts

@@ -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
@@ -88,7 +89,7 @@ function isManifest(m: unknown): m is ModelManifestV1 {
  *
  *   - 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/src/vector-cortex/encoder/bench-export.ts

@@ -17,7 +17,7 @@ export interface BenchGatesV1 {
   readonly latency: boolean;
   /** steady-state marginal RSS over the process baseline <= 150 MiB. */
   readonly rss: boolean;
-  /** the loaded model's declared opset_import equals 17. */
+  /** the loaded model's declared opset_import equals ENCODER_OPSET (21, ENC-0a re-baseline). */
   readonly opset: boolean;
   /** SHA-256 of the embedding output identical across 3 runs (maxAbsDelta=0). */
   readonly determinism: boolean;
@@ -53,7 +53,7 @@ export interface BenchResultV1 {
   readonly rssBaselineMib: number | null;
   /** rssMib - rssBaselineMib: the encoder's marginal footprint. */
   readonly rssMarginalMib: number | null;
-  /** declared opset_import (17); null when no asset manifest is readable. */
+  /** declared opset_import (21, ENC-0a re-baseline); null when no asset manifest is readable. */
   readonly opset: number | null;
   /** true when the output SHA-256 is identical across 3 runs. */
   readonly deterministic: boolean;

package/src/vector-cortex/encoder/decision.ts

@@ -0,0 +1,125 @@
+/**
+ * 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).
+ */
+
+import type { EncoderPlatform } from "./types.js";
+
+/** Backend demotion disposition for a platform row. */
+export type BackendDemotion = "none" | "wasm" | "modeB";
+
+/** One platform row: the concrete runtime + install size + demotion disposition. */
+export interface EncoderPlatformRow {
+  readonly runtime: string;
+  readonly installMiB: number;
+  readonly demotion: BackendDemotion;
+}
+
+/**
+ * EncoderBackendDecisionV1 — the locked learned-encoder runtime-backend decision.
+ *
+ * `opset` is pinned to the literal 21 (the ENC-0a re-baseline); `artifacts`
+ * carries only aggregate digests/sizes — never message content (EVAL-REDACT-002);
+ * `blockedBy` names the open hard-gate items that DEFER part of the decision
+ * (e.g. HG-4 — the darwin-x64 demotion is ENC-0e's job).
+ */
+export interface EncoderBackendDecisionV1 {
+  readonly schema: "encoder-backend-decision-v1";
+  readonly backend: "wasm" | "native";
+  readonly budgetOk: boolean;
+  readonly opset: 21;
+  readonly platformMatrix: Readonly<Record<EncoderPlatform, EncoderPlatformRow>>;
+  readonly license: { readonly spdx: "MIT"; readonly redistribution: true };
+  readonly artifacts: {
+    readonly model: { readonly path: string; readonly bytes: number; readonly sha256: string };
+    readonly tokenizer: { readonly path: string; readonly bytes: number; readonly sha256: string };
+  };
+  readonly p95Ms: number | null;
+  readonly blockedBy: readonly string[];
+}
+
+/**
+ * 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: {
+  readonly backend: "wasm" | "native";
+  readonly budgetOk: boolean;
+  readonly p95Ms: number | null;
+  readonly platformMatrix: Readonly<Record<EncoderPlatform, EncoderPlatformRow>>;
+  readonly modelPath: string;
+  readonly modelBytes: number;
+  readonly modelSha256: string;
+  readonly tokenizerPath: string;
+  readonly tokenizerBytes: number;
+  readonly tokenizerSha256: string;
+  readonly blockedBy: readonly string[];
+}): EncoderBackendDecisionV1 {
+  const { platformMatrix } = input;
+  const platforms: readonly EncoderPlatform[] = [
+    "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/src/vector-cortex/encoder/runtime-native.ts

@@ -45,7 +45,7 @@ export interface OrtNativeModule {
 
 /** The backend's inference session — a thin wrapper over the real native session. */
 export interface NativeSession {
-  /** The declared ONNX opset in the loaded manifest (normative 17). */
+  /** The declared ONNX opset in the loaded manifest (normative 21). */
   readonly opset: number;
   /** The semantic embedding width (normative 384). */
   readonly semanticWidth: number;

package/src/vector-cortex/encoder/runtime-wasm.ts

@@ -45,7 +45,7 @@ export interface OrtWasmModule {
 
 /** The backend's inference session — a thin wrapper over the real WASM session. */
 export interface WasmSession {
-  /** The declared ONNX opset in the loaded manifest (normative 17). */
+  /** The declared ONNX opset in the loaded manifest (normative 21). */
   readonly opset: number;
   /** The semantic embedding width (normative 384). */
   readonly semanticWidth: number;

package/src/vector-cortex/encoder/types-vc2c.ts

@@ -0,0 +1,124 @@
+/**
+ * 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).
+ */
+
+import type { EncoderHeadName } from "./types.js";
+
+/**
+ * Held-out metrics recorded as qualification evidence for a candidate asset
+ * (EVALUATION.md §metrics). Semantic metrics are Spearman rho + recall@10;
+ * dependency directed precision/recall; contradiction precision/recall/ECE;
+ * cache precision/recall; payload-routing macro-F1 + exact/anchor recall;
+ * reconstruction is the binary causality/exact/closure/task-success set. The
+ * qualification decision (task 3 `select.ts`) consumes ONLY the per-head rows
+ * this record carries; the true EVALUATION thresholds are the normative
+ * constants in MODEL_ASSET (mirrored in `EVALUATION_THRESHOLDS` below).
+ */
+export interface EncoderHeldOutMetrics {
+  /** Semantic: Spearman rho (>= .75) and recall@10 (>= .90). */
+  readonly semantic: { readonly spearman: number; readonly recallAt10: number };
+  /** Dependency: directed precision (>= .97) and recall (>= .95). */
+  readonly dependency: { readonly precision: number; readonly recall: number };
+  /** Contradiction: precision (>= .98), recall (>= .90), ECE (<= .05). */
+  readonly contradiction: { readonly precision: number; readonly recall: number; readonly ece: number };
+  /** Cache: precision (>= .999, zero false-stable) and recall (>= .90). */
+  readonly cacheStability: { readonly precision: number; readonly recall: number };
+  /** Payload routing: macro-F1 (>= .97) and exact/anchor recall (1.0). */
+  readonly payloadRouting: { readonly macroF1: number; readonly exactAnchorRecall: number };
+  /** Reconstruction: binary gates — zero causal/tool/anchor/exact violations. */
+  readonly reconstruction: {
+    readonly votesOk: boolean;
+    readonly dependencyClosureRecall: number;
+    readonly taskSuccessNonInferior: boolean;
+  };
+}
+
+/** 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 },
+} as const;
+
+/**
+ * CalibrationV1 — fitted temperature/isotonic calibration, frozen on the
+ * CALIBRATION split only (VC2C task 2). Held-out test labels NEVER enter the
+ * fit inputs (calibration-fit prohibition). The split digest proves the exact
+ * calibration assignment (grouped by repository+session); the frozen temp/threshold
+ * values are what `select.ts` stamps into a `QualifiedEncoderV1`.
+ */
+export interface CalibrationV1 {
+  readonly schema: "calibration-v1";
+  readonly headOrder: readonly EncoderHeadName[];
+  /** SHA-256 of the calibration split assignment (grouped repository+session). */
+  readonly calibrationSplitDigest: string;
+  /** Fitted on the calibration split only; held-out labels excluded from fit. */
+  readonly fittedOnCalibrationOnly: true;
+  /** Frozen per-head temperature (isotonic calibration reference points). */
+  readonly temperatures: Readonly<Record<EncoderHeadName, number>>;
+  /** Frozen per-head decision thresholds for the qualified decision. */
+  readonly thresholds: Readonly<Record<EncoderHeadName, number>>;
+  /** Seed of the deterministic calibration fit. */
+  readonly seed: number;
+}
+
+/**
+ * QualifiedEncoderV1 — the VC2C-owned eligibility record (mode A). Produced by
+ * `select.ts` ONLY when EVERY MODEL_ASSET + per-head EVALUATION threshold
+ * passes (atomic — one failed field demotes all of A). Pins the asset digest,
+ * the calibration digest, the held-out metrics that justified eligibility, and
+ * the calibration reference, so VC3A receives a fully self-describing candidate.
+ */
+export interface QualifiedEncoderV1 {
+  readonly schema: "qualified-encoder-v1";
+  readonly modelVersion: string;
+  readonly mode: "A";
+  /** SHA-256 of the asset manifest bytes (ModelManifestV1) that qualified.
+   *  Identical semantics to the dashboard health card's `encoderAssetDigest`
+   *  (both hash the committed manifest.json ModelManifestV1 bytes), so
+   *  downstream consumers (VC3A) pin the same digest across the seam. */
+  readonly assetDigest: string;
+  /** SHA-256 of the calibration split assignment (grouped repository+session)
+   *  that the CalibrationV1 was fitted on — the calibration's core identity. */
+  readonly calibrationDigest: string;
+  /** SHA-256 of the qualified asset's verified ONNX bytes (digest-pinned). */
+  readonly onnxDigest: string;
+  /** Held-out metrics recorded as the eligibility evidence. */
+  readonly heldOut: EncoderHeldOutMetrics;
+  /** Calibration reference this qualification is grounded in. */
+  readonly calibration: CalibrationV1;
+}
+
+/** 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",
+} as const;
+
+/** The 4 registered VC2C conformance IDs (task 1: "register ENC-017..020"). */
+export const ENC2C_IDS: readonly string[] = [
+  "ENC-017",
+  "ENC-018",
+  "ENC-019",
+  "ENC-020",
+];

package/src/vector-cortex/encoder/types.ts

@@ -34,8 +34,13 @@ export const ENCODER_SUPPORTED_PLATFORMS: readonly EncoderPlatform[] = [
   "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). */
@@ -124,7 +129,7 @@ export type EncoderMode = "A" | "B" | "C";
 
 /** 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",
@@ -275,117 +280,15 @@ export const ENC2B_IDS: readonly string[] = [
 ];
 
 // ---------------------------------------------------------------------------
-// VC2C — encoder qualification + calibration (QualifiedEncoderV1 / CalibrationV1).
+// VC2C — encoder qualification + calibration: extracted to types-vc2c.ts
+// (delegate-shell split, soft-limit compliance). Re-exported here.
 // ---------------------------------------------------------------------------
 
-/**
- * Held-out metrics recorded as qualification evidence for a candidate asset
- * (EVALUATION.md §metrics). Semantic metrics are Spearman rho + recall@10;
- * dependency directed precision/recall; contradiction precision/recall/ECE;
- * cache precision/recall; payload-routing macro-F1 + exact/anchor recall;
- * reconstruction is the binary causality/exact/closure/task-success set. The
- * qualification decision (task 3 `select.ts`) consumes ONLY the per-head rows
- * this record carries; the true EVALUATION thresholds are the normative
- * constants in MODEL_ASSET (mirrored in `EVALUATION_THRESHOLDS` below).
- */
-export interface EncoderHeldOutMetrics {
-  /** Semantic: Spearman rho (>= .75) and recall@10 (>= .90). */
-  readonly semantic: { readonly spearman: number; readonly recallAt10: number };
-  /** Dependency: directed precision (>= .97) and recall (>= .95). */
-  readonly dependency: { readonly precision: number; readonly recall: number };
-  /** Contradiction: precision (>= .98), recall (>= .90), ECE (<= .05). */
-  readonly contradiction: { readonly precision: number; readonly recall: number; readonly ece: number };
-  /** Cache: precision (>= .999, zero false-stable) and recall (>= .90). */
-  readonly cacheStability: { readonly precision: number; readonly recall: number };
-  /** Payload routing: macro-F1 (>= .97) and exact/anchor recall (1.0). */
-  readonly payloadRouting: { readonly macroF1: number; readonly exactAnchorRecall: number };
-  /** Reconstruction: binary gates — zero causal/tool/anchor/exact violations. */
-  readonly reconstruction: {
-    readonly votesOk: boolean;
-    readonly dependencyClosureRecall: number;
-    readonly taskSuccessNonInferior: boolean;
-  };
-}
-
-/** 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 },
-} as const;
-
-/**
- * CalibrationV1 — fitted temperature/isotonic calibration, frozen on the
- * CALIBRATION split only (VC2C task 2). Held-out test labels NEVER enter the
- * fit inputs (calibration-fit prohibition). The split digest proves the exact
- * calibration assignment (grouped by repository+session); the frozen temp/threshold
- * values are what `select.ts` stamps into a `QualifiedEncoderV1`.
- */
-export interface CalibrationV1 {
-  readonly schema: "calibration-v1";
-  readonly headOrder: readonly EncoderHeadName[];
-  /** SHA-256 of the calibration split assignment (grouped repository+session). */
-  readonly calibrationSplitDigest: string;
-  /** Fitted on the calibration split only; held-out labels excluded from fit. */
-  readonly fittedOnCalibrationOnly: true;
-  /** Frozen per-head temperature (isotonic calibration reference points). */
-  readonly temperatures: Readonly<Record<EncoderHeadName, number>>;
-  /** Frozen per-head decision thresholds for the qualified decision. */
-  readonly thresholds: Readonly<Record<EncoderHeadName, number>>;
-  /** Seed of the deterministic calibration fit. */
-  readonly seed: number;
-}
-
-/**
- * QualifiedEncoderV1 — the VC2C-owned eligibility record (mode A). Produced by
- * `select.ts` ONLY when EVERY MODEL_ASSET + per-head EVALUATION threshold
- * passes (atomic — one failed field demotes all of A). Pins the asset digest,
- * the calibration digest, the held-out metrics that justified eligibility, and
- * the calibration reference, so VC3A receives a fully self-describing candidate.
- */
-export interface QualifiedEncoderV1 {
-  readonly schema: "qualified-encoder-v1";
-  readonly modelVersion: string;
-  readonly mode: "A";
-  /** SHA-256 of the asset manifest bytes (ModelManifestV1) that qualified.
-   *  Identical semantics to the dashboard health card's `encoderAssetDigest`
-   *  (both hash the committed manifest.json ModelManifestV1 bytes), so
-   *  downstream consumers (VC3A) pin the same digest across the seam. */
-  readonly assetDigest: string;
-  /** SHA-256 of the calibration split assignment (grouped repository+session)
-   *  that the CalibrationV1 was fitted on — the calibration's core identity. */
-  readonly calibrationDigest: string;
-  /** SHA-256 of the qualified asset's verified ONNX bytes (digest-pinned). */
-  readonly onnxDigest: string;
-  /** Held-out metrics recorded as the eligibility evidence. */
-  readonly heldOut: EncoderHeldOutMetrics;
-  /** Calibration reference this qualification is grounded in. */
-  readonly calibration: CalibrationV1;
-}
-
-/** 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",
-} as const;
-
-/** The 4 registered VC2C conformance IDs (task 1: "register ENC-017..020"). */
-export const ENC2C_IDS: readonly string[] = [
-  "ENC-017",
-  "ENC-018",
-  "ENC-019",
-  "ENC-020",
-];
+export {
+  EVALUATION_THRESHOLDS,
+  ENC_QUALIFICATION_FAIL,
+  ENC2C_IDS,
+  type EncoderHeldOutMetrics,
+  type CalibrationV1,
+  type QualifiedEncoderV1,
+} from "./types-vc2c.js";