From d6decbe05ccecd32d6a745767ee7a795bd1c88b1 Mon Sep 17 00:00:00 2001
From: DCCONSTRUCTIONS <dcconstructions@MacBook-Pro-DCCONSTRUCTIONS-2.local>
Date: Sat, 25 Jul 2026 16:02:20 +0300
Subject: [PATCH] feat(polygon): qualify GOOSE ground providers

---
 .../src/core/polygon/groundQualification.ts   |  393 ++++++
 .../control-station/src/styles/responsive.css |   22 +
 .../control-station/src/styles/workspaces.css |  240 ++++
 .../workspaces/DatasetGatewayWorkspace.tsx    |    7 +-
 .../src/workspaces/PolygonRunWorkspace.tsx    |  215 +++
 .../test/groundQualification.test.mjs         |  134 ++
 src/k1link/datasets/__init__.py               |   20 +
 src/k1link/datasets/cli.py                    |   35 +
 src/k1link/datasets/gateway.py                |   68 +-
 src/k1link/datasets/goose_qualification.py    | 1153 +++++++++++++++++
 src/k1link/web/app.py                         |    9 +-
 src/k1link/web/polygon_api.py                 |  170 +++
 tests/test_goose_qualification.py             |  128 ++
 tests/test_polygon_api.py                     |  146 ++-
 14 files changed, 2718 insertions(+), 22 deletions(-)
 create mode 100644 apps/control-station/src/core/polygon/groundQualification.ts
 create mode 100644 apps/control-station/test/groundQualification.test.mjs
 create mode 100644 src/k1link/datasets/goose_qualification.py
 create mode 100644 tests/test_goose_qualification.py

diff --git a/apps/control-station/src/core/polygon/groundQualification.ts b/apps/control-station/src/core/polygon/groundQualification.ts
new file mode 100644
index 0000000..b61feeb
--- /dev/null
+++ b/apps/control-station/src/core/polygon/groundQualification.ts
@@ -0,0 +1,393 @@
+export interface QualificationMetricAggregate {
+  micro: {
+    groundIou: number;
+    naturalGroundRecall: number;
+    obstacleNonGroundRecall: number;
+  };
+  latencyMs: {
+    p50: number;
+    p95: number;
+    maximum: number;
+  };
+  assignedFraction: number;
+  sourceCoverage: number;
+  frameCount: number;
+}
+
+export interface QualificationCheck {
+  checkId: string;
+  observed: number;
+  operator: ">=" | "<=";
+  threshold: number;
+  passed: boolean;
+}
+
+export interface QualificationWorstFrame {
+  frameId: string;
+  currentGroundIou: number;
+  patchworkGroundIou: number;
+  groundIouDelta: number;
+  patchworkNaturalGroundRecall: number;
+}
+
+export interface GroundQualification {
+  runId: string;
+  identitySha256: string;
+  sourceId: string;
+  split: string;
+  frameCount: number;
+  current: QualificationMetricAggregate;
+  patchwork: QualificationMetricAggregate;
+  degradations: Record<string, QualificationMetricAggregate>;
+  checks: QualificationCheck[];
+  worstFrames: QualificationWorstFrame[];
+  decision: {
+    status: "shadow-candidate" | "qualification-rejected";
+    passed: boolean;
+    promotedToNavigationOrSafety: false;
+    reason: string;
+  };
+}
+
+export interface GroundFailurePreview {
+  runId: string;
+  frameId: string;
+  sourcePointCount: number;
+  pointCount: number;
+  pointsXyzM: Array<[number, number, number]>;
+  groundTruthGround: number[];
+  evaluated: number[];
+  currentGround: number[];
+  patchworkGround: number[];
+  currentDisagreement: number[];
+  patchworkDisagreement: number[];
+}
+
+export class GroundQualificationContractError extends Error {}
+
+export class GroundQualificationApiError extends Error {
+  constructor(message: string, readonly status: number | null = null) {
+    super(message);
+  }
+}
+
+type QualificationFetch = (
+  input: RequestInfo | URL,
+  init?: RequestInit,
+) => Promise<Response>;
+
+const SAFE_ID = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/;
+const SHA256 = /^[a-f0-9]{64}$/;
+
+function record(value: unknown, field: string): Record<string, unknown> {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new GroundQualificationContractError(`${field} должен быть объектом.`);
+  }
+  return value as Record<string, unknown>;
+}
+
+function array(value: unknown, field: string, maximum: number): unknown[] {
+  if (!Array.isArray(value) || value.length > maximum) {
+    throw new GroundQualificationContractError(`${field} должен быть ограниченным массивом.`);
+  }
+  return value;
+}
+
+function text(value: unknown, field: string, maximum = 256): string {
+  if (typeof value !== "string" || !value.trim() || value.length > maximum) {
+    throw new GroundQualificationContractError(`${field} должен быть непустой строкой.`);
+  }
+  return value;
+}
+
+function id(value: unknown, field: string): string {
+  const result = text(value, field, 128);
+  if (!SAFE_ID.test(result)) {
+    throw new GroundQualificationContractError(`${field} содержит недопустимый идентификатор.`);
+  }
+  return result;
+}
+
+function number(value: unknown, field: string, minimum = 0): number {
+  if (typeof value !== "number" || !Number.isFinite(value) || value < minimum) {
+    throw new GroundQualificationContractError(`${field} должен быть конечным числом.`);
+  }
+  return value;
+}
+
+function fraction(value: unknown, field: string): number {
+  const result = number(value, field);
+  if (result > 1) {
+    throw new GroundQualificationContractError(`${field} должен быть долей 0..1.`);
+  }
+  return result;
+}
+
+function boolean(value: unknown, field: string): boolean {
+  if (typeof value !== "boolean") {
+    throw new GroundQualificationContractError(`${field} должен быть boolean.`);
+  }
+  return value;
+}
+
+function aggregate(value: unknown, field: string): QualificationMetricAggregate {
+  const source = record(value, field);
+  const micro = record(source.micro, `${field}.micro`);
+  const latency = record(source.latency_ms, `${field}.latency_ms`);
+  return {
+    micro: {
+      groundIou: fraction(micro.ground_iou, `${field}.micro.ground_iou`),
+      naturalGroundRecall: fraction(
+        micro.natural_ground_recall,
+        `${field}.micro.natural_ground_recall`,
+      ),
+      obstacleNonGroundRecall: fraction(
+        micro.obstacle_non_ground_recall,
+        `${field}.micro.obstacle_non_ground_recall`,
+      ),
+    },
+    latencyMs: {
+      p50: number(latency.p50, `${field}.latency_ms.p50`),
+      p95: number(latency.p95, `${field}.latency_ms.p95`),
+      maximum: number(latency.maximum, `${field}.latency_ms.maximum`),
+    },
+    assignedFraction: fraction(source.assigned_fraction, `${field}.assigned_fraction`),
+    sourceCoverage: fraction(source.source_coverage, `${field}.source_coverage`),
+    frameCount: number(source.frame_count, `${field}.frame_count`, 1),
+  };
+}
+
+export function decodeGroundQualification(payload: unknown): GroundQualification {
+  const source = record(payload, "qualification");
+  if (
+    source.schema_version !== "missioncore.polygon-ground-qualification/v1"
+    || source.access !== "read-only"
+  ) {
+    throw new GroundQualificationContractError("Неизвестная схема квалификации.");
+  }
+  const runId = id(source.run_id, "run_id");
+  const identitySha256 = text(source.identity_sha256, "identity_sha256", 64);
+  if (!SHA256.test(identitySha256)) {
+    throw new GroundQualificationContractError("identity_sha256 должен содержать SHA-256.");
+  }
+  const aggregates = record(source.aggregates, "aggregates");
+  const degradationSource = record(source.degradations, "degradations");
+  const degradations: Record<string, QualificationMetricAggregate> = {};
+  Object.entries(degradationSource).forEach(([profileId, value]) => {
+    if (!SAFE_ID.test(profileId) || Object.keys(degradations).length >= 32) {
+      throw new GroundQualificationContractError("Профили деградации имеют неверный контракт.");
+    }
+    degradations[profileId] = aggregate(value, `degradations.${profileId}`);
+  });
+  const checks = array(source.checks, "checks", 128).map((value, index) => {
+    const check = record(value, `checks[${index}]`);
+    const rawOperator = text(check.operator, `checks[${index}].operator`, 2);
+    if (rawOperator !== ">=" && rawOperator !== "<=") {
+      throw new GroundQualificationContractError("Проверка содержит неизвестный оператор.");
+    }
+    const operator: QualificationCheck["operator"] = rawOperator;
+    return {
+      checkId: id(check.check_id, `checks[${index}].check_id`),
+      observed: number(check.observed, `checks[${index}].observed`, -Infinity),
+      operator,
+      threshold: number(check.threshold, `checks[${index}].threshold`, -Infinity),
+      passed: boolean(check.passed, `checks[${index}].passed`),
+    };
+  });
+  const worstFrames = array(source.worst_frames, "worst_frames", 20).map(
+    (value, index) => {
+      const frame = record(value, `worst_frames[${index}]`);
+      return {
+        frameId: id(frame.frame_id, `worst_frames[${index}].frame_id`),
+        currentGroundIou: fraction(
+          frame.current_ground_iou,
+          `worst_frames[${index}].current_ground_iou`,
+        ),
+        patchworkGroundIou: fraction(
+          frame.patchwork_ground_iou,
+          `worst_frames[${index}].patchwork_ground_iou`,
+        ),
+        groundIouDelta: number(
+          frame.ground_iou_delta,
+          `worst_frames[${index}].ground_iou_delta`,
+          -1,
+        ),
+        patchworkNaturalGroundRecall: fraction(
+          frame.patchwork_natural_ground_recall,
+          `worst_frames[${index}].patchwork_natural_ground_recall`,
+        ),
+      };
+    },
+  );
+  const decision = record(source.decision, "decision");
+  const status = text(decision.status, "decision.status", 64);
+  if (status !== "shadow-candidate" && status !== "qualification-rejected") {
+    throw new GroundQualificationContractError("Решение квалификации неизвестно.");
+  }
+  if (decision.promoted_to_navigation_or_safety !== false) {
+    throw new GroundQualificationContractError(
+      "Квалификация не может принимать навигацию или safety.",
+    );
+  }
+  const frameCount = number(source.frame_count, "frame_count", 1);
+  const current = aggregate(aggregates.current, "aggregates.current");
+  const patchwork = aggregate(aggregates.patchworkpp, "aggregates.patchworkpp");
+  if (current.frameCount !== frameCount || patchwork.frameCount !== frameCount) {
+    throw new GroundQualificationContractError("Агрегаты не совпадают с числом кадров.");
+  }
+  return {
+    runId,
+    identitySha256,
+    sourceId: text(source.source_id, "source_id"),
+    split: id(source.split, "split"),
+    frameCount,
+    current,
+    patchwork,
+    degradations,
+    checks,
+    worstFrames,
+    decision: {
+      status,
+      passed: boolean(decision.passed, "decision.passed"),
+      promotedToNavigationOrSafety: false,
+      reason: text(decision.reason, "decision.reason", 512),
+    },
+  };
+}
+
+function mask(value: unknown, field: string, expected: number): number[] {
+  const values = array(value, field, 50_000).map((item, index) => {
+    if (item !== 0 && item !== 1) {
+      throw new GroundQualificationContractError(`${field}[${index}] должен быть 0 или 1.`);
+    }
+    return item;
+  });
+  if (values.length !== expected) {
+    throw new GroundQualificationContractError(`${field} не совпадает с point_count.`);
+  }
+  return values as number[];
+}
+
+export function decodeGroundFailurePreview(payload: unknown): GroundFailurePreview {
+  const source = record(payload, "failure preview");
+  if (
+    source.schema_version !== "missioncore.polygon-ground-failure-preview/v1"
+    || source.access !== "read-only"
+  ) {
+    throw new GroundQualificationContractError("Неизвестная схема preview.");
+  }
+  const pointCount = number(source.point_count, "point_count", 1);
+  const pointsXyzM = array(source.points_xyz_m, "points_xyz_m", 50_000).map(
+    (value, index): [number, number, number] => {
+      const tuple = array(value, `points_xyz_m[${index}]`, 3);
+      if (tuple.length !== 3) {
+        throw new GroundQualificationContractError("Точка должна содержать XYZ.");
+      }
+      return [
+        number(tuple[0], `points_xyz_m[${index}].x`, -Infinity),
+        number(tuple[1], `points_xyz_m[${index}].y`, -Infinity),
+        number(tuple[2], `points_xyz_m[${index}].z`, -Infinity),
+      ];
+    },
+  );
+  if (pointsXyzM.length !== pointCount) {
+    throw new GroundQualificationContractError("points_xyz_m не совпадает с point_count.");
+  }
+  return {
+    runId: id(source.run_id, "run_id"),
+    frameId: id(source.frame_id, "frame_id"),
+    sourcePointCount: number(source.source_point_count, "source_point_count", pointCount),
+    pointCount,
+    pointsXyzM,
+    groundTruthGround: mask(source.ground_truth_ground, "ground_truth_ground", pointCount),
+    evaluated: mask(source.evaluated, "evaluated", pointCount),
+    currentGround: mask(source.current_ground, "current_ground", pointCount),
+    patchworkGround: mask(source.patchwork_ground, "patchwork_ground", pointCount),
+    currentDisagreement: mask(
+      source.current_disagreement,
+      "current_disagreement",
+      pointCount,
+    ),
+    patchworkDisagreement: mask(
+      source.patchwork_disagreement,
+      "patchwork_disagreement",
+      pointCount,
+    ),
+  };
+}
+
+async function requestJson(
+  url: string,
+  signal: AbortSignal | undefined,
+  fetcher: QualificationFetch,
+): Promise<unknown> {
+  let response: Response;
+  try {
+    response = await fetcher(url, {
+      method: "GET",
+      headers: { Accept: "application/json" },
+      signal,
+    });
+  } catch (error) {
+    if (error instanceof DOMException && error.name === "AbortError") throw error;
+    throw new GroundQualificationApiError("Не удалось загрузить квалификацию.");
+  }
+  let body: unknown;
+  try {
+    body = await response.json();
+  } catch {
+    throw new GroundQualificationContractError("Polygon API вернул повреждённый JSON.");
+  }
+  if (!response.ok) {
+    const detail = typeof body === "object" && body !== null && "detail" in body
+      ? String((body as { detail: unknown }).detail)
+      : `Polygon API HTTP ${response.status}.`;
+    throw new GroundQualificationApiError(detail, response.status);
+  }
+  return body;
+}
+
+export async function fetchGroundQualification(
+  runId: string,
+  {
+    signal,
+    fetcher = globalThis.fetch,
+  }: { signal?: AbortSignal; fetcher?: QualificationFetch } = {},
+): Promise<GroundQualification | null> {
+  if (!SAFE_ID.test(runId)) {
+    throw new GroundQualificationContractError("Недопустимый run_id.");
+  }
+  try {
+    return decodeGroundQualification(
+      await requestJson(
+        `/api/v1/polygon/runs/${encodeURIComponent(runId)}/qualification`,
+        signal,
+        fetcher,
+      ),
+    );
+  } catch (error) {
+    if (error instanceof GroundQualificationApiError && error.status === 404) return null;
+    throw error;
+  }
+}
+
+export async function fetchGroundFailurePreview(
+  runId: string,
+  frameId: string,
+  {
+    signal,
+    fetcher = globalThis.fetch,
+  }: { signal?: AbortSignal; fetcher?: QualificationFetch } = {},
+): Promise<GroundFailurePreview> {
+  if (!SAFE_ID.test(runId) || !SAFE_ID.test(frameId)) {
+    throw new GroundQualificationContractError("Недопустимый идентификатор preview.");
+  }
+  return decodeGroundFailurePreview(
+    await requestJson(
+      `/api/v1/polygon/runs/${encodeURIComponent(runId)}/qualification/failures/`
+      + encodeURIComponent(frameId),
+      signal,
+      fetcher,
+    ),
+  );
+}
diff --git a/apps/control-station/src/styles/responsive.css b/apps/control-station/src/styles/responsive.css
index 8bf5cf6..7a040be 100644
--- a/apps/control-station/src/styles/responsive.css
+++ b/apps/control-station/src/styles/responsive.css
@@ -97,6 +97,15 @@
 }
 
 @media (max-width: 1040px) {
+  .polygon-qualification__grid,
+  .polygon-qualification__failures {
+    grid-template-columns: 1fr;
+  }
+
+  .polygon-qualification__providers dl {
+    grid-template-columns: repeat(2, minmax(0, 1fr));
+  }
+
   .feature-group {
     grid-template-columns: 1fr;
     gap: 0.9rem;
@@ -174,6 +183,19 @@
 }
 
 @media (max-width: 760px) {
+  .polygon-qualification__heading,
+  .polygon-qualification__viewer > header {
+    display: grid;
+  }
+
+  .polygon-qualification__providers {
+    grid-template-columns: 1fr;
+  }
+
+  .polygon-qualification__degradations p {
+    grid-template-columns: 1fr 1fr;
+  }
+
   .dataset-purpose ol {
     display: grid;
     grid-template-columns: repeat(2, minmax(0, 1fr));
diff --git a/apps/control-station/src/styles/workspaces.css b/apps/control-station/src/styles/workspaces.css
index a5f632b..f4db2f2 100644
--- a/apps/control-station/src/styles/workspaces.css
+++ b/apps/control-station/src/styles/workspaces.css
@@ -775,6 +775,246 @@
   line-height: 1.5;
 }
 
+.polygon-qualification {
+  display: grid;
+  gap: 0.75rem;
+  border-radius: 1.2rem;
+  background: var(--station-panel);
+  padding: 1rem;
+}
+
+.polygon-qualification__heading {
+  display: flex;
+  align-items: flex-start;
+  justify-content: space-between;
+  gap: 1.5rem;
+}
+
+.polygon-qualification__heading h3,
+.polygon-qualification__heading p {
+  margin: 0;
+}
+
+.polygon-qualification__heading h3 {
+  margin-top: 0.35rem;
+  color: var(--nodedc-text-primary);
+  font-size: 1.15rem;
+  letter-spacing: -0.035em;
+}
+
+.polygon-qualification__heading p {
+  max-width: 46rem;
+  margin-top: 0.45rem;
+  color: var(--nodedc-text-muted);
+  font-size: 0.62rem;
+  line-height: 1.5;
+}
+
+.polygon-qualification__providers {
+  display: grid;
+  grid-template-columns: repeat(2, minmax(0, 1fr));
+  gap: 0.6rem;
+}
+
+.polygon-qualification__providers article,
+.polygon-qualification__checks,
+.polygon-qualification__degradations,
+.polygon-qualification__failures > article {
+  border-radius: 0.9rem;
+  background: rgb(255 255 255 / 0.03);
+  padding: 0.85rem;
+}
+
+.polygon-qualification__providers article > strong {
+  color: var(--nodedc-text-primary);
+  font-size: 0.75rem;
+}
+
+.polygon-qualification__providers dl {
+  display: grid;
+  grid-template-columns: repeat(4, minmax(0, 1fr));
+  gap: 0.6rem;
+  margin: 0.75rem 0 0;
+}
+
+.polygon-qualification__providers dl > div {
+  display: grid;
+  gap: 0.22rem;
+}
+
+.polygon-qualification__providers dt,
+.polygon-qualification__providers dd {
+  margin: 0;
+}
+
+.polygon-qualification__providers dt {
+  color: var(--nodedc-text-muted);
+  font-size: 0.55rem;
+}
+
+.polygon-qualification__providers dd {
+  color: var(--nodedc-text-primary);
+  font-size: 0.88rem;
+  font-weight: 650;
+}
+
+.polygon-qualification__grid {
+  display: grid;
+  grid-template-columns: minmax(0, 1fr) minmax(0, 1fr);
+  gap: 0.6rem;
+}
+
+.polygon-qualification__checks > div,
+.polygon-qualification__degradations > div {
+  display: grid;
+  gap: 0.25rem;
+  margin-top: 0.7rem;
+}
+
+.polygon-qualification__checks p,
+.polygon-qualification__degradations p {
+  display: grid;
+  min-width: 0;
+  align-items: center;
+  gap: 0.55rem;
+  margin: 0;
+  border-radius: 0.65rem;
+  background: rgb(255 255 255 / 0.025);
+  padding: 0.48rem 0.55rem;
+}
+
+.polygon-qualification__checks p {
+  grid-template-columns: auto minmax(0, 1fr) auto;
+}
+
+.polygon-qualification__checks i {
+  width: 0.42rem;
+  height: 0.42rem;
+  border-radius: 50%;
+  background: rgb(var(--nodedc-danger-rgb));
+}
+
+.polygon-qualification__checks p[data-passed="true"] i {
+  background: rgb(var(--nodedc-success-rgb));
+}
+
+.polygon-qualification__checks span,
+.polygon-qualification__checks code,
+.polygon-qualification__degradations strong,
+.polygon-qualification__degradations span {
+  overflow: hidden;
+  font-size: 0.55rem;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.polygon-qualification__checks span,
+.polygon-qualification__degradations strong {
+  color: var(--nodedc-text-secondary);
+}
+
+.polygon-qualification__checks code,
+.polygon-qualification__degradations span {
+  color: var(--nodedc-text-muted);
+}
+
+.polygon-qualification__degradations p {
+  grid-template-columns: minmax(7rem, 1fr) repeat(3, auto);
+}
+
+.polygon-qualification__failures {
+  display: grid;
+  grid-template-columns: minmax(14rem, 0.34fr) minmax(0, 1.66fr);
+  gap: 0.6rem;
+}
+
+.polygon-qualification__failures > article:first-child > div {
+  display: grid;
+  gap: 0.3rem;
+  margin-top: 0.7rem;
+}
+
+.polygon-qualification__failures button {
+  display: grid;
+  min-width: 0;
+  gap: 0.22rem;
+  border: 0;
+  border-radius: 0.65rem;
+  background: rgb(255 255 255 / 0.025);
+  color: var(--nodedc-text-secondary);
+  padding: 0.55rem;
+  text-align: left;
+  cursor: pointer;
+}
+
+.polygon-qualification__failures button:hover,
+.polygon-qualification__failures button:focus-visible,
+.polygon-qualification__failures button[data-active="true"] {
+  outline: 0;
+  background: rgb(255 255 255 / 0.075);
+}
+
+.polygon-qualification__failures button span,
+.polygon-qualification__failures button code {
+  overflow: hidden;
+  font-size: 0.54rem;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.polygon-qualification__failures button code {
+  color: var(--nodedc-text-muted);
+}
+
+.polygon-qualification__viewer {
+  min-width: 0;
+}
+
+.polygon-qualification__viewer > header {
+  display: flex;
+  min-width: 0;
+  align-items: center;
+  justify-content: space-between;
+  gap: 1rem;
+  margin-bottom: 0.65rem;
+}
+
+.polygon-qualification__viewer > header > div:first-child {
+  display: grid;
+  min-width: 0;
+  gap: 0.25rem;
+}
+
+.polygon-qualification__viewer > header strong {
+  overflow: hidden;
+  color: var(--nodedc-text-primary);
+  font-size: 0.62rem;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.polygon-qualification__viewer .lidar-ground-scene {
+  min-height: 30rem;
+}
+
+.polygon-qualification__viewer-empty {
+  display: grid;
+  min-height: 30rem;
+  place-items: center;
+  border-radius: 0.85rem;
+  background: #06070a;
+  color: var(--nodedc-text-muted);
+  font-size: 0.62rem;
+}
+
+.polygon-qualification__error {
+  border-radius: 0.9rem;
+  background: rgb(var(--nodedc-danger-rgb) / 0.08);
+  color: var(--nodedc-text-muted);
+  padding: 0.8rem 1rem;
+  font-size: 0.62rem;
+}
+
 .capability-summary {
   display: grid;
   grid-template-columns: repeat(4, minmax(0, 1fr));
diff --git a/apps/control-station/src/workspaces/DatasetGatewayWorkspace.tsx b/apps/control-station/src/workspaces/DatasetGatewayWorkspace.tsx
index af721e2..981d7e9 100644
--- a/apps/control-station/src/workspaces/DatasetGatewayWorkspace.tsx
+++ b/apps/control-station/src/workspaces/DatasetGatewayWorkspace.tsx
@@ -275,10 +275,11 @@ export function DatasetGatewayWorkspace() {
                   </Button>
                   <Button
                     size="compact"
-                    disabled
-                    title="Прогон станет доступен после импорта датасета"
+                    variant="secondary"
+                    title="Открыть read-only архив квалификационных прогонов"
+                    onClick={() => window.location.assign("/?workspace=polygon-run")}
                   >
-                    Создать прогон
+                    Открыть прогоны
                   </Button>
                 </div>
               </footer>
diff --git a/apps/control-station/src/workspaces/PolygonRunWorkspace.tsx b/apps/control-station/src/workspaces/PolygonRunWorkspace.tsx
index a33479c..22a997d 100644
--- a/apps/control-station/src/workspaces/PolygonRunWorkspace.tsx
+++ b/apps/control-station/src/workspaces/PolygonRunWorkspace.tsx
@@ -5,6 +5,12 @@ import {
   StatusBadge,
 } from "@nodedc/ui-react";
 
+import {
+  fetchGroundFailurePreview,
+  fetchGroundQualification,
+  type GroundFailurePreview,
+  type GroundQualification,
+} from "../core/polygon/groundQualification";
 import {
   fetchPolygonRunCatalog,
   fetchPolygonRunDetail,
@@ -13,6 +19,10 @@ import {
   type PolygonRunRoute,
   type PolygonRunState,
 } from "../core/polygon/runArchive";
+import {
+  LidarGroundPointCloud,
+  type LidarGroundViewMode,
+} from "./LidarGroundPointCloud";
 import { PolygonLivePanel } from "./PolygonLivePanel";
 
 interface PolygonRunWorkspaceProps {
@@ -62,6 +72,17 @@ function errorMessage(error: unknown): string {
   return "Не удалось прочитать доказательства прогона.";
 }
 
+function formatPercent(value: number): string {
+  return new Intl.NumberFormat("ru-RU", {
+    style: "percent",
+    maximumFractionDigits: 1,
+  }).format(value);
+}
+
+function formatMilliseconds(value: number): string {
+  return `${value.toLocaleString("ru-RU", { maximumFractionDigits: 1 })} мс`;
+}
+
 export function PolygonRunWorkspace({ route }: PolygonRunWorkspaceProps) {
   const [catalog, setCatalog] = useState<PolygonRunCatalog | null>(null);
   const [detail, setDetail] = useState<PolygonRunDetail | null>(null);
@@ -69,6 +90,12 @@ export function PolygonRunWorkspace({ route }: PolygonRunWorkspaceProps) {
   const [loading, setLoading] = useState(route.error === null);
   const [error, setError] = useState<string | null>(route.error);
   const [reloadGeneration, setReloadGeneration] = useState(0);
+  const [qualification, setQualification] = useState<GroundQualification | null>(null);
+  const [qualificationError, setQualificationError] = useState<string | null>(null);
+  const [failurePreview, setFailurePreview] = useState<GroundFailurePreview | null>(null);
+  const [selectedFailureFrameId, setSelectedFailureFrameId] = useState<string | null>(null);
+  const [failureMode, setFailureMode] =
+    useState<LidarGroundViewMode>("candidate-disagreement");
 
   useEffect(() => {
     if (route.error) {
@@ -106,10 +133,71 @@ export function PolygonRunWorkspace({ route }: PolygonRunWorkspaceProps) {
     return () => controller.abort();
   }, [reloadGeneration, route.error, route.runId, selectedRunId]);
 
+  useEffect(() => {
+    const runId = detail?.run.runId;
+    if (!runId) {
+      setQualification(null);
+      setQualificationError(null);
+      return;
+    }
+    const controller = new AbortController();
+    setQualification(null);
+    setQualificationError(null);
+    setFailurePreview(null);
+    setSelectedFailureFrameId(null);
+    void fetchGroundQualification(runId, { signal: controller.signal })
+      .then((result) => {
+        if (controller.signal.aborted) return;
+        setQualification(result);
+        setSelectedFailureFrameId(result?.worstFrames[0]?.frameId ?? null);
+      })
+      .catch((loadError: unknown) => {
+        if (!controller.signal.aborted) setQualificationError(errorMessage(loadError));
+      });
+    return () => controller.abort();
+  }, [detail?.run.runId]);
+
+  useEffect(() => {
+    const runId = qualification?.runId;
+    if (!runId || !selectedFailureFrameId) {
+      setFailurePreview(null);
+      return;
+    }
+    const controller = new AbortController();
+    setFailurePreview(null);
+    void fetchGroundFailurePreview(runId, selectedFailureFrameId, {
+      signal: controller.signal,
+    })
+      .then((result) => {
+        if (!controller.signal.aborted) setFailurePreview(result);
+      })
+      .catch((loadError: unknown) => {
+        if (!controller.signal.aborted) setQualificationError(errorMessage(loadError));
+      });
+    return () => controller.abort();
+  }, [qualification?.runId, selectedFailureFrameId]);
+
   const visibleEvents = useMemo(
     () => detail ? [...detail.events].reverse() : [],
     [detail],
   );
+  const failureFrame = useMemo(() => {
+    if (!failurePreview) return null;
+    return {
+      pointCount: failurePreview.pointCount,
+      pointsXyzM: failurePreview.pointsXyzM,
+      intensity0To255: null,
+      masks: {
+        currentGround: failurePreview.currentGround,
+        currentAssigned: failurePreview.evaluated,
+        candidateGround: failurePreview.patchworkGround,
+        candidateAssigned: failurePreview.evaluated,
+        disagreement: failurePreview.currentDisagreement,
+        candidateDisagreement: failurePreview.patchworkDisagreement,
+        groundTruthGround: failurePreview.groundTruthGround,
+      },
+    };
+  }, [failurePreview]);
 
   if (loading && !detail) {
     return (
@@ -199,6 +287,133 @@ export function PolygonRunWorkspace({ route }: PolygonRunWorkspaceProps) {
         </div>
       </section>
 
+      {qualification ? (
+        <section className="polygon-qualification" aria-label="Квалификация ground provider">
+          <header className="polygon-qualification__heading">
+            <div>
+              <span className="section-eyebrow">GOOSE VALIDATION · {qualification.frameCount} КАДРОВ</span>
+              <h3>Current против Patchwork++</h3>
+              <p>
+                Публичная разметка проверяет переносимость ground pipeline. Результат остаётся
+                shadow-only и не даёт права на навигацию или safety.
+              </p>
+            </div>
+            <StatusBadge tone={qualification.decision.passed ? "success" : "danger"}>
+              {qualification.decision.passed ? "Shadow candidate" : "Gate не пройден"}
+            </StatusBadge>
+          </header>
+
+          <div className="polygon-qualification__providers">
+            {([
+              ["Current", qualification.current],
+              ["Patchwork++", qualification.patchwork],
+            ] as const).map(([label, aggregate]) => (
+              <article key={label}>
+                <strong>{label}</strong>
+                <dl>
+                  <div><dt>Ground IoU</dt><dd>{formatPercent(aggregate.micro.groundIou)}</dd></div>
+                  <div><dt>Natural ground</dt><dd>{formatPercent(aggregate.micro.naturalGroundRecall)}</dd></div>
+                  <div><dt>Obstacle recall</dt><dd>{formatPercent(aggregate.micro.obstacleNonGroundRecall)}</dd></div>
+                  <div><dt>Latency p95</dt><dd>{formatMilliseconds(aggregate.latencyMs.p95)}</dd></div>
+                </dl>
+              </article>
+            ))}
+          </div>
+
+          <div className="polygon-qualification__grid">
+            <article className="polygon-qualification__checks">
+              <span className="section-eyebrow">ЗАРАНЕЕ ЗАФИКСИРОВАННЫЕ GATES</span>
+              <div>
+                {qualification.checks.map((check) => (
+                  <p key={check.checkId} data-passed={check.passed ? "true" : "false"}>
+                    <i aria-hidden="true" />
+                    <span>{check.checkId}</span>
+                    <code>
+                      {check.observed.toLocaleString("ru-RU", { maximumFractionDigits: 3 })}
+                      {" "}{check.operator}{" "}
+                      {check.threshold.toLocaleString("ru-RU", { maximumFractionDigits: 3 })}
+                    </code>
+                  </p>
+                ))}
+              </div>
+            </article>
+
+            <article className="polygon-qualification__degradations">
+              <span className="section-eyebrow">ДЕТЕРМИНИРОВАННЫЕ ДЕГРАДАЦИИ</span>
+              <div>
+                {Object.entries(qualification.degradations).map(([profileId, aggregate]) => (
+                  <p key={profileId}>
+                    <strong>{profileId}</strong>
+                    <span>IoU {formatPercent(aggregate.micro.groundIou)}</span>
+                    <span>Natural {formatPercent(aggregate.micro.naturalGroundRecall)}</span>
+                    <span>p95 {formatMilliseconds(aggregate.latencyMs.p95)}</span>
+                  </p>
+                ))}
+              </div>
+            </article>
+          </div>
+
+          <div className="polygon-qualification__failures">
+            <article>
+              <span className="section-eyebrow">ХУДШИЕ КАДРЫ</span>
+              <div>
+                {qualification.worstFrames.slice(0, 5).map((frame) => (
+                  <button
+                    type="button"
+                    key={frame.frameId}
+                    data-active={frame.frameId === selectedFailureFrameId ? "true" : undefined}
+                    onClick={() => setSelectedFailureFrameId(frame.frameId)}
+                  >
+                    <span>{frame.frameId}</span>
+                    <code>
+                      PW {formatPercent(frame.patchworkGroundIou)} ·
+                      Δ {formatPercent(frame.groundIouDelta)}
+                    </code>
+                  </button>
+                ))}
+              </div>
+            </article>
+            <article className="polygon-qualification__viewer">
+              <header>
+                <div>
+                  <span className="section-eyebrow">РАЗБОР ОШИБКИ</span>
+                  <strong>{failurePreview?.frameId ?? "Загружаем кадр"}</strong>
+                </div>
+                <div className="lidar-ground-modes" aria-label="Режим отображения ошибки">
+                  {([
+                    ["ground-truth", "Ground truth"],
+                    ["current", "Current"],
+                    ["candidate", "Patchwork++"],
+                    ["disagreement", "Ошибка Current"],
+                    ["candidate-disagreement", "Ошибка PW++"],
+                  ] as const).map(([mode, label]) => (
+                    <button
+                      type="button"
+                      key={mode}
+                      data-active={failureMode === mode ? "true" : undefined}
+                      onClick={() => setFailureMode(mode)}
+                    >
+                      {label}
+                    </button>
+                  ))}
+                </div>
+              </header>
+              {failureFrame ? (
+                <LidarGroundPointCloud frame={failureFrame} mode={failureMode} />
+              ) : (
+                <div className="polygon-qualification__viewer-empty">
+                  Читаем bounded preview из sealed-артефакта прогона…
+                </div>
+              )}
+            </article>
+          </div>
+        </section>
+      ) : qualificationError ? (
+        <div className="polygon-qualification__error">
+          Квалификационный отчёт недоступен: {qualificationError}
+        </div>
+      ) : null}
+
       <div className="polygon-run-layout">
         <GlassSurface className="polygon-run-catalog" padding="lg">
           <header className="polygon-run-panel-heading">
diff --git a/apps/control-station/test/groundQualification.test.mjs b/apps/control-station/test/groundQualification.test.mjs
new file mode 100644
index 0000000..df0c59b
--- /dev/null
+++ b/apps/control-station/test/groundQualification.test.mjs
@@ -0,0 +1,134 @@
+import assert from "node:assert/strict";
+import { after, before, test } from "node:test";
+
+import { createServer } from "vite";
+
+let server;
+let decodeGroundQualification;
+let decodeGroundFailurePreview;
+let fetchGroundQualification;
+let GroundQualificationContractError;
+
+const aggregate = {
+  micro: {
+    ground_iou: 0.75,
+    natural_ground_recall: 0.8,
+    obstacle_non_ground_recall: 0.92,
+  },
+  latency_ms: { p50: 12, p95: 18, maximum: 25 },
+  assigned_fraction: 1,
+  source_coverage: 1,
+  frame_count: 961,
+};
+
+const qualification = {
+  schema_version: "missioncore.polygon-ground-qualification/v1",
+  access: "read-only",
+  run_id: "goose-ground-abc",
+  identity_sha256: "a".repeat(64),
+  source_id: "goose-3d/v2025-08-22",
+  split: "validation",
+  frame_count: 961,
+  aggregates: {
+    current: { ...aggregate, micro: { ...aggregate.micro, ground_iou: 0.5 } },
+    patchworkpp: aggregate,
+  },
+  degradations: { "range-20m": { ...aggregate, source_coverage: 0.6 } },
+  checks: [{
+    check_id: "ground-iou-gain",
+    observed: 0.25,
+    operator: ">=",
+    threshold: 0.07,
+    passed: true,
+  }],
+  worst_frames: [{
+    frame_id: "2022-07-22_flight__0071_0001",
+    current_ground_iou: 0.6,
+    patchwork_ground_iou: 0.55,
+    ground_iou_delta: -0.05,
+    patchwork_natural_ground_recall: 0.7,
+  }],
+  decision: {
+    status: "shadow-candidate",
+    passed: true,
+    promoted_to_navigation_or_safety: false,
+    reason: "all gates passed",
+  },
+  safety: {
+    qualification_only: true,
+    actuator_authority: false,
+    navigation_or_safety_accepted: false,
+  },
+};
+
+before(async () => {
+  server = await createServer({
+    appType: "custom",
+    logLevel: "silent",
+    server: { middlewareMode: true },
+  });
+  ({
+    decodeGroundQualification,
+    decodeGroundFailurePreview,
+    fetchGroundQualification,
+    GroundQualificationContractError,
+  } = await server.ssrLoadModule("/src/core/polygon/groundQualification.ts"));
+});
+
+after(async () => {
+  await server?.close();
+});
+
+test("decodes a bounded shadow-only qualification", () => {
+  const decoded = decodeGroundQualification(qualification);
+  assert.equal(decoded.frameCount, 961);
+  assert.equal(decoded.patchwork.micro.groundIou, 0.75);
+  assert.equal(decoded.degradations["range-20m"].sourceCoverage, 0.6);
+  assert.equal(decoded.decision.promotedToNavigationOrSafety, false);
+});
+
+test("rejects navigation or safety promotion", () => {
+  assert.throws(
+    () => decodeGroundQualification({
+      ...qualification,
+      decision: {
+        ...qualification.decision,
+        promoted_to_navigation_or_safety: true,
+      },
+    }),
+    GroundQualificationContractError,
+  );
+});
+
+test("decodes point-aligned failure preview", () => {
+  const decoded = decodeGroundFailurePreview({
+    schema_version: "missioncore.polygon-ground-failure-preview/v1",
+    access: "read-only",
+    run_id: "goose-ground-abc",
+    source_id: "goose-3d/v2025-08-22",
+    frame_id: "2022-07-22_flight__0071_0001",
+    source_point_count: 2,
+    point_count: 2,
+    sampling: "deterministic-even-index",
+    points_xyz_m: [[0, 0, 0], [1, 1, 1]],
+    ground_truth_ground: [1, 0],
+    evaluated: [1, 1],
+    current_ground: [0, 0],
+    patchwork_ground: [1, 0],
+    current_disagreement: [1, 0],
+    patchwork_disagreement: [0, 0],
+    safety: { navigation_or_safety_accepted: false },
+  });
+  assert.equal(decoded.pointCount, 2);
+  assert.deepEqual(decoded.patchworkGround, [1, 0]);
+});
+
+test("treats missing qualification as a generic run", async () => {
+  const result = await fetchGroundQualification("goose-ground-abc", {
+    fetcher: async () => new Response(
+      JSON.stringify({ detail: "not found" }),
+      { status: 404, headers: { "content-type": "application/json" } },
+    ),
+  });
+  assert.equal(result, null);
+});
diff --git a/src/k1link/datasets/__init__.py b/src/k1link/datasets/__init__.py
index 57893ed..9e68ec1 100644
--- a/src/k1link/datasets/__init__.py
+++ b/src/k1link/datasets/__init__.py
@@ -9,6 +9,7 @@ from k1link.datasets.gateway import (
     configured_dataset_ground_preview,
     configured_dataset_preview,
     dataset_gateway_catalog,
+    decode_semantic_kitti_frame,
     read_dataset_admission_manifest,
     read_dataset_ground_preview,
     read_dataset_native_scan_preview,
@@ -27,6 +28,16 @@ from k1link.datasets.goose_profile import (
     GOOSE_PATCHWORK_PROFILE_SCHEMA,
     GoosePatchworkProfile,
 )
+from k1link.datasets.goose_qualification import (
+    DEFAULT_DEGRADATIONS,
+    GOOSE_QUALIFICATION_FRAME_SCHEMA,
+    GOOSE_QUALIFICATION_PREVIEW_SCHEMA,
+    GOOSE_QUALIFICATION_PROFILE_SCHEMA,
+    GOOSE_QUALIFICATION_REPORT_SCHEMA,
+    DegradationProfile,
+    GroundAcceptancePolicy,
+    qualify_goose_ground,
+)
 
 __all__ = [
     "DATASET_GATEWAY_CATALOG_SCHEMA",
@@ -39,15 +50,24 @@ __all__ = [
     "GOOSE_GROUND_BENCHMARK_SCHEMA",
     "GOOSE_GROUND_PREVIEW_SCHEMA",
     "GOOSE_PATCHWORK_PROFILE_SCHEMA",
+    "GOOSE_QUALIFICATION_FRAME_SCHEMA",
+    "GOOSE_QUALIFICATION_PREVIEW_SCHEMA",
+    "GOOSE_QUALIFICATION_PROFILE_SCHEMA",
+    "GOOSE_QUALIFICATION_REPORT_SCHEMA",
     "GoosePatchworkProfile",
+    "GroundAcceptancePolicy",
+    "DegradationProfile",
+    "DEFAULT_DEGRADATIONS",
     "benchmark_goose_current_ground",
     "benchmark_goose_patchwork_ground",
     "configured_dataset_admission_manifest",
     "configured_dataset_ground_preview",
     "configured_dataset_preview",
     "dataset_gateway_catalog",
+    "decode_semantic_kitti_frame",
     "read_dataset_admission_manifest",
     "read_dataset_ground_preview",
     "read_dataset_native_scan_preview",
     "read_semantic_kitti_frame",
+    "qualify_goose_ground",
 ]
diff --git a/src/k1link/datasets/cli.py b/src/k1link/datasets/cli.py
index c9f34f8..229c4b1 100644
--- a/src/k1link/datasets/cli.py
+++ b/src/k1link/datasets/cli.py
@@ -13,6 +13,7 @@ from k1link.datasets.goose_benchmark import (
     benchmark_goose_current_ground,
     benchmark_goose_patchwork_ground,
 )
+from k1link.datasets.goose_qualification import qualify_goose_ground
 
 app = typer.Typer(
     add_completion=False,
@@ -83,5 +84,39 @@ def benchmark_goose_patchwork_ground_command(
     typer.echo(json.dumps(report, ensure_ascii=False, sort_keys=True))
 
 
+@app.command("qualify-goose-ground")
+def qualify_goose_ground_command(
+    dataset_root: Annotated[
+        Path,
+        typer.Option("--dataset-root", exists=True, file_okay=False, resolve_path=True),
+    ],
+    runs_root: Annotated[
+        Path,
+        typer.Option("--runs-root", file_okay=False, resolve_path=True),
+    ],
+    mission_core_commit: Annotated[
+        str,
+        typer.Option("--mission-core-commit", min=7, max=64),
+    ],
+    workers: Annotated[
+        int,
+        typer.Option("--workers", min=1, max=32),
+    ] = 8,
+) -> None:
+    """Run the immutable GOOSE validation-split ground qualification."""
+
+    try:
+        report = qualify_goose_ground(
+            dataset_root,
+            runs_root,
+            mission_core_commit=mission_core_commit,
+            parallel_workers=workers,
+        )
+    except (GooseAdmissionError, ValueError) as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(code=2) from exc
+    typer.echo(json.dumps(report, ensure_ascii=False, sort_keys=True))
+
+
 if __name__ == "__main__":
     app()
diff --git a/src/k1link/datasets/gateway.py b/src/k1link/datasets/gateway.py
index 9d3ee73..166e05c 100644
--- a/src/k1link/datasets/gateway.py
+++ b/src/k1link/datasets/gateway.py
@@ -67,27 +67,45 @@ def read_semantic_kitti_frame(
 ) -> DatasetPointFrame:
     """Read one GOOSE/SemanticKITTI XYZI + packed-label frame losslessly."""
 
-    if maximum_points <= 0:
-        raise DatasetFrameError("maximum_points must be positive")
     try:
         point_size = point_path.stat().st_size
         label_size = label_path.stat().st_size
+        _validate_semantic_kitti_sizes(
+            point_size,
+            label_size,
+            maximum_points=maximum_points,
+        )
+        point_bytes = point_path.read_bytes()
+        label_bytes = label_path.read_bytes()
     except OSError as exc:
         raise DatasetFrameError("dataset point or label file is unavailable") from exc
-    if point_size == 0 or point_size % 16:
-        raise DatasetFrameError("point frame must contain little-endian float32 XYZI tuples")
-    if label_size % 4:
-        raise DatasetFrameError("label frame must contain packed little-endian uint32 values")
-    point_count = point_size // 16
-    if point_count > maximum_points:
-        raise DatasetFrameError("dataset point frame exceeds the configured safety limit")
-    if label_size // 4 != point_count:
-        raise DatasetFrameError("point and label counts do not match")
+    return decode_semantic_kitti_frame(
+        point_bytes,
+        label_bytes,
+        maximum_points=maximum_points,
+    )
+
+
+def decode_semantic_kitti_frame(
+    point_bytes: bytes,
+    label_bytes: bytes,
+    *,
+    maximum_points: int = 2_000_000,
+) -> DatasetPointFrame:
+    """Decode one in-memory SemanticKITTI frame without extracting an archive."""
+
+    point_size = len(point_bytes)
+    label_size = len(label_bytes)
+    point_count = _validate_semantic_kitti_sizes(
+        point_size,
+        label_size,
+        maximum_points=maximum_points,
+    )
 
     try:
-        xyzi = np.fromfile(point_path, dtype="<f4").reshape((-1, 4))
-        packed_labels = np.fromfile(label_path, dtype="<u4")
-    except (OSError, ValueError) as exc:
+        xyzi = np.frombuffer(point_bytes, dtype="<f4").reshape((-1, 4))
+        packed_labels = np.frombuffer(label_bytes, dtype="<u4")
+    except ValueError as exc:
         raise DatasetFrameError("dataset frame cannot be decoded") from exc
     if not np.isfinite(xyzi).all():
         raise DatasetFrameError("dataset point frame contains non-finite values")
@@ -98,9 +116,31 @@ def read_semantic_kitti_frame(
     instance = np.ascontiguousarray(packed_labels >> np.uint32(16), dtype=np.uint16)
     for values in (points, remission, semantic, instance):
         values.setflags(write=False)
+    if points.shape[0] != point_count:
+        raise DatasetFrameError("decoded point count differs from the admitted size")
     return DatasetPointFrame(points, remission, semantic, instance)
 
 
+def _validate_semantic_kitti_sizes(
+    point_size: int,
+    label_size: int,
+    *,
+    maximum_points: int,
+) -> int:
+    if maximum_points <= 0:
+        raise DatasetFrameError("maximum_points must be positive")
+    if point_size == 0 or point_size % 16:
+        raise DatasetFrameError("point frame must contain little-endian float32 XYZI tuples")
+    if label_size % 4:
+        raise DatasetFrameError("label frame must contain packed little-endian uint32 values")
+    point_count = point_size // 16
+    if point_count > maximum_points:
+        raise DatasetFrameError("dataset point frame exceeds the configured safety limit")
+    if label_size // 4 != point_count:
+        raise DatasetFrameError("point and label counts do not match")
+    return point_count
+
+
 def _configured_dataset_root() -> Path | None:
     raw = os.environ.get(DATASET_ROOT_ENV, "").strip()
     return Path(raw).expanduser().absolute() if raw else None
diff --git a/src/k1link/datasets/goose_qualification.py b/src/k1link/datasets/goose_qualification.py
new file mode 100644
index 0000000..7adb951
--- /dev/null
+++ b/src/k1link/datasets/goose_qualification.py
@@ -0,0 +1,1153 @@
+"""Full-split, crash-resumable GOOSE ground-provider qualification.
+
+The source archive stays on the Simulation Worker D drive. Frames are streamed
+directly from ZIP members and only bounded evidence is published through the
+Polygon qualification-run journal.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import math
+import os
+import tempfile
+import time
+import zipfile
+from concurrent.futures import ProcessPoolExecutor, as_completed
+from dataclasses import asdict, dataclass
+from datetime import UTC, datetime
+from pathlib import Path, PurePosixPath
+from typing import Any, Final
+
+import numpy as np
+
+from k1link.datasets.gateway import DatasetPointFrame, decode_semantic_kitti_frame
+from k1link.datasets.goose_admission import (
+    GOOSE_ARCHIVE_FILENAME,
+    GOOSE_SOURCE_ID,
+    GooseAdmissionError,
+    read_goose_label_mapping,
+)
+from k1link.datasets.goose_benchmark import _ground_metrics
+from k1link.datasets.goose_profile import (
+    DEFAULT_GOOSE_PATCHWORK_PROFILE,
+    GoosePatchworkProfile,
+)
+from k1link.ground_segmentation import (
+    DEFAULT_GROUND_BENCHMARK_PROFILE,
+    PATCHWORKPP_SOURCE_COMMIT,
+    GroundBenchmarkProfile,
+    GroundSegmentation,
+    GroundSegmenter,
+    LocalPercentileGroundSegmenter,
+    PatchworkPPGroundSegmenter,
+)
+from k1link.simulation.contracts import (
+    AuthorityProfile,
+    ProviderPin,
+    QualificationArtifact,
+    QualificationRun,
+    ReproducibilityTier,
+    RunKind,
+    RunState,
+)
+from k1link.simulation.run_store import (
+    QualificationRunConflictError,
+    QualificationRunStore,
+)
+
+GOOSE_QUALIFICATION_PROFILE_SCHEMA: Final = "missioncore.goose-ground-qualification-profile/v1"
+GOOSE_QUALIFICATION_FRAME_SCHEMA: Final = "missioncore.goose-ground-qualification-frame/v1"
+GOOSE_QUALIFICATION_REPORT_SCHEMA: Final = "missioncore.goose-ground-qualification-report/v1"
+GOOSE_QUALIFICATION_PREVIEW_SCHEMA: Final = (
+    "missioncore.goose-ground-qualification-failure-preview/v1"
+)
+REPORT_ARTIFACT_KIND: Final = "goose-ground-qualification-report"
+FAILURE_ARTIFACT_KIND: Final = "goose-ground-qualification-failure-preview"
+MAX_FAILURE_PREVIEW_POINTS: Final = 12_000
+EXPECTED_VALIDATION_FRAMES: Final = 961
+DEFAULT_SEED: Final = 42
+_WORKER_PATCHWORK: GroundSegmenter | None = None
+
+
+@dataclass(frozen=True, slots=True)
+class GroundAcceptancePolicy:
+    """Predeclared gates for a shadow-only provider decision."""
+
+    minimum_ground_iou_gain: float = 0.07
+    minimum_natural_ground_recall_gain: float = 0.10
+    minimum_obstacle_non_ground_recall: float = 0.90
+    minimum_assigned_fraction: float = 0.999
+    maximum_patchwork_latency_p95_ms: float = 50.0
+    maximum_per_frame_iou_regression: float = 0.20
+    maximum_degraded_iou_loss: float = 0.15
+    maximum_degraded_natural_recall_loss: float = 0.20
+
+    def to_dict(self) -> dict[str, float]:
+        return asdict(self)
+
+
+@dataclass(frozen=True, slots=True)
+class DegradationProfile:
+    profile_id: str
+    kind: str
+    value: float
+
+    def to_dict(self) -> dict[str, str | float]:
+        return asdict(self)
+
+
+DEFAULT_DEGRADATIONS: Final[tuple[DegradationProfile, ...]] = (
+    DegradationProfile("range-20m", "maximum-range-m", 20.0),
+    DegradationProfile("range-40m", "maximum-range-m", 40.0),
+    DegradationProfile("density-50", "density-fraction", 0.50),
+    DegradationProfile("density-25", "density-fraction", 0.25),
+    DegradationProfile("noise-05m", "gaussian-xyz-sigma-m", 0.05),
+    DegradationProfile("dropout-30", "dropout-fraction", 0.30),
+    DegradationProfile("front-180", "horizontal-field-of-view-deg", 180.0),
+)
+DEFAULT_ACCEPTANCE_POLICY: Final = GroundAcceptancePolicy()
+
+
+def qualify_goose_ground(
+    dataset_root: Path,
+    runs_root: Path,
+    *,
+    mission_core_commit: str,
+    parallel_workers: int = 8,
+    expected_frame_count: int = EXPECTED_VALIDATION_FRAMES,
+    current_profile: GroundBenchmarkProfile = DEFAULT_GROUND_BENCHMARK_PROFILE,
+    patchwork_profile: GoosePatchworkProfile = DEFAULT_GOOSE_PATCHWORK_PROFILE,
+    acceptance: GroundAcceptancePolicy = DEFAULT_ACCEPTANCE_POLICY,
+    degradations: tuple[DegradationProfile, ...] = DEFAULT_DEGRADATIONS,
+    seed: int = DEFAULT_SEED,
+    patchwork_module_name: str = "pypatchworkpp",
+    current_segmenter: GroundSegmenter | None = None,
+    patchwork_segmenter: GroundSegmenter | None = None,
+) -> dict[str, Any]:
+    """Qualify Current vs Patchwork++ across the immutable validation split.
+
+    Custom segmenters are intentionally limited to the single-process path so
+    unit tests can exercise the complete orchestration contract without native
+    Patchwork++ bindings.
+    """
+
+    root = dataset_root.expanduser().absolute()
+    if not _is_worker_dataset_root(root):
+        raise GooseAdmissionError("GOOSE qualification requires the canonical worker D root")
+    if not 1 <= parallel_workers <= 32:
+        raise GooseAdmissionError("parallel worker count is outside the admitted range")
+    if expected_frame_count < 1:
+        raise GooseAdmissionError("expected frame count must be positive")
+    if (current_segmenter is not None or patchwork_segmenter is not None) and parallel_workers != 1:
+        raise GooseAdmissionError("custom ground providers require one qualification worker")
+
+    manifest_path = root / "state/goose-3d-v2025-08-22.json"
+    try:
+        manifest = json.loads(manifest_path.read_text(encoding="utf-8"))
+    except (OSError, UnicodeDecodeError, json.JSONDecodeError) as exc:
+        raise GooseAdmissionError("GOOSE admission manifest is unavailable") from exc
+    archive_sha256 = str(manifest.get("archive", {}).get("sha256", ""))
+    if len(archive_sha256) != 64:
+        raise GooseAdmissionError("GOOSE archive identity is invalid")
+    install_root = root / "goose-3d/v2025-08-22/installs" / archive_sha256
+    archive_path = root / "goose-3d/v2025-08-22/archives" / GOOSE_ARCHIVE_FILENAME
+    label_mapping = read_goose_label_mapping(install_root / "goose_label_mapping.csv")
+    frame_members = _validation_frame_members(archive_path)
+    if len(frame_members) != expected_frame_count:
+        raise GooseAdmissionError(
+            f"GOOSE validation split contains {len(frame_members)} frames, "
+            f"not the pinned {expected_frame_count}"
+        )
+
+    local = current_segmenter or LocalPercentileGroundSegmenter(current_profile)
+    candidate = patchwork_segmenter or PatchworkPPGroundSegmenter.load(
+        patchwork_profile,
+        module_name=patchwork_module_name,
+    )
+    provider_identities = {
+        "current": dict(local.identity),
+        "patchworkpp": dict(candidate.identity),
+    }
+    profile_document = {
+        "schema_version": GOOSE_QUALIFICATION_PROFILE_SCHEMA,
+        "source_id": GOOSE_SOURCE_ID,
+        "split": "validation",
+        "expected_frame_count": expected_frame_count,
+        "archive_sha256": archive_sha256,
+        "current_profile": current_profile.to_dict(),
+        "patchwork_profile": patchwork_profile.to_dict(),
+        "acceptance": acceptance.to_dict(),
+        "degradations": [profile.to_dict() for profile in degradations],
+        "seed": seed,
+        "reproducibility_tier": "R1",
+        "authority": {
+            "qualification_only": True,
+            "navigation_or_safety_accepted": False,
+        },
+    }
+    identity_document = {
+        "profile": profile_document,
+        "mission_core_commit": mission_core_commit,
+        "providers": provider_identities,
+    }
+    identity_sha256 = _canonical_sha256(identity_document)
+    run_id = f"goose-ground-{identity_sha256[:20]}"
+    work_root = install_root / "qualifications" / identity_sha256 / "working"
+    frame_cache_root = work_root / "frames"
+    frame_cache_root.mkdir(parents=True, exist_ok=True)
+    run_store = QualificationRunStore(runs_root)
+    run = _admit_or_resume_run(
+        run_store,
+        run_id=run_id,
+        identity_sha256=identity_sha256,
+        profile_document=profile_document,
+        mission_core_commit=mission_core_commit,
+        provider_identities=provider_identities,
+        seed=seed,
+    )
+    if run.state is RunState.COMPLETED:
+        return _read_completed_report(run_store, run)
+    run = _ensure_running(run_store, run)
+    _append_progress(
+        run_store,
+        run_id,
+        "qualification.profile-admitted",
+        {
+            "identity_sha256": identity_sha256,
+            "frames_total": len(frame_members),
+            "parallel_workers": parallel_workers,
+            "cache_resume": True,
+        },
+    )
+
+    cached: dict[str, dict[str, Any]] = {}
+    pending: list[tuple[str, str, str]] = []
+    for frame_id, point_member, label_member in frame_members:
+        cache_path = frame_cache_root / f"{frame_id}.json"
+        record = _read_cached_frame(cache_path, identity_sha256)
+        if record is None:
+            pending.append((frame_id, point_member, label_member))
+        else:
+            cached[frame_id] = record
+
+    common = (
+        str(archive_path),
+        label_mapping,
+        current_profile,
+        patchwork_profile,
+        degradations,
+        seed,
+        identity_sha256,
+        patchwork_module_name,
+    )
+    completed_since_event = 0
+    if pending and parallel_workers == 1:
+        for frame_id, point_member, label_member in pending:
+            record = _qualify_frame(
+                *common,
+                frame_id,
+                point_member,
+                label_member,
+                local,
+                candidate,
+            )
+            _write_json_once(frame_cache_root / f"{frame_id}.json", record)
+            cached[frame_id] = record
+            completed_since_event += 1
+            if completed_since_event >= 25 or len(cached) == len(frame_members):
+                _append_frame_progress(run_store, run_id, len(cached), len(frame_members))
+                completed_since_event = 0
+    elif pending:
+        with ProcessPoolExecutor(
+            max_workers=parallel_workers,
+            initializer=_initialize_patchwork_worker,
+            initargs=(patchwork_profile, patchwork_module_name),
+        ) as executor:
+            futures = {
+                executor.submit(
+                    _qualify_frame_worker,
+                    *common,
+                    frame_id,
+                    point_member,
+                    label_member,
+                ): frame_id
+                for frame_id, point_member, label_member in pending
+            }
+            for future in as_completed(futures):
+                frame_id = futures[future]
+                record = future.result()
+                _write_json_once(frame_cache_root / f"{frame_id}.json", record)
+                cached[frame_id] = record
+                completed_since_event += 1
+                if completed_since_event >= 25 or len(cached) == len(frame_members):
+                    _append_frame_progress(run_store, run_id, len(cached), len(frame_members))
+                    completed_since_event = 0
+
+    ordered_frames = [cached[frame_id] for frame_id, _, _ in frame_members]
+    report = _build_report(
+        identity_sha256=identity_sha256,
+        run_id=run_id,
+        profile=profile_document,
+        provider_identities=provider_identities,
+        frames=ordered_frames,
+        acceptance=acceptance,
+        degradations=degradations,
+    )
+    run_path = runs_root.expanduser().absolute() / run_id
+    evidence_root = run_path / "evidence"
+    evidence_root.mkdir(parents=True, exist_ok=True)
+    report_path = evidence_root / "qualification.json"
+    _write_json_once(report_path, report)
+    _register_file(
+        run_store,
+        run_id,
+        report_path,
+        run_path,
+        artifact_id="qualification-report",
+        kind=REPORT_ARTIFACT_KIND,
+    )
+
+    member_lookup = {frame_id: (point, label) for frame_id, point, label in frame_members}
+    for index, failure in enumerate(report["worst_frames"][:5], start=1):
+        frame_id = str(failure["frame_id"])
+        point_member, label_member = member_lookup[frame_id]
+        preview = _failure_preview(
+            archive_path,
+            frame_id,
+            point_member,
+            label_member,
+            label_mapping,
+            local,
+            candidate,
+        )
+        preview_path = evidence_root / "failures" / f"{frame_id}.json"
+        _write_json_once(preview_path, preview)
+        _register_file(
+            run_store,
+            run_id,
+            preview_path,
+            run_path,
+            artifact_id=f"failure-preview-{index:02d}",
+            kind=FAILURE_ARTIFACT_KIND,
+        )
+
+    _append_progress(
+        run_store,
+        run_id,
+        "qualification.decision-recorded",
+        {
+            "status": report["decision"]["status"],
+            "passed": report["decision"]["passed"],
+            "frames_completed": len(ordered_frames),
+        },
+    )
+    run = run_store.load(run_id)
+    run = run_store.transition(
+        run_id,
+        RunState.STOPPING,
+        expected_revision=run.revision,
+        observed_at_utc=_utc_now(),
+        host_monotonic_ns=time.monotonic_ns(),
+    )
+    run_store.transition(
+        run_id,
+        RunState.COMPLETED,
+        expected_revision=run.revision,
+        observed_at_utc=_utc_now(),
+        host_monotonic_ns=time.monotonic_ns(),
+        reason="qualification-evidence-sealed",
+    )
+    return report
+
+
+def _qualify_frame_worker(
+    archive_path: str,
+    label_mapping: dict[int, dict[str, Any]],
+    current_profile: GroundBenchmarkProfile,
+    patchwork_profile: GoosePatchworkProfile,
+    degradations: tuple[DegradationProfile, ...],
+    seed: int,
+    identity_sha256: str,
+    patchwork_module_name: str,
+    frame_id: str,
+    point_member: str,
+    label_member: str,
+) -> dict[str, Any]:
+    del patchwork_module_name
+    if _WORKER_PATCHWORK is None:
+        raise GooseAdmissionError("Patchwork++ worker was not initialized")
+    return _qualify_frame(
+        archive_path,
+        label_mapping,
+        current_profile,
+        patchwork_profile,
+        degradations,
+        seed,
+        identity_sha256,
+        "pypatchworkpp",
+        frame_id,
+        point_member,
+        label_member,
+        LocalPercentileGroundSegmenter(current_profile),
+        _WORKER_PATCHWORK,
+    )
+
+
+def _qualify_frame(
+    archive_path: str,
+    label_mapping: dict[int, dict[str, Any]],
+    current_profile: GroundBenchmarkProfile,
+    patchwork_profile: GoosePatchworkProfile,
+    degradations: tuple[DegradationProfile, ...],
+    seed: int,
+    identity_sha256: str,
+    patchwork_module_name: str,
+    frame_id: str,
+    point_member: str,
+    label_member: str,
+    current: GroundSegmenter,
+    patchwork: GroundSegmenter,
+) -> dict[str, Any]:
+    del current_profile, patchwork_profile, patchwork_module_name
+    frame = _read_archive_frame(Path(archive_path), point_member, label_member)
+    categories = _challenge_categories(frame, label_mapping)
+    evaluated = categories != 0
+    ground_truth = (categories == 2) | (categories == 3)
+    xyzi = np.column_stack((frame.points_xyz_m, frame.remission)).astype(
+        np.float32,
+        copy=False,
+    )
+    current_result = current.segment(xyzi)
+    patchwork_result = patchwork.segment(xyzi)
+    _validate_result(current_result, frame.point_count, "current")
+    _validate_result(patchwork_result, frame.point_count, "patchworkpp")
+    nominal = {
+        "current": _provider_frame_result(
+            current_result,
+            ground_truth,
+            evaluated,
+            categories,
+            frame.point_count,
+        ),
+        "patchworkpp": _provider_frame_result(
+            patchwork_result,
+            ground_truth,
+            evaluated,
+            categories,
+            frame.point_count,
+        ),
+    }
+    degraded: dict[str, Any] = {}
+    for profile in degradations:
+        derived_xyzi, source_indices = _degrade(xyzi, frame_id, profile, seed)
+        result = patchwork.segment(derived_xyzi)
+        _validate_result(result, derived_xyzi.shape[0], profile.profile_id)
+        degraded[profile.profile_id] = _provider_frame_result(
+            result,
+            ground_truth[source_indices],
+            evaluated[source_indices],
+            categories[source_indices],
+            frame.point_count,
+        )
+    return {
+        "schema_version": GOOSE_QUALIFICATION_FRAME_SCHEMA,
+        "identity_sha256": identity_sha256,
+        "frame_id": frame_id,
+        "source_point_count": frame.point_count,
+        "nominal": nominal,
+        "degradations": degraded,
+    }
+
+
+def _build_report(
+    *,
+    identity_sha256: str,
+    run_id: str,
+    profile: dict[str, Any],
+    provider_identities: dict[str, dict[str, object]],
+    frames: list[dict[str, Any]],
+    acceptance: GroundAcceptancePolicy,
+    degradations: tuple[DegradationProfile, ...],
+) -> dict[str, Any]:
+    current = _aggregate([frame["nominal"]["current"] for frame in frames])
+    patchwork = _aggregate([frame["nominal"]["patchworkpp"] for frame in frames])
+    degradation_results = {
+        degradation.profile_id: _aggregate(
+            [frame["degradations"][degradation.profile_id] for frame in frames]
+        )
+        for degradation in degradations
+    }
+    regressions = [
+        {
+            "frame_id": frame["frame_id"],
+            "current_ground_iou": frame["nominal"]["current"]["metrics"]["ground_iou"],
+            "patchwork_ground_iou": frame["nominal"]["patchworkpp"]["metrics"]["ground_iou"],
+            "ground_iou_delta": (
+                frame["nominal"]["patchworkpp"]["metrics"]["ground_iou"]
+                - frame["nominal"]["current"]["metrics"]["ground_iou"]
+            ),
+            "patchwork_natural_ground_recall": frame["nominal"]["patchworkpp"]["metrics"][
+                "natural_ground_recall"
+            ],
+        }
+        for frame in frames
+    ]
+    worst_frames = sorted(
+        regressions,
+        key=lambda item: (item["ground_iou_delta"], item["patchwork_ground_iou"]),
+    )[:20]
+    checks = [
+        _check(
+            "ground-iou-gain",
+            patchwork["micro"]["ground_iou"] - current["micro"]["ground_iou"],
+            acceptance.minimum_ground_iou_gain,
+            ">=",
+        ),
+        _check(
+            "natural-ground-recall-gain",
+            patchwork["micro"]["natural_ground_recall"] - current["micro"]["natural_ground_recall"],
+            acceptance.minimum_natural_ground_recall_gain,
+            ">=",
+        ),
+        _check(
+            "obstacle-non-ground-recall",
+            patchwork["micro"]["obstacle_non_ground_recall"],
+            acceptance.minimum_obstacle_non_ground_recall,
+            ">=",
+        ),
+        _check(
+            "assigned-fraction",
+            patchwork["assigned_fraction"],
+            acceptance.minimum_assigned_fraction,
+            ">=",
+        ),
+        _check(
+            "latency-p95-ms",
+            patchwork["latency_ms"]["p95"],
+            acceptance.maximum_patchwork_latency_p95_ms,
+            "<=",
+        ),
+        _check(
+            "catastrophic-regression-count",
+            sum(
+                1
+                for item in regressions
+                if item["ground_iou_delta"] < -acceptance.maximum_per_frame_iou_regression
+            ),
+            0,
+            "<=",
+        ),
+    ]
+    degradation_checks: list[dict[str, Any]] = []
+    for profile_id, aggregate in degradation_results.items():
+        degradation_checks.extend(
+            (
+                _check(
+                    f"{profile_id}:ground-iou-loss",
+                    patchwork["micro"]["ground_iou"] - aggregate["micro"]["ground_iou"],
+                    acceptance.maximum_degraded_iou_loss,
+                    "<=",
+                ),
+                _check(
+                    f"{profile_id}:natural-ground-recall-loss",
+                    patchwork["micro"]["natural_ground_recall"]
+                    - aggregate["micro"]["natural_ground_recall"],
+                    acceptance.maximum_degraded_natural_recall_loss,
+                    "<=",
+                ),
+                _check(
+                    f"{profile_id}:latency-p95-ms",
+                    aggregate["latency_ms"]["p95"],
+                    acceptance.maximum_patchwork_latency_p95_ms,
+                    "<=",
+                ),
+            )
+        )
+    all_checks = checks + degradation_checks
+    passed = all(bool(check["passed"]) for check in all_checks)
+    return {
+        "schema_version": GOOSE_QUALIFICATION_REPORT_SCHEMA,
+        "identity_sha256": identity_sha256,
+        "run_id": run_id,
+        "source_id": GOOSE_SOURCE_ID,
+        "split": "validation",
+        "frame_count": len(frames),
+        "profile": profile,
+        "providers": provider_identities,
+        "aggregates": {
+            "current": current,
+            "patchworkpp": patchwork,
+        },
+        "degradations": degradation_results,
+        "checks": all_checks,
+        "worst_frames": worst_frames,
+        "frames": frames,
+        "decision": {
+            "status": "shadow-candidate" if passed else "qualification-rejected",
+            "passed": passed,
+            "promoted_to_navigation_or_safety": False,
+            "reason": (
+                "all predeclared validation and degradation gates passed"
+                if passed
+                else "one or more predeclared gates failed"
+            ),
+        },
+        "safety": {
+            "qualification_only": True,
+            "actuator_authority": False,
+            "navigation_or_safety_accepted": False,
+        },
+    }
+
+
+def _aggregate(records: list[dict[str, Any]]) -> dict[str, Any]:
+    count_keys = (
+        "true_positive",
+        "false_positive",
+        "false_negative",
+        "true_negative",
+        "artificial_ground_true_positive",
+        "artificial_ground_count",
+        "natural_ground_true_positive",
+        "natural_ground_count",
+        "obstacle_non_ground_true_positive",
+        "obstacle_count",
+    )
+    counts = {key: sum(int(record["counts"][key]) for record in records) for key in count_keys}
+    tp = counts["true_positive"]
+    fp = counts["false_positive"]
+    fn = counts["false_negative"]
+    tn = counts["true_negative"]
+    micro = {
+        "precision": _ratio(tp, tp + fp),
+        "recall": _ratio(tp, tp + fn),
+        "f1": _ratio(2 * tp, 2 * tp + fp + fn),
+        "ground_iou": _ratio(tp, tp + fp + fn),
+        "accuracy": _ratio(tp + tn, tp + tn + fp + fn),
+        "artificial_ground_recall": _ratio(
+            counts["artificial_ground_true_positive"],
+            counts["artificial_ground_count"],
+        ),
+        "natural_ground_recall": _ratio(
+            counts["natural_ground_true_positive"],
+            counts["natural_ground_count"],
+        ),
+        "obstacle_non_ground_recall": _ratio(
+            counts["obstacle_non_ground_true_positive"],
+            counts["obstacle_count"],
+        ),
+    }
+    macro: dict[str, dict[str, float]] = {}
+    for key in (
+        "ground_iou",
+        "natural_ground_recall",
+        "obstacle_non_ground_recall",
+    ):
+        values = np.asarray([record["metrics"][key] for record in records], dtype=np.float64)
+        macro[key] = {
+            "mean": float(np.mean(values)),
+            "p50": float(np.percentile(values, 50)),
+            "p05": float(np.percentile(values, 5)),
+            "minimum": float(np.min(values)),
+        }
+    latency = np.asarray([record["latency_ms"] for record in records], dtype=np.float64)
+    total_source_points = sum(int(record["source_point_count"]) for record in records)
+    return {
+        "micro": micro,
+        "macro": macro,
+        "latency_ms": {
+            "p50": float(np.percentile(latency, 50)),
+            "p95": float(np.percentile(latency, 95)),
+            "maximum": float(np.max(latency)),
+        },
+        "assigned_fraction": _ratio(
+            sum(int(record["assigned_point_count"]) for record in records),
+            sum(int(record["retained_point_count"]) for record in records),
+        ),
+        "source_coverage": _ratio(
+            sum(int(record["retained_point_count"]) for record in records),
+            total_source_points,
+        ),
+        "frame_count": len(records),
+        "counts": counts,
+    }
+
+
+def _provider_frame_result(
+    result: GroundSegmentation,
+    ground_truth: np.ndarray[Any, Any],
+    evaluated: np.ndarray[Any, Any],
+    categories: np.ndarray[Any, Any],
+    source_point_count: int,
+) -> dict[str, Any]:
+    assigned_evaluated = evaluated & result.assigned_mask
+    metrics = _ground_metrics(
+        result.ground_mask,
+        ground_truth,
+        assigned_evaluated,
+        categories,
+    )
+    counts = {
+        key: int(metrics[key])
+        for key in ("true_positive", "false_positive", "false_negative", "true_negative")
+    }
+    counts.update(
+        {
+            "artificial_ground_true_positive": int(
+                np.count_nonzero(result.ground_mask & (categories == 2))
+            ),
+            "artificial_ground_count": int(np.count_nonzero(categories == 2)),
+            "natural_ground_true_positive": int(
+                np.count_nonzero(result.ground_mask & (categories == 3))
+            ),
+            "natural_ground_count": int(np.count_nonzero(categories == 3)),
+            "obstacle_non_ground_true_positive": int(
+                np.count_nonzero(~result.ground_mask & (categories == 4))
+            ),
+            "obstacle_count": int(np.count_nonzero(categories == 4)),
+        }
+    )
+    return {
+        "metrics": metrics,
+        "counts": counts,
+        "latency_ms": float(result.latency_ms),
+        "source_point_count": source_point_count,
+        "retained_point_count": int(result.ground_mask.shape[0]),
+        "assigned_point_count": int(np.count_nonzero(result.assigned_mask)),
+        "assigned_fraction": float(np.mean(result.assigned_mask)),
+    }
+
+
+def _degrade(
+    xyzi: np.ndarray[Any, Any],
+    frame_id: str,
+    profile: DegradationProfile,
+    seed: int,
+) -> tuple[np.ndarray[Any, Any], np.ndarray[Any, Any]]:
+    point_count = xyzi.shape[0]
+    indices = np.arange(point_count, dtype=np.int64)
+    radial = np.linalg.norm(xyzi[:, :3], axis=1)
+    if profile.kind == "maximum-range-m":
+        indices = indices[radial <= profile.value]
+    elif profile.kind in {"density-fraction", "dropout-fraction"}:
+        fraction = profile.value if profile.kind == "density-fraction" else 1.0 - profile.value
+        keep = max(1, int(math.floor(point_count * fraction)))
+        rng = np.random.default_rng(_frame_seed(frame_id, profile.profile_id, seed))
+        indices = np.sort(rng.choice(indices, size=keep, replace=False))
+    elif profile.kind == "horizontal-field-of-view-deg":
+        half_angle = math.radians(profile.value / 2)
+        angles = np.arctan2(xyzi[:, 1], xyzi[:, 0])
+        indices = indices[np.abs(angles) <= half_angle]
+    elif profile.kind != "gaussian-xyz-sigma-m":
+        raise GooseAdmissionError("unknown GOOSE degradation profile")
+    derived = np.ascontiguousarray(xyzi[indices], dtype=np.float32)
+    if profile.kind == "gaussian-xyz-sigma-m":
+        rng = np.random.default_rng(_frame_seed(frame_id, profile.profile_id, seed))
+        derived[:, :3] += rng.normal(0.0, profile.value, derived[:, :3].shape).astype(np.float32)
+    return derived, indices
+
+
+def _failure_preview(
+    archive_path: Path,
+    frame_id: str,
+    point_member: str,
+    label_member: str,
+    label_mapping: dict[int, dict[str, Any]],
+    current: GroundSegmenter,
+    patchwork: GroundSegmenter,
+) -> dict[str, Any]:
+    frame = _read_archive_frame(archive_path, point_member, label_member)
+    categories = _challenge_categories(frame, label_mapping)
+    ground_truth = (categories == 2) | (categories == 3)
+    evaluated = categories != 0
+    xyzi = np.column_stack((frame.points_xyz_m, frame.remission)).astype(
+        np.float32,
+        copy=False,
+    )
+    current_result = current.segment(xyzi)
+    patchwork_result = patchwork.segment(xyzi)
+    sample_count = min(frame.point_count, MAX_FAILURE_PREVIEW_POINTS)
+    indices = np.linspace(0, frame.point_count - 1, sample_count, dtype=np.int64)
+    return {
+        "schema_version": GOOSE_QUALIFICATION_PREVIEW_SCHEMA,
+        "source_id": GOOSE_SOURCE_ID,
+        "frame_id": frame_id,
+        "source_point_count": frame.point_count,
+        "point_count": sample_count,
+        "sampling": "deterministic-even-index",
+        "points_xyz_m": frame.points_xyz_m[indices].tolist(),
+        "ground_truth_ground": ground_truth[indices].astype(np.uint8).tolist(),
+        "evaluated": evaluated[indices].astype(np.uint8).tolist(),
+        "current_ground": current_result.ground_mask[indices].astype(np.uint8).tolist(),
+        "patchwork_ground": patchwork_result.ground_mask[indices].astype(np.uint8).tolist(),
+        "current_disagreement": (
+            evaluated[indices] & (current_result.ground_mask[indices] != ground_truth[indices])
+        )
+        .astype(np.uint8)
+        .tolist(),
+        "patchwork_disagreement": (
+            evaluated[indices] & (patchwork_result.ground_mask[indices] != ground_truth[indices])
+        )
+        .astype(np.uint8)
+        .tolist(),
+        "safety": {
+            "visualization_only": True,
+            "navigation_or_safety_accepted": False,
+        },
+    }
+
+
+def _validation_frame_members(archive_path: Path) -> list[tuple[str, str, str]]:
+    try:
+        with zipfile.ZipFile(archive_path) as source:
+            points = {
+                _frame_id(member.filename, "_vls128.bin"): member.filename
+                for member in source.infolist()
+                if not member.is_dir()
+                and "/lidar/val/" in "/" + member.filename.replace("\\", "/")
+                and member.filename.endswith("_vls128.bin")
+            }
+            labels = {
+                _frame_id(member.filename, "_goose.label"): member.filename
+                for member in source.infolist()
+                if not member.is_dir()
+                and "/labels/val/" in "/" + member.filename.replace("\\", "/")
+                and member.filename.endswith("_goose.label")
+            }
+    except (OSError, zipfile.BadZipFile) as exc:
+        raise GooseAdmissionError("GOOSE archive cannot be indexed") from exc
+    if len(points) != len(labels) or points.keys() != labels.keys():
+        raise GooseAdmissionError("GOOSE validation point and label members are not aligned")
+    return [(frame_id, points[frame_id], labels[frame_id]) for frame_id in sorted(points)]
+
+
+def _read_archive_frame(
+    archive_path: Path,
+    point_member: str,
+    label_member: str,
+) -> DatasetPointFrame:
+    try:
+        with zipfile.ZipFile(archive_path) as source:
+            return decode_semantic_kitti_frame(
+                source.read(point_member),
+                source.read(label_member),
+            )
+    except (OSError, KeyError, zipfile.BadZipFile) as exc:
+        raise GooseAdmissionError("GOOSE frame cannot be streamed from the archive") from exc
+
+
+def _challenge_categories(
+    frame: DatasetPointFrame,
+    labels: dict[int, dict[str, Any]],
+) -> np.ndarray[Any, Any]:
+    try:
+        return np.asarray(
+            [labels[int(value)]["challenge_category_id"] for value in frame.semantic_labels],
+            dtype=np.uint8,
+        )
+    except KeyError as exc:
+        raise GooseAdmissionError("GOOSE frame contains an unmapped semantic label") from exc
+
+
+def _initialize_patchwork_worker(
+    profile: GoosePatchworkProfile,
+    module_name: str,
+) -> None:
+    global _WORKER_PATCHWORK
+    _WORKER_PATCHWORK = PatchworkPPGroundSegmenter.load(profile, module_name=module_name)
+
+
+def _admit_or_resume_run(
+    store: QualificationRunStore,
+    *,
+    run_id: str,
+    identity_sha256: str,
+    profile_document: dict[str, Any],
+    mission_core_commit: str,
+    provider_identities: dict[str, dict[str, object]],
+    seed: int,
+) -> QualificationRun:
+    scenario = {
+        "source_id": GOOSE_SOURCE_ID,
+        "split": "validation",
+        "clock": "dataset-frame-index",
+    }
+    patchwork_digest = provider_identities["patchworkpp"].get("binary_sha256")
+    run = QualificationRun(
+        run_id=run_id,
+        episode_id=f"episode-{identity_sha256[:20]}",
+        kind=RunKind.REPLAY_SHADOW,
+        state=RunState.ADMITTED,
+        scenario_generation="goose-3d-validation-v2025-08-22",
+        scenario_sha256=_canonical_sha256(scenario),
+        profile_generation="goose-ground-current-vs-patchworkpp-v1",
+        profile_sha256=_canonical_sha256(profile_document),
+        mission_core_commit=mission_core_commit,
+        providers=(
+            ProviderPin(
+                identifier="missioncore-local-percentile-ground",
+                version="v1",
+                revision=mission_core_commit,
+            ),
+            ProviderPin(
+                identifier="patchworkpp",
+                version="v1.4.1",
+                revision=PATCHWORKPP_SOURCE_COMMIT,
+                digest=str(patchwork_digest) if patchwork_digest is not None else None,
+            ),
+        ),
+        host_profile_id="simulation-worker-goose-ground-v1",
+        host_profile_sha256=_canonical_sha256(
+            {
+                "role": "simulation-worker",
+                "storage": "worker-d-only",
+                "parallelism": "process-pool",
+            }
+        ),
+        seed=seed,
+        reproducibility_tier=ReproducibilityTier.R1,
+        authority=AuthorityProfile(
+            generation=1,
+            command_ttl_max_ns=1,
+            heartbeat_timeout_monotonic_ns=1,
+        ),
+        clock_domain="dataset:frame-index",
+        created_at_utc=_utc_now(),
+    )
+    try:
+        return store.create(run)
+    except QualificationRunConflictError as exc:
+        existing = store.load(run_id)
+        if (
+            existing.profile_sha256 != run.profile_sha256
+            or existing.scenario_sha256 != run.scenario_sha256
+            or existing.mission_core_commit != mission_core_commit
+        ):
+            raise GooseAdmissionError("existing qualification run has another identity") from exc
+        return existing
+
+
+def _ensure_running(store: QualificationRunStore, run: QualificationRun) -> QualificationRun:
+    if run.state is RunState.ADMITTED:
+        run = store.transition(
+            run.run_id,
+            RunState.STARTING,
+            expected_revision=run.revision,
+            observed_at_utc=_utc_now(),
+            host_monotonic_ns=time.monotonic_ns(),
+        )
+    if run.state is RunState.STARTING:
+        run = store.transition(
+            run.run_id,
+            RunState.RUNNING,
+            expected_revision=run.revision,
+            observed_at_utc=_utc_now(),
+            host_monotonic_ns=time.monotonic_ns(),
+        )
+    if run.state is not RunState.RUNNING:
+        raise GooseAdmissionError(
+            "qualification run cannot resume from its current lifecycle state"
+        )
+    return run
+
+
+def _read_completed_report(
+    store: QualificationRunStore,
+    run: QualificationRun,
+) -> dict[str, Any]:
+    artifact = next(
+        (artifact for artifact in run.artifacts if artifact.kind == REPORT_ARTIFACT_KIND),
+        None,
+    )
+    if artifact is None:
+        raise GooseAdmissionError("completed qualification run has no report artifact")
+    path = store.root / run.run_id / artifact.relative_path
+    if _sha256_file(path) != artifact.sha256:
+        raise GooseAdmissionError("completed qualification report digest differs")
+    try:
+        value = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, UnicodeDecodeError, json.JSONDecodeError) as exc:
+        raise GooseAdmissionError("completed qualification report is invalid") from exc
+    if not isinstance(value, dict):
+        raise GooseAdmissionError("completed qualification report must be an object")
+    return value
+
+
+def _register_file(
+    store: QualificationRunStore,
+    run_id: str,
+    path: Path,
+    run_path: Path,
+    *,
+    artifact_id: str,
+    kind: str,
+) -> None:
+    try:
+        relative_path = path.relative_to(run_path).as_posix()
+    except ValueError as exc:
+        raise GooseAdmissionError("qualification artifact escaped its run root") from exc
+    digest = _sha256_file(path)
+    size = path.stat().st_size
+    current = store.load(run_id)
+    existing = next(
+        (artifact for artifact in current.artifacts if artifact.artifact_id == artifact_id),
+        None,
+    )
+    if existing is not None:
+        if (
+            existing.kind != kind
+            or existing.relative_path != relative_path
+            or existing.sha256 != digest
+            or existing.byte_length != size
+        ):
+            raise GooseAdmissionError("registered qualification artifact changed on resume")
+        return
+    store.register_artifact(
+        run_id,
+        QualificationArtifact(
+            artifact_id=artifact_id,
+            kind=kind,
+            relative_path=relative_path,
+            sha256=digest,
+            byte_length=size,
+            source_of_record=True,
+        ),
+    )
+
+
+def _append_frame_progress(
+    store: QualificationRunStore,
+    run_id: str,
+    completed: int,
+    total: int,
+) -> None:
+    _append_progress(
+        store,
+        run_id,
+        "qualification.frames-progress",
+        {
+            "completed": completed,
+            "total": total,
+            "fraction": completed / total,
+        },
+    )
+
+
+def _append_progress(
+    store: QualificationRunStore,
+    run_id: str,
+    event_type: str,
+    payload: dict[str, Any],
+) -> None:
+    store.append_event(
+        run_id,
+        event_type=event_type,
+        observed_at_utc=_utc_now(),
+        host_monotonic_ns=time.monotonic_ns(),
+        payload=payload,
+    )
+
+
+def _read_cached_frame(path: Path, identity_sha256: str) -> dict[str, Any] | None:
+    if not path.is_file():
+        return None
+    try:
+        value = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, UnicodeDecodeError, json.JSONDecodeError):
+        return None
+    if (
+        not isinstance(value, dict)
+        or value.get("schema_version") != GOOSE_QUALIFICATION_FRAME_SCHEMA
+        or value.get("identity_sha256") != identity_sha256
+    ):
+        return None
+    return value
+
+
+def _check(
+    name: str,
+    observed: float | int,
+    threshold: float | int,
+    operator: str,
+) -> dict[str, Any]:
+    passed = observed >= threshold if operator == ">=" else observed <= threshold
+    return {
+        "check_id": name,
+        "observed": float(observed),
+        "operator": operator,
+        "threshold": float(threshold),
+        "passed": bool(passed),
+    }
+
+
+def _validate_result(result: GroundSegmentation, point_count: int, label: str) -> None:
+    if (
+        result.ground_mask.shape != (point_count,)
+        or result.assigned_mask.shape != (point_count,)
+        or not math.isfinite(result.latency_ms)
+        or result.latency_ms < 0
+    ):
+        raise GooseAdmissionError(f"{label} ground result violates point alignment")
+
+
+def _frame_seed(frame_id: str, profile_id: str, seed: int) -> int:
+    digest = hashlib.sha256(f"{seed}:{frame_id}:{profile_id}".encode()).digest()
+    return int.from_bytes(digest[:8], "little")
+
+
+def _frame_id(filename: str, suffix: str) -> str:
+    name = PurePosixPath(filename.replace("\\", "/")).name
+    if not name.endswith(suffix) or len(name) <= len(suffix):
+        raise GooseAdmissionError("GOOSE validation member has an invalid frame identity")
+    return name[: -len(suffix)]
+
+
+def _is_worker_dataset_root(root: Path) -> bool:
+    return str(root).replace("\\", "/").rstrip("/").lower() == ("/mnt/d/ndc_missioncore/datasets")
+
+
+def _ratio(numerator: int | float, denominator: int | float) -> float:
+    return float(numerator / denominator) if denominator else 0.0
+
+
+def _canonical_sha256(value: dict[str, Any]) -> str:
+    return hashlib.sha256(
+        json.dumps(value, sort_keys=True, separators=(",", ":")).encode()
+    ).hexdigest()
+
+
+def _sha256_file(path: Path) -> str:
+    digest = hashlib.sha256()
+    try:
+        with path.open("rb") as source:
+            for chunk in iter(lambda: source.read(1024**2), b""):
+                digest.update(chunk)
+    except OSError as exc:
+        raise GooseAdmissionError("qualification artifact cannot be hashed") from exc
+    return digest.hexdigest()
+
+
+def _write_json_once(path: Path, value: dict[str, Any]) -> None:
+    encoded = json.dumps(value, sort_keys=True, separators=(",", ":")).encode() + b"\n"
+    if path.exists():
+        try:
+            if path.is_file() and path.read_bytes() == encoded:
+                return
+        except OSError as exc:
+            raise GooseAdmissionError(
+                "immutable qualification artifact cannot be verified"
+            ) from exc
+        raise GooseAdmissionError("immutable qualification artifact already exists")
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with tempfile.NamedTemporaryFile(dir=path.parent, delete=False) as temporary:
+        temporary_path = Path(temporary.name)
+        temporary.write(encoded)
+        temporary.flush()
+        os.fsync(temporary.fileno())
+    os.replace(temporary_path, path)
+
+
+def _utc_now() -> str:
+    return datetime.now(UTC).isoformat(timespec="milliseconds").replace("+00:00", "Z")
diff --git a/src/k1link/web/app.py b/src/k1link/web/app.py
index 2462b3d..624f66c 100644
--- a/src/k1link/web/app.py
+++ b/src/k1link/web/app.py
@@ -44,7 +44,7 @@ from k1link.web.plugin_runtime import (
     PluginNotFoundError,
     PluginRuntimeUnavailableError,
 )
-from k1link.web.polygon_api import build_polygon_router
+from k1link.web.polygon_api import build_polygon_router, configured_polygon_runs_root
 from k1link.web.session_api import build_session_router
 
 REPOSITORY_ROOT = Path(__file__).resolve().parents[3]
@@ -398,7 +398,12 @@ app.include_router(
         point_color_renderers=plugin_environment.point_color_renderers,
     )
 )
-app.include_router(build_polygon_router())
+app.include_router(
+    build_polygon_router(
+        root_provider=lambda: configured_polygon_runs_root()
+        or REPOSITORY_ROOT / ".runtime" / "polygon-runs"
+    )
+)
 app.include_router(
     build_lidar_router(
         root_provider=lambda: (
diff --git a/src/k1link/web/polygon_api.py b/src/k1link/web/polygon_api.py
index e138731..948bc35 100644
--- a/src/k1link/web/polygon_api.py
+++ b/src/k1link/web/polygon_api.py
@@ -1,5 +1,7 @@
 from __future__ import annotations
 
+import hashlib
+import json
 import os
 import re
 import secrets
@@ -33,6 +35,13 @@ POLYGON_WORKER_CONTROL_ENV: Final = "MISSIONCORE_POLYGON_WORKER_CONTROL"
 MISSION_CORE_COMMIT_ENV: Final = "MISSIONCORE_COMMIT"
 CATALOG_SCHEMA: Final = "missioncore.polygon-run-catalog/v1"
 DETAIL_SCHEMA: Final = "missioncore.polygon-run-detail/v1"
+GROUND_QUALIFICATION_SCHEMA: Final = "missioncore.polygon-ground-qualification/v1"
+GROUND_FAILURE_PREVIEW_SCHEMA: Final = "missioncore.polygon-ground-failure-preview/v1"
+GROUND_REPORT_ARTIFACT_KIND: Final = "goose-ground-qualification-report"
+GROUND_FAILURE_ARTIFACT_KIND: Final = "goose-ground-qualification-failure-preview"
+GROUND_REPORT_SCHEMA: Final = "missioncore.goose-ground-qualification-report/v1"
+GROUND_FAILURE_SCHEMA: Final = "missioncore.goose-ground-qualification-failure-preview/v1"
+MAX_QUALIFICATION_ARTIFACT_BYTES: Final = 32 * 1024**2
 COMMIT_PATTERN: Final = re.compile(r"^[a-f0-9]{40}$")
 READ_ONLY_LIMITATIONS: Final[tuple[str, ...]] = (
     "Архивный UI-0 публикует только квалификационные доказательства; "
@@ -165,6 +174,90 @@ def build_polygon_router(
             "limitations": list(READ_ONLY_LIMITATIONS),
         }
 
+    @router.get("/runs/{run_id}/qualification")
+    def get_polygon_ground_qualification(
+        run_id: Annotated[
+            str,
+            PathParameter(pattern=r"^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$"),
+        ],
+    ) -> dict[str, Any]:
+        store, run = _load_run(root_provider, run_id)
+        report = _read_registered_json(
+            store,
+            run,
+            artifact_kind=GROUND_REPORT_ARTIFACT_KIND,
+            expected_schema=GROUND_REPORT_SCHEMA,
+        )
+        required = (
+            "identity_sha256",
+            "source_id",
+            "split",
+            "frame_count",
+            "aggregates",
+            "degradations",
+            "checks",
+            "worst_frames",
+            "decision",
+            "safety",
+        )
+        if any(key not in report for key in required):
+            raise HTTPException(
+                status_code=500,
+                detail="Отчёт квалификации имеет неполный контракт.",
+            )
+        return {
+            "schema_version": GROUND_QUALIFICATION_SCHEMA,
+            "access": "read-only",
+            "run_id": run.run_id,
+            **{key: report[key] for key in required},
+        }
+
+    @router.get("/runs/{run_id}/qualification/failures/{frame_id}")
+    def get_polygon_ground_failure_preview(
+        run_id: Annotated[
+            str,
+            PathParameter(pattern=r"^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$"),
+        ],
+        frame_id: Annotated[
+            str,
+            PathParameter(pattern=r"^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$"),
+        ],
+    ) -> dict[str, Any]:
+        store, run = _load_run(root_provider, run_id)
+        preview = _read_registered_json(
+            store,
+            run,
+            artifact_kind=GROUND_FAILURE_ARTIFACT_KIND,
+            expected_schema=GROUND_FAILURE_SCHEMA,
+            frame_id=frame_id,
+        )
+        required = (
+            "source_id",
+            "frame_id",
+            "source_point_count",
+            "point_count",
+            "sampling",
+            "points_xyz_m",
+            "ground_truth_ground",
+            "evaluated",
+            "current_ground",
+            "patchwork_ground",
+            "current_disagreement",
+            "patchwork_disagreement",
+            "safety",
+        )
+        if any(key not in preview for key in required) or preview["frame_id"] != frame_id:
+            raise HTTPException(
+                status_code=500,
+                detail="Preview проблемного кадра имеет неполный контракт.",
+            )
+        return {
+            "schema_version": GROUND_FAILURE_PREVIEW_SCHEMA,
+            "access": "read-only",
+            "run_id": run.run_id,
+            **{key: preview[key] for key in required},
+        }
+
     @router.get("/worker")
     def get_polygon_worker() -> dict[str, Any]:
         gateway = worker_provider()
@@ -315,6 +408,83 @@ def _open_read_only_store(root_provider: RootProvider) -> QualificationRunStore:
         ) from exc
 
 
+def _load_run(
+    root_provider: RootProvider,
+    run_id: str,
+) -> tuple[QualificationRunStore, QualificationRun]:
+    store = _open_read_only_store(root_provider)
+    try:
+        return store, store.load(run_id)
+    except QualificationRunNotFoundError as exc:
+        raise HTTPException(status_code=404, detail="Прогон Полигона не найден.") from exc
+    except QualificationRunIntegrityError as exc:
+        raise HTTPException(
+            status_code=500,
+            detail="Доказательства прогона не прошли проверку целостности.",
+        ) from exc
+
+
+def _read_registered_json(
+    store: QualificationRunStore,
+    run: QualificationRun,
+    *,
+    artifact_kind: str,
+    expected_schema: str,
+    frame_id: str | None = None,
+) -> dict[str, Any]:
+    candidates = [artifact for artifact in run.artifacts if artifact.kind == artifact_kind]
+    if frame_id is not None:
+        candidates = [
+            artifact for artifact in candidates if Path(artifact.relative_path).stem == frame_id
+        ]
+    if len(candidates) != 1:
+        raise HTTPException(
+            status_code=404,
+            detail="Квалификационный артефакт для этого прогона не найден.",
+        )
+    artifact = candidates[0]
+    if artifact.byte_length > MAX_QUALIFICATION_ARTIFACT_BYTES:
+        raise HTTPException(status_code=500, detail="Квалификационный артефакт слишком велик.")
+    run_root = (store.root / run.run_id).resolve()
+    path = run_root / artifact.relative_path
+    try:
+        resolved = path.resolve(strict=True)
+        resolved.relative_to(run_root)
+    except (OSError, ValueError) as exc:
+        raise HTTPException(
+            status_code=500,
+            detail="Путь квалификационного артефакта нарушает границу прогона.",
+        ) from exc
+    if (
+        path.is_symlink()
+        or not resolved.is_file()
+        or resolved.stat().st_size != artifact.byte_length
+    ):
+        raise HTTPException(
+            status_code=500,
+            detail="Квалификационный артефакт не прошёл проверку файла.",
+        )
+    digest = hashlib.sha256(resolved.read_bytes()).hexdigest()
+    if digest != artifact.sha256:
+        raise HTTPException(
+            status_code=500,
+            detail="Квалификационный артефакт не прошёл проверку SHA-256.",
+        )
+    try:
+        value = json.loads(resolved.read_text(encoding="utf-8"))
+    except (OSError, UnicodeDecodeError, json.JSONDecodeError) as exc:
+        raise HTTPException(
+            status_code=500,
+            detail="Квалификационный артефакт не является допустимым JSON.",
+        ) from exc
+    if not isinstance(value, dict) or value.get("schema_version") != expected_schema:
+        raise HTTPException(
+            status_code=500,
+            detail="Квалификационный артефакт имеет неизвестную схему.",
+        )
+    return value
+
+
 def _run_summary(run: QualificationRun) -> dict[str, Any]:
     return {
         "run_id": run.run_id,
diff --git a/tests/test_goose_qualification.py b/tests/test_goose_qualification.py
new file mode 100644
index 0000000..ea26cdf
--- /dev/null
+++ b/tests/test_goose_qualification.py
@@ -0,0 +1,128 @@
+from __future__ import annotations
+
+import json
+import struct
+import zipfile
+from collections.abc import Mapping
+from pathlib import Path
+
+import numpy as np
+import numpy.typing as npt
+import pytest
+
+from k1link.datasets import goose_qualification
+from k1link.datasets.goose_qualification import (
+    DegradationProfile,
+    qualify_goose_ground,
+)
+from k1link.ground_segmentation import GroundSegmentation
+from k1link.simulation import QualificationRunStore, RunState
+
+
+class _NeverGround:
+    @property
+    def identity(self) -> Mapping[str, object]:
+        return {"provider_id": "test-current", "revision": "1"}
+
+    def segment(self, xyzi: npt.NDArray[np.float32]) -> GroundSegmentation:
+        count = xyzi.shape[0]
+        return GroundSegmentation(
+            ground_mask=np.zeros(count, dtype=np.bool_),
+            assigned_mask=np.ones(count, dtype=np.bool_),
+            latency_ms=2.0,
+        )
+
+
+class _NegativeZGround:
+    @property
+    def identity(self) -> Mapping[str, object]:
+        return {"provider_id": "test-patchwork", "revision": "1"}
+
+    def segment(self, xyzi: npt.NDArray[np.float32]) -> GroundSegmentation:
+        count = xyzi.shape[0]
+        return GroundSegmentation(
+            ground_mask=np.asarray(xyzi[:, 2] < 0, dtype=np.bool_),
+            assigned_mask=np.ones(count, dtype=np.bool_),
+            latency_ms=3.0,
+        )
+
+
+def _frame_bytes(offset: float) -> tuple[bytes, bytes]:
+    points = (
+        (-1.0 + offset, 0.0, -2.0, 0.1),
+        (0.0 + offset, 0.0, -2.0, 0.2),
+        (1.0 + offset, 0.0, 2.0, 0.3),
+        (2.0 + offset, 0.0, 2.0, 0.4),
+    )
+    labels = (1, 3, 2, 2)
+    return (
+        b"".join(struct.pack("<ffff", *point) for point in points),
+        b"".join(struct.pack("<I", label) for label in labels),
+    )
+
+
+def _dataset(tmp_path: Path) -> Path:
+    root = tmp_path / "datasets"
+    archive_sha = "a" * 64
+    archive = root / "goose-3d/v2025-08-22/archives/goose_3d_val.zip"
+    archive.parent.mkdir(parents=True)
+    with zipfile.ZipFile(archive, "w") as target:
+        for index in range(2):
+            frame_id = f"2022-01-01_flight__0001_{index:019d}"
+            points, labels = _frame_bytes(index * 0.1)
+            target.writestr(f"goose/lidar/val/{frame_id}_vls128.bin", points)
+            target.writestr(f"goose/labels/val/{frame_id}_goose.label", labels)
+    state = root / "state/goose-3d-v2025-08-22.json"
+    state.parent.mkdir(parents=True)
+    state.write_text(json.dumps({"archive": {"sha256": archive_sha}}), encoding="utf-8")
+    install = root / "goose-3d/v2025-08-22/installs" / archive_sha
+    install.mkdir(parents=True)
+    (install / "goose_label_mapping.csv").write_text(
+        "class_name,label_key,hex\nasphalt,1,#111111\nrock,2,#222222\nsoil,3,#333333\n",
+        encoding="utf-8",
+    )
+    return root
+
+
+def test_full_split_qualification_is_sealed_and_resumable(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    root = _dataset(tmp_path)
+    runs_root = tmp_path / "runs"
+    monkeypatch.setattr(goose_qualification, "_is_worker_dataset_root", lambda _: True)
+
+    report = qualify_goose_ground(
+        root,
+        runs_root,
+        mission_core_commit="1" * 40,
+        parallel_workers=1,
+        expected_frame_count=2,
+        current_segmenter=_NeverGround(),
+        patchwork_segmenter=_NegativeZGround(),
+        degradations=(DegradationProfile("range-20m", "maximum-range-m", 20.0),),
+    )
+
+    assert report["frame_count"] == 2
+    assert report["decision"]["status"] == "shadow-candidate"
+    assert report["aggregates"]["current"]["micro"]["ground_iou"] == 0
+    assert report["aggregates"]["patchworkpp"]["micro"]["ground_iou"] == 1
+    assert len(report["frames"]) == 2
+    run = QualificationRunStore(runs_root, read_only=True).load(report["run_id"])
+    assert run.state is RunState.COMPLETED
+    assert {artifact.kind for artifact in run.artifacts} == {
+        "goose-ground-qualification-report",
+        "goose-ground-qualification-failure-preview",
+    }
+
+    resumed = qualify_goose_ground(
+        root,
+        runs_root,
+        mission_core_commit="1" * 40,
+        parallel_workers=1,
+        expected_frame_count=2,
+        current_segmenter=_NeverGround(),
+        patchwork_segmenter=_NegativeZGround(),
+        degradations=(DegradationProfile("range-20m", "maximum-range-m", 20.0),),
+    )
+    assert resumed["identity_sha256"] == report["identity_sha256"]
diff --git a/tests/test_polygon_api.py b/tests/test_polygon_api.py
index d710331..2875ae4 100644
--- a/tests/test_polygon_api.py
+++ b/tests/test_polygon_api.py
@@ -1,5 +1,7 @@
 from __future__ import annotations
 
+import hashlib
+import json
 from collections.abc import Callable
 from pathlib import Path
 from typing import Any
@@ -191,6 +193,146 @@ def test_polygon_api_rejects_corrupt_evidence_without_partial_response(
     assert "целостности" in failure.value.detail
 
 
+def _qualification_run(root: Path) -> tuple[QualificationRun, str]:
+    store = QualificationRunStore(root)
+    admitted = store.create(_run("goose-ground-test"))
+    starting = store.transition(
+        admitted.run_id,
+        RunState.STARTING,
+        expected_revision=0,
+        observed_at_utc="2026-07-24T15:35:01Z",
+        host_monotonic_ns=1,
+    )
+    store.transition(
+        admitted.run_id,
+        RunState.RUNNING,
+        expected_revision=starting.revision,
+        observed_at_utc="2026-07-24T15:35:02Z",
+        host_monotonic_ns=2,
+    )
+    evidence = root / admitted.run_id / "evidence"
+    failures = evidence / "failures"
+    failures.mkdir(parents=True)
+    frame_id = "2022-07-22_flight__0071_0001"
+    report = {
+        "schema_version": "missioncore.goose-ground-qualification-report/v1",
+        "identity_sha256": SHA_A,
+        "source_id": "goose-3d/v2025-08-22",
+        "split": "validation",
+        "frame_count": 961,
+        "aggregates": {"current": {}, "patchworkpp": {}},
+        "degradations": {},
+        "checks": [],
+        "worst_frames": [{"frame_id": frame_id}],
+        "decision": {"status": "shadow-candidate", "passed": True},
+        "safety": {"navigation_or_safety_accepted": False},
+        "frames": [{"private": "not-published"}],
+    }
+    preview = {
+        "schema_version": "missioncore.goose-ground-qualification-failure-preview/v1",
+        "source_id": "goose-3d/v2025-08-22",
+        "frame_id": frame_id,
+        "source_point_count": 2,
+        "point_count": 2,
+        "sampling": "deterministic-even-index",
+        "points_xyz_m": [[0, 0, 0], [1, 1, 1]],
+        "ground_truth_ground": [1, 0],
+        "evaluated": [1, 1],
+        "current_ground": [0, 0],
+        "patchwork_ground": [1, 0],
+        "current_disagreement": [1, 0],
+        "patchwork_disagreement": [0, 0],
+        "safety": {"navigation_or_safety_accepted": False},
+    }
+    for artifact_id, kind, path, value in (
+        (
+            "qualification-report",
+            "goose-ground-qualification-report",
+            evidence / "qualification.json",
+            report,
+        ),
+        (
+            "failure-preview-01",
+            "goose-ground-qualification-failure-preview",
+            failures / f"{frame_id}.json",
+            preview,
+        ),
+    ):
+        path.write_text(json.dumps(value), encoding="utf-8")
+        store.register_artifact(
+            admitted.run_id,
+            QualificationArtifact(
+                artifact_id=artifact_id,
+                kind=kind,
+                relative_path=path.relative_to(root / admitted.run_id).as_posix(),
+                sha256=hashlib.sha256(path.read_bytes()).hexdigest(),
+                byte_length=path.stat().st_size,
+                source_of_record=True,
+            ),
+        )
+    current = store.load(admitted.run_id)
+    stopping = store.transition(
+        admitted.run_id,
+        RunState.STOPPING,
+        expected_revision=current.revision,
+        observed_at_utc="2026-07-24T15:35:04Z",
+        host_monotonic_ns=4,
+    )
+    completed = store.transition(
+        admitted.run_id,
+        RunState.COMPLETED,
+        expected_revision=stopping.revision,
+        observed_at_utc="2026-07-24T15:35:05Z",
+        host_monotonic_ns=5,
+        reason="qualification-evidence-sealed",
+    )
+    return completed, frame_id
+
+
+def test_polygon_api_publishes_verified_ground_qualification(
+    tmp_path: Path,
+) -> None:
+    root = tmp_path / "runs"
+    run, frame_id = _qualification_run(root)
+    router = build_polygon_router(root_provider=lambda: root)
+
+    qualification = _endpoint(
+        router,
+        "/api/v1/polygon/runs/{run_id}/qualification",
+        "GET",
+    )(run_id=run.run_id)
+    preview = _endpoint(
+        router,
+        "/api/v1/polygon/runs/{run_id}/qualification/failures/{frame_id}",
+        "GET",
+    )(run_id=run.run_id, frame_id=frame_id)
+
+    assert qualification["schema_version"] == "missioncore.polygon-ground-qualification/v1"
+    assert qualification["frame_count"] == 961
+    assert "frames" not in qualification
+    assert preview["schema_version"] == "missioncore.polygon-ground-failure-preview/v1"
+    assert preview["frame_id"] == frame_id
+    assert str(tmp_path) not in repr({"qualification": qualification, "preview": preview})
+
+
+def test_polygon_api_rejects_tampered_ground_qualification(
+    tmp_path: Path,
+) -> None:
+    root = tmp_path / "runs"
+    run, _ = _qualification_run(root)
+    (root / run.run_id / "evidence/qualification.json").write_text("{}", encoding="utf-8")
+    router = build_polygon_router(root_provider=lambda: root)
+
+    with pytest.raises(HTTPException) as failure:
+        _endpoint(
+            router,
+            "/api/v1/polygon/runs/{run_id}/qualification",
+            "GET",
+        )(run_id=run.run_id)
+    assert failure.value.status_code == 500
+    assert "SHA-256" in failure.value.detail or "файла" in failure.value.detail
+
+
 class _FakeWorkerGateway:
     def __init__(self) -> None:
         self.calls: list[tuple[str, str]] = []
@@ -286,9 +428,7 @@ class _FakeWorkerGateway:
             "control_available": True,
             "active_run_id": self.active_run_id,
             "run_state": "running" if self.active_run_id else None,
-            "active_provider_ids": (
-                ["px4-gazebo-stock-rover"] if self.active_run_id else []
-            ),
+            "active_provider_ids": (["px4-gazebo-stock-rover"] if self.active_run_id else []),
             "provider_profile": STOCK_ROVER_PROVIDER_PROFILE.to_dict(),
             "isolation": {
                 "network": "loopback-only-netns",