pi-mega-compact 0.20.47 → 0.20.49

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

@@ -25,12 +25,18 @@ import { readFileSync, statSync } from "node:fs";
 import { join, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
 import type { RouteContext } from "./routes-core.js";
-import { VC9A_ENABLED, ENC_0E_ENABLED } from "../../src/config.js";
+import { VC9A_ENABLED, ENC_0E_ENABLED, ENC_0F_ENABLED, ENC_0G_ENABLED } from "../../src/config.js";
 import { readEncoderManifest, verifyEncoderAsset, detectPlatform } from "../../src/vector-cortex/encoder/asset.js";
+import type { QualificationV1 } from "../../src/vector-cortex/encoder/qualify.js";
 import { selectRuntimeBackend } from "../../src/vector-cortex/encoder/runtime-select.js";
 import { sendJson } from "./routes-vector-cortex-shared.js";
 import { deriveVcStatus } from "./vc-status.js";
-import { SETUP_CORTEX_BLOCKERS } from "./setup-cortex-blockers.js";
+import { SETUP_CORTEX_BLOCKERS, computeSetupCortexBlockers } from "./setup-cortex-blockers.js";
+import {
+  readQualificationRecord,
+  encoderStateDir,
+  QUALIFICATION_RECORD_UNAVAILABLE,
+} from "./qualification-record.js";
 import type {
   SetupCortexStatusResponse,
   BlockerV1,
@@ -62,6 +68,8 @@ interface SetupCortexFacts {
   assetDigestPrefix: string | null;
   verdict: "qualified" | "demoted" | "unavailable";
   thresholdFailures: string[];
+  /** Number of projection heads the verified manifest declares, or null. */
+  headCount: number | null;
 }
 
 interface SetupCortexFactCache {
@@ -72,7 +80,13 @@ interface SetupCortexFactCache {
 let factCache: SetupCortexFactCache | null = null;
 
 /** Stable cache key: manifest bytes + (size,mtime) of the asset files + platform. */
-function factCacheKey(dir: string, manifestPath: string): string | null {
+function factCacheKey(
+  dir: string,
+  manifestPath: string,
+  stateDir: string,
+  record: QualificationV1 | null,
+  recordGate: boolean,
+): string | null {
   const platform = detectPlatform();
   if (!platform) return null;
   const parts: string[] = [platform];
@@ -86,16 +100,56 @@ function factCacheKey(dir: string, manifestPath: string): string | null {
   } catch {
     return null;
   }
+  // ENC-0g: fold the qualification-record gate + (mtime, content sha) into the
+  // key so a re-run gate invalidates memoized facts (no stale verdict served).
+  try {
+    const s = statSync(join(stateDir, "encoder-qualification.json"));
+    parts.push(`g:${recordGate ? "on" : "off"}`, `q:${s.size}:${s.mtimeMs}`);
+    parts.push(createHash("sha256").update(JSON.stringify(record)).digest("hex"));
+  } catch {
+    parts.push(`g:${recordGate ? "on" : "off"}`, "q:absent");
+  }
   return parts.join("|");
 }
 
-function computeSetupCortexFacts(dir: string): SetupCortexFacts | null {
+function applyQualificationOverride(
+  base: SetupCortexFacts,
+  record: QualificationV1 | null,
+  recordGate: boolean,
+): SetupCortexFacts {
+  // Flag-off (recordGate false): byte-identical verify-derived facts.
+  if (!recordGate) return base;
+  if (record !== null) {
+    // The ENC-0f QualificationV1 failure maps onto the contract "demoted": a
+    // structurally-valid asset whose real-asset gate measured failure is honest
+    // as demoted, NOT qualified. mode stays verify-derived (A).
+    return {
+      ...base,
+      verdict: record.verdict === "qualified" ? "qualified" : "demoted",
+      thresholdFailures: [...record.reasons],
+    };
+  }
+  // No record + gate on: keep the verify verdict but surface the missing-record
+  // sentinel (never a fabricated pass, never a bare silent fallback).
+  return {
+    ...base,
+    thresholdFailures: [...base.thresholdFailures, QUALIFICATION_RECORD_UNAVAILABLE],
+  };
+}
+
+function computeSetupCortexFacts(
+  dir: string,
+  stateDir: string,
+  record: QualificationV1 | null,
+  recordGate: boolean,
+): SetupCortexFacts | null {
   const manifest = readEncoderManifest(dir);
   if (manifest === null) {
-    return { mode: "C", assetDigestPrefix: null, verdict: "unavailable", thresholdFailures: [] };
+    return { mode: "C", assetDigestPrefix: null, verdict: "unavailable", thresholdFailures: [], headCount: null };
   }
+  const headCount = Object.keys(manifest.heads).length;
   const manifestPath = join(dir, "manifest.json");
-  const key = factCacheKey(dir, manifestPath);
+  const key = factCacheKey(dir, manifestPath, stateDir, record, recordGate);
   if (key === null) return null;
   if (factCache !== null && factCache.key === key) return factCache.facts;
   let digest: string;
@@ -103,26 +157,31 @@ function computeSetupCortexFacts(dir: string): SetupCortexFacts | null {
     // guardrails-allow PREVENT-PI-004: local manifest filesystem read (loopback)
     digest = createHash("sha256").update(readFileSync(manifestPath)).digest("hex");
   } catch {
-    const facts: SetupCortexFacts = { mode: "B", assetDigestPrefix: null, verdict: "demoted", thresholdFailures: ["ENC_ASSET_UNREADABLE"] };
+    const base: SetupCortexFacts = { mode: "B", assetDigestPrefix: null, verdict: "demoted", thresholdFailures: ["ENC_ASSET_UNREADABLE"], headCount };
+    const facts = applyQualificationOverride(base, record, recordGate);
     factCache = { key, facts };
     return facts;
   }
   const verify = verifyEncoderAsset(dir, manifest, detectPlatform());
   const prefix = digest.slice(0, 12);
-  const facts: SetupCortexFacts = verify.ok
-    ? { mode: "A", assetDigestPrefix: prefix, verdict: "qualified", thresholdFailures: [] }
-    : { mode: "B", assetDigestPrefix: prefix, verdict: "demoted", thresholdFailures: [verify.code] };
+  const base: SetupCortexFacts = verify.ok
+    ? { mode: "A", assetDigestPrefix: prefix, verdict: "qualified", thresholdFailures: [], headCount }
+    : { mode: "B", assetDigestPrefix: prefix, verdict: "demoted", thresholdFailures: [verify.code], headCount };
+  const facts = applyQualificationOverride(base, record, recordGate);
   factCache = { key, facts };
   return facts;
 }
 
-function setupCortexFacts(): SetupCortexFacts {
+function setupCortexFacts(
+  record: QualificationV1 | null,
+  recordGate: boolean,
+): SetupCortexFacts {
   const dir = encoderAssetDir();
   if (dir === null) {
-    return { mode: "C", assetDigestPrefix: null, verdict: "unavailable", thresholdFailures: [] };
+    return { mode: "C", assetDigestPrefix: null, verdict: "unavailable", thresholdFailures: [], headCount: null };
   }
-  const facts = computeSetupCortexFacts(dir);
-  return facts ?? { mode: "C", assetDigestPrefix: null, verdict: "unavailable", thresholdFailures: [] };
+  const facts = computeSetupCortexFacts(dir, encoderStateDir(), record, recordGate);
+  return facts ?? { mode: "C", assetDigestPrefix: null, verdict: "unavailable", thresholdFailures: [], headCount: null };
 }
 
 /**
@@ -145,8 +204,25 @@ export function handleSetupCortexStatus(
   }
 
   const enabled = VC9A_ENABLED();
-  const facts = enabled ? setupCortexFacts() : null;
-  const blocks: BlockerV1[] = enabled ? [...SETUP_CORTEX_BLOCKERS] : [];
+
+  // ENC-0g: when both gates are ON, read the QualificationV1 record and let its
+  // verdict override the structural verify for the `qualification` field. When
+  // ENC_0G is OFF, nothing below reads the record (byte-identical to ENC-0f-era).
+  const enc0g = enabled && ENC_0G_ENABLED();
+  const recordGate = enc0g && ENC_0F_ENABLED();
+  const record = recordGate ? readQualificationRecord(encoderStateDir()) : null;
+
+  const facts = enabled ? setupCortexFacts(record, recordGate) : null;
+
+  const blocks: BlockerV1[] = enabled
+    ? enc0g
+      ? [...computeSetupCortexBlockers({
+          platform: detectPlatform(),
+          qualification: record,
+          headCount: facts ? facts.headCount : null,
+        })]
+      : [...SETUP_CORTEX_BLOCKERS]
+    : [];
 
   // ENC-0e: surface the darwin-x64 demotion reason additively (reader-only GET,
   // no new route). The platform is read locally; the selection is pure. On a

package/extensions/dashboard-server/setup-cortex-actions.ts

@@ -36,6 +36,11 @@ import {
   verifyEncoderAsset,
   detectPlatform,
 } from "../../src/vector-cortex/encoder/asset.js";
+import { ENC_0G_ENABLED, ENC_0F_ENABLED } from "../../src/config.js";
+import {
+  readQualificationRecord,
+  encoderStateDir,
+} from "./qualification-record.js";
 
 /** Cap applied to every log tail served by the action-log route. */
 export const ACTION_LOG_TAIL_BYTES = 8192;
@@ -174,23 +179,37 @@ function runVerifyAsset(stateDir: string): SetupCortexActionResult {
   };
 }
 
+/**
+ * The ENC-0g honesty suffix for the verify-asset summary line: when both gates
+ * are ON, surface the QualificationV1 record verdict so the action log is honest
+ * alongside the (possibly demoted) status card. Returns "" byte-identical when
+ * ENC_0G is off. Bounded + redacted (verdict + reasons only).
+ */
+function qualificationRecordSuffix(): string {
+  if (!ENC_0G_ENABLED() || !ENC_0F_ENABLED()) return "";
+  const record = readQualificationRecord(encoderStateDir());
+  if (record === null) return " record_verdict=unavailable";
+  return ` record_verdict=${record.verdict} record_reasons=${record.reasons.join(",")}`;
+}
+
 /** Compute the redacted verify-asset summary lines (digests + codes only). */
 function buildVerifySummary(): string {
+  const suffix = qualificationRecordSuffix();
   const dir = encoderAssetDir();
   if (dir === null) {
-    return "mode=C verdict=unavailable reason=asset_missing\n";
+    return `mode=C verdict=unavailable reason=asset_missing${suffix}\n`;
   }
   const manifest = readEncoderManifest(dir);
   if (manifest === null) {
-    return "mode=B verdict=demoted reason=ENC_MANIFEST_INVALID\n";
+    return `mode=B verdict=demoted reason=ENC_MANIFEST_INVALID${suffix}\n`;
   }
   const platform = detectPlatform();
   const verify = verifyEncoderAsset(dir, manifest, platform);
   if (verify.ok) {
     const prefix = verify.onnxDigest.slice(0, 12);
-    return `mode=A verdict=qualified onnx_digest_prefix=${prefix} embedded_bytes=${verify.embeddedBytes}\n`;
+    return `mode=A verdict=qualified onnx_digest_prefix=${prefix} embedded_bytes=${verify.embeddedBytes}${suffix}\n`;
   }
-  return `mode=B verdict=demoted reason=${verify.code}\n`;
+  return `mode=B verdict=demoted reason=${verify.code}${suffix}\n`;
 }
 
 /** Walk up to the committed encoder-v1 asset dir (mirrors routes-setup-cortex.ts). */

package/extensions/dashboard-server/setup-cortex-blockers.ts

@@ -1,99 +1,5 @@
 /**
- * dashboard-server/setup-cortex-blockers.ts — canonical blocker manifest for the
- * dashboard Setup Cortex status read path (VC9A).
- *
- * The hard-gate items enumerated in docs/vector-cortex/vc2-model-prep.md §6
- * (per the 2026-08-05 research update: the opset-14→17 re-export blocker is
- * REMOVED because onnx-community exports are now opset 21). This module is the
- * SINGLE canonical source of those blockers — the route file
- * (routes-setup-cortex.ts) carries NO string literals for them; it reads this
- * static manifest so the UI rows and the spec stay in one place.
- *
- * Reader-only, static: zero network, no writes (PREVENT-PI-004), no `any`
- * (PREVENT-011).
+ * dashboard-server/setup-cortex-blockers.ts — thin shell re-exporting the
+ * canonical Setup Cortex blocker compute from src (single source of truth).
  */
-
-/** The open hard-gate items VC9A surfaces (nothing is closed in-workstream). */
-export interface SetupCortexBlockerV1 {
-  /** Stable machine id (e.g. HG-1) the client can key rows on. */
-  readonly id: string;
-  /** Human title shown on the blockers card. */
-  readonly title: string;
-  /** Severity: blocker | high | medium. */
-  readonly severity: "blocker" | "high" | "medium";
-  /** Lifecycle state — all OPEN (hard gates are never silently closed). */
-  readonly status: "open";
-  /** Optional candidate resolution surfaced for the controller / user. */
-  readonly resolution?: string;
-}
-
-/**
- * The four blockers VC9A reports. Enumerates the vc2-model-prep §6 items that
- * remain per the 2026-08-05 research. The opset re-export blocker (formerly
- * §6 #2) is NOT listed: onnx-community exports are opset 21, so it is removed.
- */
-export const SETUP_CORTEX_BLOCKERS: readonly SetupCortexBlockerV1[] = [
-  {
-    id: "HG-1",
-    title: "Five projection heads do not exist",
-    severity: "blocker",
-    status: "open",
-    resolution:
-      "Supervision transfer onto a frozen bge-small-en-v1.5 trunk (contradiction distilled from cross-encoder/nli-deberta-v3-small; dependency NLI-assisted; cache-stability deterministic; payload-routing small MLP) — VC2B training + export.",
-  },
-  {
-    id: "HG-3",
-    title: "onnxruntime-node install exceeds the 80 MiB asset budget",
-    severity: "blocker",
-    status: "open",
-    resolution:
-      "onnxruntime-node bundles ~258 MiB across all platforms. Candidate: transformers.js v4.2.0 (9.5 MiB shell, pure-Node via onnxruntime-web WASM) measured against budget + p95 gate before committing.",
-  },
-  {
-    id: "HG-4",
-    title: "No darwin-x64 binary in onnxruntime-node",
-    severity: "high",
-    status: "open",
-    resolution:
-      "Intel-Mac mode-A users demote to the WASM path (if HG-3 resolves that way) or mode B. " +
-      "darwin-x64: no native binary upstream (arm64-only); mode-B WASM per HG-4.",
-  },
-  {
-    id: "HG-5",
-    title: "RSS margin at 512 tokens is ~0.5%",
-    severity: "medium",
-    status: "open",
-    resolution:
-      "149.2 MiB vs 150 MiB cap with run-to-run variance 119-149 MiB; considers capping mode A at 384 tokens or using the marginal-footprint accounting runtime.ts already implements.",
-  },
-];
-
-/** Look up one blocker by id; undefined when unknown (defensive). */
-export function setupCortexBlocker(id: string): SetupCortexBlockerV1 | undefined {
-  return SETUP_CORTEX_BLOCKERS.find((b) => b.id === id);
-}
-
-// ─── VC9B action gating ─────────────────────────────────────────────────────
-
-/** The VC9B action kinds the drivers know how to run. */
-export type SetupCortexActionKind = "fetch-model" | "bench" | "verify-asset";
-
-/**
- * The open hard-gate ids that BLOCK a given action. fetch-model and bench are
- * gated by HG-1 (five-head training open) and HG-3 (install budget open) per the
- * VC9 workstream plan; verify-asset is a pure re-read of committed assets and is
- * NOT gated. When a gated action is requested, the route returns
- * action_blocked_by_open_item with these ids and does NOT spawn. The ids are
- * always drawn from SETUP_CORTEX_BLOCKERS (each exists — verified by test).
- */
-export function setupCortexActionBlockers(
-  action: SetupCortexActionKind,
-): readonly string[] {
-  switch (action) {
-    case "fetch-model":
-    case "bench":
-      return ["HG-1", "HG-3"];
-    case "verify-asset":
-      return [];
-  }
-}
+export * from "../../src/vector-cortex/setup-cortex-blockers-compute.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-mega-compact",
-  "version": "0.20.47",
+  "version": "0.20.49",
   "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-enc0f.ts

@@ -0,0 +1,38 @@
+/**
+ * config/vector-cortex-enc0f.ts — ENC-0f p95 + marginal-RSS qualification gate.
+ *
+ * Extracted from vector-cortex.ts so that file stays under the 300-line soft
+ * limit (soft-as-hard gate), exactly as vector-cortex-enc0a.ts / enc0b.ts /
+ * enc0c.ts / enc0d.ts / enc0e.ts and the VC8C/VC9A-D/ML5A-E/DEDUP_ATTR
+ * siblings were. vector-cortex.ts re-exports the flag below and root
+ * src/config.ts re-exports it, so no consumer import path changes.
+ *
+ * ENC-0f closes HG-5 (RSS margin) with a real asset: the qualification gate
+ * that admits the ENC-0d-promoted trained asset to mode A. The gate runs the
+ * ML5-B bench under --expose-gc and asserts p95 ≤ ENCODER_LATENCY_P95_MS
+ * (40 ms @ 512 tokens / 4 threads), marginal RSS ≤ ENCODER_RSS_BUDGET_BYTES
+ * (150 MiB, baseline-subtracted), determinism (distinct digests == 1), and
+ * the opset-21 handshake. On pass it emits a QualificationV1 record that flips
+ * the runtime to qualified mode A; on any failure the asset stays demoted.
+ *
+ * `MEGACOMPACT_ENC_0F=0` disables the gate entirely: no qualification gate
+ * runs, no QualificationV1 record is written for the real trained asset, and
+ * the runtime keeps serving the ENC-0d survivor. Flag-off is byte-identical to
+ * the predecessor. The flag MUST also be a dashboard SETTINGS toggle (visible
+ * in config UI, never in EXCLUDED_SETTINGS).
+ *
+ * Pi-agnostic, dependency-free (PREVENT-PI-004 / PREVENT-011).
+ */
+
+import { sprintFlag } from "./vector-cortex-flag.js";
+
+/**
+ * ENC-0f — p95 + marginal-RSS qualification gate for the real trained asset.
+ * Default ON. `MEGACOMPACT_ENC_0F=0` disables and is byte-identical to the
+ * predecessor (ENC-0e): no qualification gate runs, no QualificationV1 record
+ * is written for the real trained asset, and the runtime keeps serving the
+ * ENC-0d survivor. This flag MUST also be a dashboard SETTINGS toggle (visible
+ * in config UI, never in EXCLUDED_SETTINGS), mirroring
+ * ENC_0A/ENC_0B/ENC_0C/ENC_0D/ENC_0E.
+ */
+export const ENC_0F_ENABLED = (): boolean => sprintFlag("MEGACOMPACT_ENC_0F");

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

@@ -0,0 +1,39 @@
+/**
+ * config/vector-cortex-enc0g.ts — ENC-0g Setup Cortex status route honest state.
+ *
+ * Extracted from vector-cortex.ts so that file stays under the 300-line soft
+ * limit (soft-as-hard gate), exactly as vector-cortex-enc0a.ts .. enc0f.ts and
+ * the VC8C/VC9A-D/ML5A-E/DEDUP_ATTR siblings were. vector-cortex.ts re-exports
+ * the flag below and root src/config.ts re-exports it, so no consumer import
+ * path changes.
+ *
+ * ENC-0g makes the Setup Cortex status route honest: the status route reads the
+ * latest ENC-0f `QualificationV1` record (when ENC_0F is ON and a record
+ * exists) and lets its verdict override the structural verifyEncoderAsset
+ * result for the `qualification` field; the blocker list becomes a pure
+ * computed function over (platform, qualification record, manifest head-count)
+ * with corrected HG statuses/wording; and VC9B action gating is re-derived from
+ * the live computed blockers instead of the stale static manifest.
+ *
+ * `MEGACOMPACT_ENC_0G=0` disables: the status route derives its `qualification`
+ * verdict from `verifyEncoderAsset(...).ok` alone, the blocker list is the
+ * static `SETUP_CORTEX_BLOCKERS` array exactly as ENC-0f-era, and action gating
+ * reads the static table as today — byte-identical to the predecessor. The flag
+ * MUST also be a dashboard SETTINGS toggle (visible in config UI, never in
+ * EXCLUDED_SETTINGS).
+ *
+ * Pi-agnostic, dependency-free (PREVENT-PI-004 / PREVENT-011).
+ */
+
+import { sprintFlag } from "./vector-cortex-flag.js";
+
+/**
+ * ENC-0g — Setup Cortex status route honest state (verdict override + live
+ * blockers + re-derived gating). Default ON. `MEGACOMPACT_ENC_0G=0` disables
+ * and is byte-identical to the predecessor (ENC-0f): verdict from
+ * `verifyEncoderAsset` alone, static `SETUP_CORTEX_BLOCKERS`, static
+ * `setupCortexActionBlockers`. This flag MUST also be a dashboard SETTINGS
+ * toggle (visible in config UI, never in EXCLUDED_SETTINGS), mirroring
+ * ENC_0A/ENC_0B/ENC_0C/ENC_0D/ENC_0E/ENC_0F.
+ */
+export const ENC_0G_ENABLED = (): boolean => sprintFlag("MEGACOMPACT_ENC_0G");

package/src/config/vector-cortex.ts

@@ -60,6 +60,8 @@ export { ENC_0B_ENABLED } from "./vector-cortex-enc0b.js";
 export { ENC_0C_ENABLED } from "./vector-cortex-enc0c.js";
 export { ENC_0D_ENABLED } from "./vector-cortex-enc0d.js";
 export { ENC_0E_ENABLED } from "./vector-cortex-enc0e.js";
+export { ENC_0F_ENABLED } from "./vector-cortex-enc0f.js";
+export { ENC_0G_ENABLED } from "./vector-cortex-enc0g.js";
 // Breaker constants (TRIAD_RESILIENCE.md §breaker) extracted to vector-cortex-breakers.ts.
 export {
   BREAKER_WINDOW_MS,

package/src/config.ts

@@ -194,6 +194,8 @@ export {
   ENC_0C_ENABLED,
   ENC_0D_ENABLED,
   ENC_0E_ENABLED,
+  ENC_0F_ENABLED,
+  ENC_0G_ENABLED,
   BREAKER_WINDOW_MS,
   BREAKER_MIN_ATTEMPTS,
   BREAKER_PERF_FAILURES,

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

@@ -0,0 +1,83 @@
+/**
+ * vector-cortex/encoder/qualify.ts — ENC-0f pure qualification function.
+ *
+ * Constructs a {@link QualificationV1} record from a {@link BenchResultV1} by
+ * asserting four independent gates (latency, marginal-RSS, determinism, opset)
+ * plus the bench's own conjunctive `gates.all`. A gated-off bench can NEVER be
+ * swept into mode A by a sub-threshold p95 alone — `bench_gates_not_green`
+ * forces `"failed"` regardless of the sub-threshold values.
+ *
+ * Pure (TRIAD_RESILIENCE §pure): no `any` (PREVENT-011), no casts, no clock, no
+ * storage, no network (PREVENT-PI-004). Thresholds are sourced from
+ * {@link ENCODER_LATENCY_P95_MS} / {@link ENCODER_RSS_BUDGET_BYTES} /
+ * {@link ENCODER_OPSET} — never magic numbers.
+ */
+
+import type { BenchResultV1 } from "./bench-export.js";
+import {
+  ENCODER_LATENCY_P95_MS,
+  ENCODER_RSS_BUDGET_BYTES,
+  ENCODER_OPSET,
+} from "./types.js";
+
+/** The qualification verdict for a real trained encoder asset. */
+export interface QualificationV1 {
+  readonly schema: "qualification-v1";
+  readonly verdict: "qualified" | "failed";
+  readonly reasons: string[];
+  readonly platform: string;
+  readonly p95Ms: number;
+  readonly rssMib: number;
+  readonly opset: number;
+  /** SHA-256 hex of the bench run's embedding output (never payload content). */
+  readonly digest: string;
+}
+
+/**
+ * Qualify a bench result against the four independent gates + the bench's own
+ * conjunctive gate. Returns a QualificationV1 with `verdict:"qualified"` only
+ * when ALL gates pass and `bench.gates.all` is true.
+ */
+export function qualifyEncodedAsset(
+  bench: BenchResultV1,
+  platform: string,
+): QualificationV1 {
+  const reasons: string[] = [];
+
+  if (bench.p95Ms !== null && bench.p95Ms > ENCODER_LATENCY_P95_MS) {
+    reasons.push("latency");
+  }
+
+  if (
+    bench.rssMarginalMib !== null &&
+    bench.rssMarginalMib * 1024 * 1024 > ENCODER_RSS_BUDGET_BYTES
+  ) {
+    reasons.push("rss");
+  }
+
+  if (!bench.deterministic) {
+    reasons.push("determinism");
+  }
+
+  if (bench.opset !== null && bench.opset !== ENCODER_OPSET) {
+    reasons.push("opset");
+  }
+
+  if (!bench.gates.all && !reasons.includes("bench_gates_not_green")) {
+    reasons.push("bench_gates_not_green");
+  }
+
+  const verdict: "qualified" | "failed" =
+    reasons.length === 0 && bench.gates.all ? "qualified" : "failed";
+
+  return {
+    schema: "qualification-v1",
+    verdict,
+    reasons,
+    platform,
+    p95Ms: bench.p95Ms ?? 0,
+    rssMib: bench.rssMarginalMib ?? 0,
+    opset: bench.opset ?? 0,
+    digest: bench.digest ?? "",
+  };
+}