From b894945344ce0e4bc7dab47abda4e46aba3c76cf Mon Sep 17 00:00:00 2001
From: DCCONSTRUCTIONS <dcconstructions@MacBook-Pro-DCCONSTRUCTIONS-2.local>
Date: Mon, 27 Jul 2026 17:53:59 +0300
Subject: [PATCH] feat(perception): qualify E35 degradation recovery

---
 .../src/core/laboratory/advancedResults.ts    |   10 +-
 .../core/laboratory/e35DegradationRecovery.ts |  578 ++++++++
 apps/control-station/src/styles.css           |    1 +
 .../src/styles/e35-degradation-recovery.css   |   83 ++
 .../laboratory/AdvancedLaboratoryResult.tsx   |   14 +-
 .../src/workspaces/laboratory/E35Result.tsx   |  340 +++++
 .../laboratory/LaboratoryArchiveWorkspace.tsx |    3 +-
 .../test/advancedLaboratoryResults.test.mjs   |  104 +-
 .../test/laboratoryProductUi.test.mjs         |   23 +
 docs/13_LIDAR_WORKER_PRODUCT_AND_ROADMAP.md   |   18 +-
 ...16_ARCHITECTURE_AUDIT_EXECUTION_ROADMAP.md |   11 +-
 ...-deterministic-degradation-and-recovery.md |   82 ++
 .../perception/LAB_E35_REPORT_2026-07-27.md   |  153 ++
 ...e35_deterministic_degradation_profile.json |   88 ++
 .../run_e35_degradation_recovery.py           |   51 +
 src/k1link/compute/degradation_recovery.py    |  623 ++++++++
 src/k1link/compute/e35_degradation_replay.py  | 1283 +++++++++++++++++
 src/k1link/web/advanced_laboratory_api.py     |  106 ++
 src/k1link/web/app.py                         |    7 +
 tests/test_advanced_laboratory_api.py         |  109 +-
 tests/test_e35_degradation_recovery.py        |  315 ++++
 21 files changed, 3985 insertions(+), 17 deletions(-)
 create mode 100644 apps/control-station/src/core/laboratory/e35DegradationRecovery.ts
 create mode 100644 apps/control-station/src/styles/e35-degradation-recovery.css
 create mode 100644 apps/control-station/src/workspaces/laboratory/E35Result.tsx
 create mode 100644 docs/adr/0028-e35-deterministic-degradation-and-recovery.md
 create mode 100644 experiments/perception/LAB_E35_REPORT_2026-07-27.md
 create mode 100644 experiments/perception/e35_deterministic_degradation_profile.json
 create mode 100644 experiments/perception/run_e35_degradation_recovery.py
 create mode 100644 src/k1link/compute/degradation_recovery.py
 create mode 100644 src/k1link/compute/e35_degradation_replay.py
 create mode 100644 tests/test_e35_degradation_recovery.py

diff --git a/apps/control-station/src/core/laboratory/advancedResults.ts b/apps/control-station/src/core/laboratory/advancedResults.ts
index 3c264d2..8d5243a 100644
--- a/apps/control-station/src/core/laboratory/advancedResults.ts
+++ b/apps/control-station/src/core/laboratory/advancedResults.ts
@@ -94,6 +94,7 @@ export interface AdvancedLaboratoryResults {
   e32: E32LaboratoryResult | null;
   e33: E33LaboratoryResult | null;
   e34: E34TemporalLayerResult | null;
+  e35: E35DegradationRecoveryResult | null;
 }
 
 export class AdvancedLaboratoryContractError extends Error {
@@ -372,15 +373,20 @@ export async function fetchAdvancedLaboratoryResults({
   fetcher?: LaboratoryFetch;
   signal?: AbortSignal;
 } = {}): Promise<AdvancedLaboratoryResults> {
-  const [e31, e32, e33, e34] = await Promise.all([
+  const [e31, e32, e33, e34, e35] = await Promise.all([
     fetchOne("/api/v1/laboratory/e31/results?limit=1", parseE31, fetcher, signal),
     fetchOne("/api/v1/laboratory/e32/results?limit=1", parseE32, fetcher, signal),
     fetchOne("/api/v1/laboratory/e33/results?limit=1", parseE33, fetcher, signal),
     fetchE34TemporalLayerResult({ fetcher, signal }),
+    fetchE35DegradationRecoveryResult({ fetcher, signal }),
   ]);
-  return { e31, e32, e33, e34 };
+  return { e31, e32, e33, e34, e35 };
 }
 import {
   fetchE34TemporalLayerResult,
   type E34TemporalLayerResult,
 } from "./e34TemporalLayer";
+import {
+  fetchE35DegradationRecoveryResult,
+  type E35DegradationRecoveryResult,
+} from "./e35DegradationRecovery";
diff --git a/apps/control-station/src/core/laboratory/e35DegradationRecovery.ts b/apps/control-station/src/core/laboratory/e35DegradationRecovery.ts
new file mode 100644
index 0000000..2af850b
--- /dev/null
+++ b/apps/control-station/src/core/laboratory/e35DegradationRecovery.ts
@@ -0,0 +1,578 @@
+import type {
+  E34OccupancyState,
+  E34OwnerKind,
+  E34Point3,
+  E34TemporalState,
+} from "./e34TemporalLayer";
+
+export type E35DegradationKind =
+  | "camera-loss"
+  | "lidar-loss"
+  | "pose-staleness"
+  | "delayed-frames"
+  | "bounded-drop"
+  | "timing-offset";
+
+export type E35FaultPhase = "before" | "during" | "after";
+
+export interface E35ScenarioMetrics {
+  scenarioId: E35DegradationKind;
+  kind: E35DegradationKind;
+  frameStart: number;
+  frameEnd: number;
+  framesProcessed: number;
+  injectedFrames: number;
+  droppedFrames: number;
+  hiddenSuccessFrames: number;
+  falseFreeRows: number;
+  semanticClaimsDuringCameraLoss: number;
+  metricRowsDuringLidarOrPoseLoss: number;
+  agreeClaimsDuringTimingOffset: number;
+  lateResultsReintroduced: number;
+  maximumCurrentComponentsDuringFault: number;
+  maximumHeldComponentsDuringFault: number;
+  expiredComponentsDuringFault: number;
+  recoveryFrameIndex: number;
+  recoverySeconds: number;
+}
+
+export interface E35TemporalComponent {
+  temporalId: number;
+  state: E34TemporalState;
+  occupancyState: E34OccupancyState;
+  ownerKind: E34OwnerKind;
+  semanticLabels: readonly string[];
+  centroidMapXyzM: E34Point3;
+  lastObservedAgeSeconds: number;
+}
+
+export interface E35RecoveryReviewFrame {
+  scenarioId: E35DegradationKind;
+  kind: E35DegradationKind;
+  frameIndex: number;
+  sessionSeconds: number;
+  faultPhase: E35FaultPhase;
+  action: string;
+  channels: Readonly<Record<string, string>>;
+  inputPointRows: number;
+  transformedPointRows: number;
+  layerState: "current" | "held" | "unknown";
+  counts: {
+    current: number;
+    held: number;
+    expired: number;
+  };
+  components: readonly E35TemporalComponent[];
+  cellCentersMapXyzM: readonly E34Point3[];
+}
+
+export interface E35RecoveryReviewScenario {
+  scenarioId: E35DegradationKind;
+  kind: E35DegradationKind;
+  frameStart: number;
+  frameEnd: number;
+  frames: readonly E35RecoveryReviewFrame[];
+}
+
+export interface E35DegradationRecoveryResult {
+  resultId: string;
+  createdAtUtc: string | null;
+  sourceSessionId: string;
+  status: "accepted-deterministic-degradation-recovery";
+  e32ResultId: string;
+  e33ResultId: string;
+  e34ResultId: string;
+  profileId: string;
+  pipelineId: string;
+  coordinateFrame: "map";
+  configuration: {
+    maximumRecoverySeconds: number;
+    scenarioCount: number;
+  };
+  metrics: {
+    sourceFrames: number;
+    variantCount: number;
+    variantFrameOutcomes: number;
+    injectionRecords: number;
+    variantFrameProcessingP95Ms: number;
+    buildElapsedMs: number;
+  };
+  scenarios: readonly E35ScenarioMetrics[];
+  reviewScenarios: readonly E35RecoveryReviewScenario[];
+  access: "read-only";
+}
+
+type LaboratoryFetch = (
+  input: RequestInfo | URL,
+  init?: RequestInit,
+) => Promise<Response>;
+
+class E35DegradationRecoveryContractError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "E35DegradationRecoveryContractError";
+  }
+}
+
+function record(value: unknown, label: string): Record<string, unknown> {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new E35DegradationRecoveryContractError(
+      `${label}: ожидался объект.`,
+    );
+  }
+  return value as Record<string, unknown>;
+}
+
+function list(value: unknown, label: string): readonly unknown[] {
+  if (!Array.isArray(value)) {
+    throw new E35DegradationRecoveryContractError(
+      `${label}: ожидался массив.`,
+    );
+  }
+  return value;
+}
+
+function stringValue(value: unknown, label: string): string {
+  if (typeof value !== "string" || !value.trim()) {
+    throw new E35DegradationRecoveryContractError(
+      `${label}: ожидалась строка.`,
+    );
+  }
+  return value;
+}
+
+function optionalString(value: unknown, label: string): string | null {
+  return value === null ? null : stringValue(value, label);
+}
+
+function numberValue(value: unknown, label: string): number {
+  if (typeof value !== "number" || !Number.isFinite(value) || value < 0) {
+    throw new E35DegradationRecoveryContractError(
+      `${label}: ожидалось неотрицательное число.`,
+    );
+  }
+  return value;
+}
+
+function integerValue(value: unknown, label: string): number {
+  const parsed = numberValue(value, label);
+  if (!Number.isSafeInteger(parsed)) {
+    throw new E35DegradationRecoveryContractError(
+      `${label}: ожидалось целое число.`,
+    );
+  }
+  return parsed;
+}
+
+function exactString<T extends string>(
+  value: unknown,
+  expected: T,
+  label: string,
+): T {
+  if (value !== expected) {
+    throw new E35DegradationRecoveryContractError(
+      `${label}: неверное значение.`,
+    );
+  }
+  return expected;
+}
+
+function oneOf<T extends string>(
+  value: unknown,
+  expected: readonly T[],
+  label: string,
+): T {
+  if (typeof value !== "string" || !expected.includes(value as T)) {
+    throw new E35DegradationRecoveryContractError(
+      `${label}: неверное значение.`,
+    );
+  }
+  return value as T;
+}
+
+function contentId(value: unknown, prefix: string, label: string): string {
+  const parsed = stringValue(value, label);
+  if (!new RegExp(`^${prefix}-[a-f0-9]{64}$`).test(parsed)) {
+    throw new E35DegradationRecoveryContractError(
+      `${label}: неверный content id.`,
+    );
+  }
+  return parsed;
+}
+
+function point(value: unknown, label: string): E34Point3 {
+  const coordinates = list(value, label);
+  if (coordinates.length !== 3) {
+    throw new E35DegradationRecoveryContractError(
+      `${label}: ожидались XYZ.`,
+    );
+  }
+  const result = coordinates.map(
+    (coordinate, index) => {
+      if (typeof coordinate !== "number" || !Number.isFinite(coordinate)) {
+        throw new E35DegradationRecoveryContractError(
+          `${label}[${index}]: ожидалось число.`,
+        );
+      }
+      return coordinate;
+    },
+  );
+  return [result[0]!, result[1]!, result[2]!];
+}
+
+const DEGRADATION_KINDS = [
+  "camera-loss",
+  "lidar-loss",
+  "pose-staleness",
+  "delayed-frames",
+  "bounded-drop",
+  "timing-offset",
+] as const;
+
+function degradationKind(
+  value: unknown,
+  label: string,
+): E35DegradationKind {
+  return oneOf(value, DEGRADATION_KINDS, label);
+}
+
+function parseComponent(
+  value: unknown,
+  label: string,
+): E35TemporalComponent {
+  const item = record(value, label);
+  return {
+    temporalId: integerValue(item.temporal_id, `${label}.temporal_id`),
+    state: oneOf(
+      item.state,
+      ["current", "held", "expired"] as const,
+      `${label}.state`,
+    ),
+    occupancyState: oneOf(
+      item.occupancy_state,
+      ["occupied", "unknown"] as const,
+      `${label}.occupancy_state`,
+    ),
+    ownerKind: oneOf(
+      item.owner_kind,
+      ["camera-track", "geometry-cluster"] as const,
+      `${label}.owner_kind`,
+    ),
+    semanticLabels: list(
+      item.semantic_labels,
+      `${label}.semantic_labels`,
+    ).map((entry, index) => stringValue(
+      entry,
+      `${label}.semantic_labels[${index}]`,
+    )),
+    centroidMapXyzM: point(
+      item.centroid_map_xyz_m,
+      `${label}.centroid_map_xyz_m`,
+    ),
+    lastObservedAgeSeconds: numberValue(
+      item.last_observed_age_seconds,
+      `${label}.last_observed_age_seconds`,
+    ),
+  };
+}
+
+function parseReviewFrame(
+  value: unknown,
+  label: string,
+): E35RecoveryReviewFrame {
+  const item = record(value, label);
+  const counts = record(item.counts, `${label}.counts`);
+  const channels = record(item.channels, `${label}.channels`);
+  return {
+    scenarioId: degradationKind(
+      item.scenario_id,
+      `${label}.scenario_id`,
+    ),
+    kind: degradationKind(item.kind, `${label}.kind`),
+    frameIndex: integerValue(item.frame_index, `${label}.frame_index`),
+    sessionSeconds: numberValue(
+      item.session_seconds,
+      `${label}.session_seconds`,
+    ),
+    faultPhase: oneOf(
+      item.fault_phase,
+      ["before", "during", "after"] as const,
+      `${label}.fault_phase`,
+    ),
+    action: stringValue(item.action, `${label}.action`),
+    channels: Object.fromEntries(
+      Object.entries(channels).map(([key, entry]) => [
+        key,
+        stringValue(entry, `${label}.channels.${key}`),
+      ]),
+    ),
+    inputPointRows: integerValue(
+      item.input_point_rows,
+      `${label}.input_point_rows`,
+    ),
+    transformedPointRows: integerValue(
+      item.transformed_point_rows,
+      `${label}.transformed_point_rows`,
+    ),
+    layerState: oneOf(
+      item.layer_state,
+      ["current", "held", "unknown"] as const,
+      `${label}.layer_state`,
+    ),
+    counts: {
+      current: integerValue(counts.current, `${label}.counts.current`),
+      held: integerValue(counts.held, `${label}.counts.held`),
+      expired: integerValue(counts.expired, `${label}.counts.expired`),
+    },
+    components: list(item.components, `${label}.components`).map(
+      (entry, index) => parseComponent(
+        entry,
+        `${label}.components[${index}]`,
+      ),
+    ),
+    cellCentersMapXyzM: list(
+      item.cell_centers_map_xyz_m,
+      `${label}.cell_centers_map_xyz_m`,
+    ).map((entry, index) => point(
+      entry,
+      `${label}.cell_centers_map_xyz_m[${index}]`,
+    )),
+  };
+}
+
+function parseReviewScenario(
+  value: unknown,
+  label: string,
+): E35RecoveryReviewScenario {
+  const item = record(value, label);
+  const scenario = record(item.scenario, `${label}.scenario`);
+  return {
+    scenarioId: degradationKind(
+      scenario.scenario_id,
+      `${label}.scenario.scenario_id`,
+    ),
+    kind: degradationKind(
+      scenario.kind,
+      `${label}.scenario.kind`,
+    ),
+    frameStart: integerValue(
+      scenario.frame_start,
+      `${label}.scenario.frame_start`,
+    ),
+    frameEnd: integerValue(
+      scenario.frame_end,
+      `${label}.scenario.frame_end`,
+    ),
+    frames: list(item.frames, `${label}.frames`).map(
+      (entry, index) => parseReviewFrame(
+        entry,
+        `${label}.frames[${index}]`,
+      ),
+    ),
+  };
+}
+
+function parseScenarioMetrics(
+  value: unknown,
+  label: string,
+): E35ScenarioMetrics {
+  const item = record(value, label);
+  const integer = (key: string) => integerValue(item[key], `${label}.${key}`);
+  return {
+    scenarioId: degradationKind(item.scenario_id, `${label}.scenario_id`),
+    kind: degradationKind(item.kind, `${label}.kind`),
+    frameStart: integer("frame_start"),
+    frameEnd: integer("frame_end"),
+    framesProcessed: integer("frames_processed"),
+    injectedFrames: integer("injected_frames"),
+    droppedFrames: integer("dropped_frames"),
+    hiddenSuccessFrames: integer("hidden_success_frames"),
+    falseFreeRows: integer("false_free_rows"),
+    semanticClaimsDuringCameraLoss: integer(
+      "semantic_claims_during_camera_loss",
+    ),
+    metricRowsDuringLidarOrPoseLoss: integer(
+      "metric_rows_during_lidar_or_pose_loss",
+    ),
+    agreeClaimsDuringTimingOffset: integer(
+      "agree_claims_during_timing_offset",
+    ),
+    lateResultsReintroduced: integer("late_results_reintroduced"),
+    maximumCurrentComponentsDuringFault: integer(
+      "maximum_current_components_during_fault",
+    ),
+    maximumHeldComponentsDuringFault: integer(
+      "maximum_held_components_during_fault",
+    ),
+    expiredComponentsDuringFault: integer(
+      "expired_components_during_fault",
+    ),
+    recoveryFrameIndex: integer("recovery_frame_index"),
+    recoverySeconds: numberValue(
+      item.recovery_seconds,
+      `${label}.recovery_seconds`,
+    ),
+  };
+}
+
+function diagnosticAuthority(value: unknown, label: string): void {
+  const authority = record(value, label);
+  if (
+    authority.commands_enabled !== false
+    || authority.navigation_or_safety_accepted !== false
+  ) {
+    throw new E35DegradationRecoveryContractError(
+      `${label}: запрещённые полномочия.`,
+    );
+  }
+}
+
+function parseResult(value: unknown): E35DegradationRecoveryResult {
+  const item = record(value, "E35");
+  const configuration = record(item.configuration, "E35.configuration");
+  const metrics = record(item.metrics, "E35.metrics");
+  const review = record(item.review, "E35.review");
+  const acceptance = record(item.acceptance, "E35.acceptance");
+  diagnosticAuthority(item.authority, "E35.authority");
+  if (acceptance.accepted !== true) {
+    throw new E35DegradationRecoveryContractError(
+      "E35.acceptance: результат отклонён.",
+    );
+  }
+  exactString(
+    review.schema_version,
+    "missioncore.e35-recovery-review/v1",
+    "E35.review.schema_version",
+  );
+  return {
+    resultId: contentId(
+      item.result_id,
+      "e35-degradation-recovery",
+      "E35.result_id",
+    ),
+    createdAtUtc: optionalString(item.created_at_utc, "E35.created_at_utc"),
+    sourceSessionId: stringValue(
+      item.source_session_id,
+      "E35.source_session_id",
+    ),
+    status: exactString(
+      item.status,
+      "accepted-deterministic-degradation-recovery",
+      "E35.status",
+    ),
+    e32ResultId: contentId(
+      item.e32_result_id,
+      "e32-track-geometry",
+      "E35.e32_result_id",
+    ),
+    e33ResultId: contentId(
+      item.e33_result_id,
+      "e33-worker-shadow",
+      "E35.e33_result_id",
+    ),
+    e34ResultId: contentId(
+      item.e34_result_id,
+      "e34-temporal-occupied",
+      "E35.e34_result_id",
+    ),
+    profileId: stringValue(item.profile_id, "E35.profile_id"),
+    pipelineId: stringValue(item.pipeline_id, "E35.pipeline_id"),
+    coordinateFrame: exactString(
+      item.coordinate_frame,
+      "map",
+      "E35.coordinate_frame",
+    ),
+    configuration: {
+      maximumRecoverySeconds: numberValue(
+        configuration.maximum_recovery_seconds,
+        "E35.configuration.maximum_recovery_seconds",
+      ),
+      scenarioCount: integerValue(
+        configuration.scenario_count,
+        "E35.configuration.scenario_count",
+      ),
+    },
+    metrics: {
+      sourceFrames: integerValue(
+        metrics.source_frames,
+        "E35.metrics.source_frames",
+      ),
+      variantCount: integerValue(
+        metrics.variant_count,
+        "E35.metrics.variant_count",
+      ),
+      variantFrameOutcomes: integerValue(
+        metrics.variant_frame_outcomes,
+        "E35.metrics.variant_frame_outcomes",
+      ),
+      injectionRecords: integerValue(
+        metrics.injection_records,
+        "E35.metrics.injection_records",
+      ),
+      variantFrameProcessingP95Ms: numberValue(
+        metrics.variant_frame_processing_p95_ms,
+        "E35.metrics.variant_frame_processing_p95_ms",
+      ),
+      buildElapsedMs: numberValue(
+        metrics.build_elapsed_ms,
+        "E35.metrics.build_elapsed_ms",
+      ),
+    },
+    scenarios: list(item.scenarios, "E35.scenarios").map(
+      (entry, index) => parseScenarioMetrics(
+        entry,
+        `E35.scenarios[${index}]`,
+      ),
+    ),
+    reviewScenarios: list(review.scenarios, "E35.review.scenarios").map(
+      (entry, index) => parseReviewScenario(
+        entry,
+        `E35.review.scenarios[${index}]`,
+      ),
+    ),
+    access: exactString(item.access, "read-only", "E35.access"),
+  };
+}
+
+export async function fetchE35DegradationRecoveryResult({
+  fetcher = fetch,
+  signal,
+}: {
+  fetcher?: LaboratoryFetch;
+  signal?: AbortSignal;
+} = {}): Promise<E35DegradationRecoveryResult | null> {
+  const response = await fetcher(
+    "/api/v1/laboratory/e35/results?limit=1",
+    {
+      method: "GET",
+      headers: { Accept: "application/json" },
+      signal,
+    },
+  );
+  if (!response.ok) {
+    throw new E35DegradationRecoveryContractError(
+      `Каталог LAB E35 недоступен: HTTP ${response.status}.`,
+    );
+  }
+  const catalog = record(await response.json(), "Каталог LAB E35");
+  exactString(
+    catalog.schema_version,
+    "missioncore.laboratory-advanced-catalog/v1",
+    "Каталог LAB E35.schema_version",
+  );
+  if (typeof catalog.configured !== "boolean") {
+    throw new E35DegradationRecoveryContractError(
+      "Каталог LAB E35.configured: ожидался boolean.",
+    );
+  }
+  integerValue(catalog.candidate_total, "Каталог LAB E35.candidate_total");
+  integerValue(catalog.invalid_total, "Каталог LAB E35.invalid_total");
+  exactString(catalog.access, "read-only", "Каталог LAB E35.access");
+  const items = list(catalog.items, "Каталог LAB E35.items");
+  if (items.length > 1) {
+    throw new E35DegradationRecoveryContractError(
+      "Каталог LAB E35: нарушен limit=1.",
+    );
+  }
+  return items.length ? parseResult(items[0]) : null;
+}
diff --git a/apps/control-station/src/styles.css b/apps/control-station/src/styles.css
index ffcf1e9..cb5c4b1 100644
--- a/apps/control-station/src/styles.css
+++ b/apps/control-station/src/styles.css
@@ -4,6 +4,7 @@
 @import "./styles/laboratory.css";
 @import "./styles/laboratory-reporting.css";
 @import "./styles/e34-temporal-layer.css";
+@import "./styles/e35-degradation-recovery.css";
 @import "./styles/e30-human-review.css";
 @import "./styles/spatial.css";
 @import "./styles/device.css";
diff --git a/apps/control-station/src/styles/e35-degradation-recovery.css b/apps/control-station/src/styles/e35-degradation-recovery.css
new file mode 100644
index 0000000..0189d61
--- /dev/null
+++ b/apps/control-station/src/styles/e35-degradation-recovery.css
@@ -0,0 +1,83 @@
+.e35-degradation-evidence {
+  width: 100%;
+  height: 100%;
+  min-width: 0;
+  min-height: 0;
+}
+
+.e35-degradation-evidence__selectors {
+  display: flex;
+  align-items: center;
+  gap: 0.45rem;
+}
+
+.e35-degradation-evidence__selectors .nodedc-select-anchor {
+  width: clamp(10rem, 20vw, 15rem);
+}
+
+.e35-degradation-evidence__timeline {
+  position: absolute;
+  z-index: 3;
+  top: 3.7rem;
+  right: 0.6rem;
+  display: flex;
+  flex-wrap: wrap;
+  justify-content: flex-end;
+  gap: 0.3rem;
+  max-width: calc(100% - 1.2rem);
+}
+
+.e35-degradation-evidence__timeline .nodedc-button {
+  background: var(--nodedc-floating-surface);
+  backdrop-filter: blur(var(--nodedc-blur-control));
+}
+
+.e35-degradation-evidence__telemetry {
+  position: absolute;
+  z-index: 3;
+  left: 0.6rem;
+  bottom: 0.6rem;
+  display: grid;
+  width: min(19rem, calc(100% - 1.2rem));
+  gap: 0.34rem;
+  margin: 0;
+  border-radius: var(--nodedc-radius-control-compact);
+  background: var(--nodedc-floating-surface);
+  padding: 0.55rem 0.65rem;
+  color: var(--nodedc-text-secondary);
+  pointer-events: none;
+  backdrop-filter: blur(var(--nodedc-blur-control));
+}
+
+.e35-degradation-evidence__telemetry > div {
+  display: grid;
+  gap: 0.1rem;
+}
+
+.e35-degradation-evidence__telemetry dt,
+.e35-degradation-evidence__telemetry dd {
+  margin: 0;
+  font-size: 0.5rem;
+}
+
+.e35-degradation-evidence__telemetry dt {
+  color: var(--nodedc-text-muted);
+}
+
+.e35-degradation-evidence__telemetry dd {
+  overflow: hidden;
+  color: var(--nodedc-text-primary);
+  font-weight: 650;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+@media (max-width: 900px) {
+  .e35-degradation-evidence__timeline {
+    top: 4rem;
+  }
+
+  .e35-degradation-evidence__timeline .nodedc-button {
+    padding-inline: 0.55rem;
+  }
+}
diff --git a/apps/control-station/src/workspaces/laboratory/AdvancedLaboratoryResult.tsx b/apps/control-station/src/workspaces/laboratory/AdvancedLaboratoryResult.tsx
index 6e6f85c..73b0f44 100644
--- a/apps/control-station/src/workspaces/laboratory/AdvancedLaboratoryResult.tsx
+++ b/apps/control-station/src/workspaces/laboratory/AdvancedLaboratoryResult.tsx
@@ -8,13 +8,15 @@ import { E31Result } from "./E31Result";
 import { E32Result } from "./E32Result";
 import { E33Result } from "./E33Result";
 import { E34Result } from "./E34Result";
+import { E35Result } from "./E35Result";
 import { RecordedReplayEvidence } from "./RecordedReplayEvidence";
 
 export type AdvancedLaboratoryWorkId =
   | "e31-source-binding"
   | "e32-track-geometry"
   | "e33-worker-shadow"
-  | "e34-temporal-layer";
+  | "e34-temporal-layer"
+  | "e35-degradation-recovery";
 
 type LaboratoryWorkspaceProps = WorkspaceRendererProps & {
   SpatialView: ComponentType<WorkspaceRendererProps>;
@@ -28,6 +30,7 @@ export function isAdvancedLaboratoryWorkId(
     || value === "e32-track-geometry"
     || value === "e33-worker-shadow"
     || value === "e34-temporal-layer"
+    || value === "e35-degradation-recovery"
   );
 }
 
@@ -60,6 +63,12 @@ export function advancedLaboratoryWorkOptions(
       label: "LAB E34 · temporal occupied/unknown",
     });
   }
+  if (results.e35) {
+    options.push({
+      id: "e35-degradation-recovery",
+      label: "LAB E35 · degradation recovery",
+    });
+  }
   return options;
 }
 
@@ -97,6 +106,9 @@ export function AdvancedLaboratoryResult({
   failedSessionId: string | null;
   replayError: string | null;
 }) {
+  if (workId === "e35-degradation-recovery" && results.e35) {
+    return <E35Result rigLabel={rigLabel} result={results.e35} />;
+  }
   if (workId === "e34-temporal-layer" && results.e34) {
     return <E34Result rigLabel={rigLabel} result={results.e34} />;
   }
diff --git a/apps/control-station/src/workspaces/laboratory/E35Result.tsx b/apps/control-station/src/workspaces/laboratory/E35Result.tsx
new file mode 100644
index 0000000..a4547ad
--- /dev/null
+++ b/apps/control-station/src/workspaces/laboratory/E35Result.tsx
@@ -0,0 +1,340 @@
+import { useMemo, useState } from "react";
+import { Button, Select } from "@nodedc/ui-react";
+
+import { LaboratoryEvidenceViewer } from "../../components/laboratory/LaboratoryEvidenceViewer";
+import {
+  LaboratoryEvidence,
+  LaboratoryResultSummary,
+  LaboratorySummary,
+  LaboratoryWorkTemplate,
+} from "../../components/laboratory/LaboratoryPresentation";
+import type {
+  E35DegradationKind,
+  E35DegradationRecoveryResult,
+  E35RecoveryReviewFrame,
+  E35RecoveryReviewScenario,
+} from "../../core/laboratory/e35DegradationRecovery";
+import type { E34TemporalReviewFrame } from "../../core/laboratory/e34TemporalLayer";
+import { formatNumber } from "../../presentation";
+import {
+  E34TemporalLayerScene,
+  type E34TemporalViewMode,
+} from "./E34TemporalLayerScene";
+
+const SCENARIO_LABELS: Record<E35DegradationKind, string> = {
+  "camera-loss": "Потеря камеры",
+  "lidar-loss": "Потеря LiDAR",
+  "pose-staleness": "Устаревшая поза",
+  "delayed-frames": "Просроченные кадры",
+  "bounded-drop": "Ограниченные пропуски",
+  "timing-offset": "Рассинхрон 250 мс",
+};
+
+const PHASE_LABELS = {
+  before: "До отказа",
+  during: "Во время отказа",
+  after: "После восстановления",
+} as const;
+
+function sceneFrame(frame: E35RecoveryReviewFrame): E34TemporalReviewFrame {
+  return {
+    frameIndex: frame.frameIndex,
+    sessionSeconds: frame.sessionSeconds,
+    sourceAvailable: frame.transformedPointRows > 0,
+    layerState: frame.layerState,
+    counts: frame.counts,
+    cellCentersMapXyzM: frame.cellCentersMapXyzM,
+    components: frame.components.map((component) => ({
+      temporalId: component.temporalId,
+      state: component.state,
+      occupancyState: component.occupancyState,
+      ownerKind: component.ownerKind,
+      centroidMapXyzM: component.centroidMapXyzM,
+      lastObservedAgeSeconds: component.lastObservedAgeSeconds,
+      associationReason: frame.action,
+      history: [],
+    })),
+  };
+}
+
+function channelSummary(frame: E35RecoveryReviewFrame): string {
+  return Object.entries(frame.channels)
+    .map(([channel, state]) => `${channel}: ${state}`)
+    .join(" · ");
+}
+
+function unsafeClaims(
+  result: E35DegradationRecoveryResult,
+): number {
+  return result.scenarios.reduce((total, scenario) => (
+    total
+    + scenario.hiddenSuccessFrames
+    + scenario.falseFreeRows
+    + scenario.semanticClaimsDuringCameraLoss
+    + scenario.metricRowsDuringLidarOrPoseLoss
+    + scenario.agreeClaimsDuringTimingOffset
+    + scenario.lateResultsReintroduced
+  ), 0);
+}
+
+function maximumRecovery(
+  result: E35DegradationRecoveryResult,
+): number {
+  return Math.max(...result.scenarios.map(
+    (scenario) => scenario.recoverySeconds,
+  ));
+}
+
+function defaultFrame(
+  scenario: E35RecoveryReviewScenario,
+): E35RecoveryReviewFrame | null {
+  return scenario.frames.find((frame) => (
+    frame.faultPhase === "during"
+    && (frame.counts.held > 0 || frame.counts.expired > 0)
+  )) ?? scenario.frames[0] ?? null;
+}
+
+function E35Evidence({
+  result,
+}: {
+  result: E35DegradationRecoveryResult;
+}) {
+  const initialScenario = result.reviewScenarios[0] ?? null;
+  const [scenarioId, setScenarioId] = useState<E35DegradationKind>(
+    initialScenario?.scenarioId ?? "camera-loss",
+  );
+  const scenario = result.reviewScenarios.find(
+    (item) => item.scenarioId === scenarioId,
+  ) ?? initialScenario;
+  const initialFrame = scenario ? defaultFrame(scenario) : null;
+  const [frameIndex, setFrameIndex] = useState(initialFrame?.frameIndex ?? 0);
+  const frame = scenario?.frames.find(
+    (item) => item.frameIndex === frameIndex,
+  ) ?? initialFrame;
+  const [mode, setMode] = useState<E34TemporalViewMode>("3d");
+  const [expanded, setExpanded] = useState(false);
+  const renderedFrame = useMemo(
+    () => frame ? sceneFrame(frame) : null,
+    [frame],
+  );
+
+  if (!scenario || !frame || !renderedFrame) {
+    return (
+      <div className="laboratory-result-pending" role="status">
+        Контрольные состояния деградации не опубликованы.
+      </div>
+    );
+  }
+
+  const selectScenario = (value: string) => {
+    const nextId = value as E35DegradationKind;
+    const nextScenario = result.reviewScenarios.find(
+      (item) => item.scenarioId === nextId,
+    );
+    setScenarioId(nextId);
+    setFrameIndex(defaultFrame(nextScenario ?? scenario)?.frameIndex ?? 0);
+  };
+
+  return (
+    <div className="e35-degradation-evidence">
+      <LaboratoryEvidenceViewer
+        label="Деградация и восстановление E35"
+        mode={mode}
+        modes={[
+          { value: "3d", label: "3D" },
+          { value: "plan", label: "План" },
+        ]}
+        expanded={expanded}
+        onModeChange={setMode}
+        onExpandedChange={setExpanded}
+        actions={(
+          <div className="e35-degradation-evidence__selectors">
+            <Select
+              label="Сценарий отказа"
+              value={scenario.scenarioId}
+              options={result.reviewScenarios.map((item) => ({
+                value: item.scenarioId,
+                label: SCENARIO_LABELS[item.scenarioId],
+              }))}
+              variant="split"
+              menuWidth="anchor"
+              onChange={selectScenario}
+            />
+          </div>
+        )}
+        overlay={(
+          <>
+            <div className="e35-degradation-evidence__timeline">
+              {scenario.frames.map((item, index) => (
+                <Button
+                  key={item.frameIndex}
+                  size="compact"
+                  variant={item.frameIndex === frame.frameIndex
+                    ? "primary"
+                    : "secondary"}
+                  onClick={() => setFrameIndex(item.frameIndex)}
+                >
+                  {index + 1}
+                  {" · "}
+                  {PHASE_LABELS[item.faultPhase]}
+                </Button>
+              ))}
+            </div>
+            <dl className="e35-degradation-evidence__telemetry">
+              <div>
+                <dt>Сценарий / фаза</dt>
+                <dd>
+                  {SCENARIO_LABELS[frame.kind]}
+                  {" · "}
+                  {PHASE_LABELS[frame.faultPhase]}
+                </dd>
+              </div>
+              <div>
+                <dt>Кадр / действие</dt>
+                <dd>
+                  {formatNumber(frame.frameIndex, 0)}
+                  {" · "}
+                  {frame.action}
+                </dd>
+              </div>
+              <div>
+                <dt>Точки до / после</dt>
+                <dd>
+                  {formatNumber(frame.inputPointRows, 0)}
+                  {" / "}
+                  {formatNumber(frame.transformedPointRows, 0)}
+                </dd>
+              </div>
+              <div>
+                <dt>Слой</dt>
+                <dd>
+                  {frame.counts.current} current · {frame.counts.held} held · {frame.counts.expired} expired
+                </dd>
+              </div>
+              <div>
+                <dt>Каналы</dt>
+                <dd>{channelSummary(frame)}</dd>
+              </div>
+            </dl>
+          </>
+        )}
+      >
+        <E34TemporalLayerScene frame={renderedFrame} mode={mode} />
+      </LaboratoryEvidenceViewer>
+    </div>
+  );
+}
+
+export function E35Result({
+  rigLabel,
+  result,
+}: {
+  rigLabel: string;
+  result: E35DegradationRecoveryResult;
+}) {
+  const metrics = result.metrics;
+  const maximum = maximumRecovery(result);
+  const unsafe = unsafeClaims(result);
+  return (
+    <LaboratoryWorkTemplate
+      summary={(
+        <LaboratorySummary
+          title="LAB E35 · деградация и восстановление"
+          description="Проверяли, теряет ли система только неподтверждённую способность при отказе камеры, LiDAR, позы или времени — и возвращается ли она в штатное состояние без скрытого успеха и ложного свободного пространства."
+          status="Безопасная деградация принята"
+          statusTone="success"
+          facts={[
+            { label: "Источник", value: `${rigLabel} · цепочка E32–E34` },
+            {
+              label: "Объём проверки",
+              value: `${formatNumber(metrics.variantCount, 0)} × ${formatNumber(metrics.sourceFrames, 0)} кадров`,
+            },
+            {
+              label: "Инъекции отказов",
+              value: `${formatNumber(metrics.injectionRecords, 0)} записей · полный журнал`,
+            },
+            { label: "Полномочия", value: "Диагностика · команды и safety выключены" },
+          ]}
+          brief={{
+            question: "Станет ли отказ источника явным и ограниченным, или система продолжит публиковать неподтверждённую семантику, метрику либо свободное пространство?",
+            approach: "Шесть неизменяемых полных replay-вариантов получили по одному заранее объявленному отказу: потеря камеры, LiDAR, актуальной позы, просрочка, ограниченные пропуски и рассинхрон 250 мс. Каждый изменённый кадр и его восстановление записаны отдельно.",
+            principalResult: `Да, для этой записи и замороженного профиля. Все ${formatNumber(metrics.variantFrameOutcomes, 0)} исходов закрыты, небезопасных утверждений — ${unsafe}, максимальное восстановление — ${maximum.toLocaleString("ru-RU", { maximumFractionDigits: 3 })} с при gate ${result.configuration.maximumRecoverySeconds.toLocaleString("ru-RU")} с.`,
+            limitation: "Это source-scoped shadow qualification. Она не доказывает перенос на другой риг, свободное пространство, traversability, качество детектора, планирование или safety.",
+          }}
+          method={{
+            completeness: "complete",
+            executionClass: "deterministic",
+            pipelineId: "E32 TrackGeometry → frozen E34 layer → E35 fault variants",
+            components: [
+              {
+                kind: "source",
+                name: "Принятая цепочка E32 / E33 / E34",
+                version: `${formatNumber(metrics.sourceFrames, 0)} кадров · map-frame`,
+                role: "неизменяемый TrackGeometry, runtime envelope и temporal layer",
+                identitySha256: null,
+              },
+              {
+                kind: "algorithm",
+                name: "Deterministic degradation transforms",
+                version: `${formatNumber(result.configuration.scenarioCount, 0)} сценариев · 60 кадров каждый`,
+                role: "явно удаляет неподтверждённый канал или разделяет несинхронные evidence claims",
+                identitySha256: null,
+              },
+              {
+                kind: "runtime",
+                name: "Independent frozen-layer replay",
+                version: `${metrics.variantFrameProcessingP95Ms.toLocaleString("ru-RU", { maximumFractionDigits: 3 })} мс/variant-frame p95`,
+                role: "полный terminal accounting, injection journal, recovery и проверка upstream digest",
+                identitySha256: null,
+              },
+            ],
+          }}
+        />
+      )}
+      evidence={(
+        <LaboratoryEvidence
+          eyebrow="ДОКАЗАТЕЛЬСТВО ОТКАЗА И ВОССТАНОВЛЕНИЯ"
+          title="До отказа, потеря способности и возврат текущего evidence"
+          kind="diagnostic-model"
+          resizable
+        >
+          <E35Evidence result={result} />
+        </LaboratoryEvidence>
+      )}
+      result={(
+        <LaboratoryResultSummary
+          title="Все шесть отказов становятся явными и восстанавливаются на следующем кадре"
+          status="14 / 14 gate"
+          statusTone="success"
+          metrics={[
+            {
+              label: "Полное покрытие",
+              value: formatNumber(metrics.variantFrameOutcomes, 0),
+              hint: `${formatNumber(metrics.variantCount, 0)} полных replay-варианта`,
+            },
+            {
+              label: "Макс. восстановление",
+              value: `${maximum.toLocaleString("ru-RU", { maximumFractionDigits: 3 })} с`,
+              hint: `gate ≤ ${result.configuration.maximumRecoverySeconds.toLocaleString("ru-RU")} с`,
+            },
+            {
+              label: "Небезопасные claims",
+              value: formatNumber(unsafe, 0),
+              hint: "нет hidden success, false free или late return",
+            },
+            {
+              label: "Журнал инъекций",
+              value: formatNumber(metrics.injectionRecords, 0),
+              hint: "каждое изменение имеет исходный и итоговый digest",
+            },
+          ]}
+          conclusion={{
+            proved: "На RAVNOVES00 потеря камеры, LiDAR, актуальной позы и времени явно понижает доступную способность: evidence становится geometry-only, camera-only, held/expired unknown или отбрасывается. Номинальное current evidence возвращается за 0,086–0,102 с.",
+            notProved: "Работа не доказывает переносимость на другую запись или mount, detector accuracy, свободное пространство, traversability, planner input, навигацию или safety.",
+            decision: "E35 принимается и закрывает A8. Следующий критический gate — A9/E36: аудит каталога и frozen-profile replay на подходящем втором mounted real source без retuning.",
+          }}
+        />
+      )}
+    />
+  );
+}
diff --git a/apps/control-station/src/workspaces/laboratory/LaboratoryArchiveWorkspace.tsx b/apps/control-station/src/workspaces/laboratory/LaboratoryArchiveWorkspace.tsx
index 9223c2b..40d9c60 100644
--- a/apps/control-station/src/workspaces/laboratory/LaboratoryArchiveWorkspace.tsx
+++ b/apps/control-station/src/workspaces/laboratory/LaboratoryArchiveWorkspace.tsx
@@ -67,6 +67,7 @@ const EMPTY_ADVANCED_RESULTS: AdvancedLaboratoryResults = {
   e32: null,
   e33: null,
   e34: null,
+  e35: null,
 };
 
 function digestFromContentId(value: string | null | undefined): string | null {
@@ -609,7 +610,7 @@ export function LaboratoryArchiveWorkspace(props: LaboratoryWorkspaceProps) {
         e28.status === "rejected" ? "E28" : null,
         e29.status === "rejected" ? "E29" : null,
         e30.status === "rejected" ? "E30" : null,
-        advanced.status === "rejected" ? "E31–E34" : null,
+        advanced.status === "rejected" ? "E31–E35" : null,
       ].filter(Boolean);
       setEvidenceError(
         failures.length
diff --git a/apps/control-station/test/advancedLaboratoryResults.test.mjs b/apps/control-station/test/advancedLaboratoryResults.test.mjs
index 293c279..6df6c85 100644
--- a/apps/control-station/test/advancedLaboratoryResults.test.mjs
+++ b/apps/control-station/test/advancedLaboratoryResults.test.mjs
@@ -206,6 +206,99 @@ function e34() {
   };
 }
 
+function e35() {
+  return {
+    result_id: `e35-degradation-recovery-${"5".repeat(64)}`,
+    created_at_utc: "2026-07-27T15:00:00Z",
+    source_session_id: "20260720T065719Z_viewer_live",
+    status: "accepted-deterministic-degradation-recovery",
+    e32_result_id: e32().result_id,
+    e33_result_id: e33().result_id,
+    e34_result_id: e34().result_id,
+    profile_id: "e35-six-channel-degradation-recovery/v1",
+    pipeline_id: "track-geometry/temporal-layer/degradation-recovery/v1",
+    coordinate_frame: "map",
+    configuration: {
+      maximum_recovery_seconds: 0.25,
+      scenario_count: 6,
+    },
+    metrics: {
+      source_frames: 4489,
+      variant_count: 6,
+      variant_frame_outcomes: 26934,
+      injection_records: 360,
+      variant_frame_processing_p95_ms: 1.08,
+      build_elapsed_ms: 18618,
+    },
+    scenarios: [{
+      scenario_id: "camera-loss",
+      kind: "camera-loss",
+      frame_start: 600,
+      frame_end: 659,
+      frames_processed: 4489,
+      injected_frames: 60,
+      dropped_frames: 0,
+      hidden_success_frames: 0,
+      false_free_rows: 0,
+      semantic_claims_during_camera_loss: 0,
+      metric_rows_during_lidar_or_pose_loss: 0,
+      agree_claims_during_timing_offset: 0,
+      late_results_reintroduced: 0,
+      maximum_current_components_during_fault: 13,
+      maximum_held_components_during_fault: 24,
+      expired_components_during_fault: 60,
+      recovery_frame_index: 660,
+      recovery_seconds: 0.086,
+    }],
+    review: {
+      schema_version: "missioncore.e35-recovery-review/v1",
+      result_id: `e35-degradation-recovery-${"5".repeat(64)}`,
+      scenarios: [{
+        scenario: {
+          schema_version: "missioncore.e35-degradation-scenario/v1",
+          scenario_id: "camera-loss",
+          kind: "camera-loss",
+          frame_start: 600,
+          frame_end: 659,
+          parameters: { drop_camera_observations: true },
+        },
+        frames: [{
+          scenario_id: "camera-loss",
+          kind: "camera-loss",
+          frame_index: 600,
+          source_frame_index: 600,
+          session_seconds: 95.4,
+          fault_phase: "during",
+          action: "camera-observations-removed",
+          channels: {
+            camera: "unavailable",
+            lidar: "available",
+            pose: "available",
+            delivery: "on-time",
+          },
+          input_point_rows: 300,
+          transformed_point_rows: 300,
+          layer_state: "current",
+          counts: { current: 5, held: 2, expired: 0 },
+          components: [{
+            temporal_id: 10,
+            state: "current",
+            occupancy_state: "occupied",
+            owner_kind: "geometry-cluster",
+            semantic_labels: [],
+            last_observed_age_seconds: 0,
+            centroid_map_xyz_m: [1, 2, 0.5],
+          }],
+          cell_centers_map_xyz_m: [[1, 2, 0.5]],
+        }],
+      }],
+    },
+    acceptance: { accepted: true },
+    authority,
+    access: "read-only",
+  };
+}
+
 before(async () => {
   server = await createServer({
     appType: "custom",
@@ -222,9 +315,9 @@ after(async () => {
   await server?.close();
 });
 
-test("decodes E31–E34 from separate read-only catalogs", async () => {
+test("decodes E31–E35 from separate read-only catalogs", async () => {
   const requests = [];
-  const items = [e31(), e32(), e33(), e34()];
+  const items = [e31(), e32(), e33(), e34(), e35()];
   const decoded = await fetchAdvancedLaboratoryResults({
     fetcher: async (input, init) => {
       requests.push({ input: String(input), method: init?.method });
@@ -241,11 +334,15 @@ test("decodes E31–E34 from separate read-only catalogs", async () => {
   assert.equal(decoded.e33.metrics.resultAgeMaxMs, 13.638);
   assert.equal(decoded.e34.metrics.processedFrames, 4489);
   assert.equal(decoded.e34.reviewFrames[0].components[0].state, "expired");
+  assert.equal(decoded.e35.metrics.variantFrameOutcomes, 26934);
+  assert.equal(decoded.e35.scenarios[0].recoverySeconds, 0.086);
+  assert.equal(decoded.e35.reviewScenarios[0].frames[0].faultPhase, "during");
   assert.deepEqual(requests, [
     { input: "/api/v1/laboratory/e31/results?limit=1", method: "GET" },
     { input: "/api/v1/laboratory/e32/results?limit=1", method: "GET" },
     { input: "/api/v1/laboratory/e33/results?limit=1", method: "GET" },
     { input: "/api/v1/laboratory/e34/results?limit=1", method: "GET" },
+    { input: "/api/v1/laboratory/e35/results?limit=1", method: "GET" },
   ]);
 });
 
@@ -259,7 +356,8 @@ test("rejects authority escalation in an accepted-looking result", async () => {
       fetcher: async (input) => new Response(JSON.stringify(catalog(
         String(input).includes("/e31/") ? forged
           : String(input).includes("/e32/") ? e32()
-            : String(input).includes("/e33/") ? e33() : e34(),
+            : String(input).includes("/e33/") ? e33()
+              : String(input).includes("/e34/") ? e34() : e35(),
       )), { status: 200 }),
     }),
     AdvancedLaboratoryContractError,
diff --git a/apps/control-station/test/laboratoryProductUi.test.mjs b/apps/control-station/test/laboratoryProductUi.test.mjs
index 67ea21e..932f7ab 100644
--- a/apps/control-station/test/laboratoryProductUi.test.mjs
+++ b/apps/control-station/test/laboratoryProductUi.test.mjs
@@ -26,6 +26,10 @@ const e34ResultUrl = new URL(
   "../src/workspaces/laboratory/E34Result.tsx",
   import.meta.url,
 );
+const e35ResultUrl = new URL(
+  "../src/workspaces/laboratory/E35Result.tsx",
+  import.meta.url,
+);
 const advancedLaboratoryResultUrl = new URL(
   "../src/workspaces/laboratory/AdvancedLaboratoryResult.tsx",
   import.meta.url,
@@ -161,6 +165,25 @@ test("E34 keeps temporal evidence inside the canonical LAB and viewer contracts"
   assert.match(advancedSource, /<E34Result/);
 });
 
+test("E35 extends the canonical LAB with fault and recovery evidence", async () => {
+  const [e35Source, advancedSource] = await Promise.all([
+    readFile(e35ResultUrl, "utf8"),
+    readFile(advancedLaboratoryResultUrl, "utf8"),
+  ]);
+
+  assert.match(e35Source, /<LaboratoryWorkTemplate/);
+  assert.match(e35Source, /<LaboratoryEvidenceViewer/);
+  assert.match(e35Source, /\{ value: "3d", label: "3D" \}/);
+  assert.match(e35Source, /\{ value: "plan", label: "План" \}/);
+  assert.match(e35Source, /Шесть неизменяемых полных replay-вариантов/);
+  assert.match(e35Source, /небезопасных утверждений —/);
+  assert.match(e35Source, /Следующий критический gate — A9\/E36/);
+  assert.match(e35Source, /SCENARIO_LABELS/);
+  assert.match(e35Source, /PHASE_LABELS/);
+  assert.match(advancedSource, /id: "e35-degradation-recovery"/);
+  assert.match(advancedSource, /<E35Result/);
+});
+
 test("the primary point-cloud viewer restores from fullscreen on Escape", async () => {
   const workspacesSource = await readFile(workspacesUrl, "utf8");
 
diff --git a/docs/13_LIDAR_WORKER_PRODUCT_AND_ROADMAP.md b/docs/13_LIDAR_WORKER_PRODUCT_AND_ROADMAP.md
index 1bb9f4b..cd00404 100644
--- a/docs/13_LIDAR_WORKER_PRODUCT_AND_ROADMAP.md
+++ b/docs/13_LIDAR_WORKER_PRODUCT_AND_ROADMAP.md
@@ -6,7 +6,8 @@ complete; full GOOSE and RELLIS qualification complete; L2.6d K1 replay
 local-surface temporal qualification, operator triage and prior-plane residual
 explainability implemented; L2.6e recorded-source-paced bounded shadow
 qualified; E28 complete worker replay accepted; E29 camera-first semantic and
-parallel geometry-only replay implemented; operator review and shadow gate next
+parallel geometry-only replay implemented; E30–E35 source-scoped qualification
+accepted; E36 transfer gate next
 Scope: passively received real-time K1 point/pose evidence, immutable replay and
 future live shadow processing
 Explicitly out of scope: K1 firmware modification, a new onboard exporter, new
@@ -693,11 +694,18 @@ source gap plus an incoherent nearest-neighbor jump detector; the fixed
 implementation uses an independent TTL deadline and coherent translation
 support without changing the frozen profile.
 
-Execution was strictly sequential through E34: E30 determined what E31 was
+E35 accepted immutable degradation result
+`e35-degradation-recovery-82bdbd5c5bfde6d932737f077153c3a8472c993c343fcbe8a207c39bfa2a6288`.
+Six deterministic variants each replay all `4,489` source frames and record
+`26,934` terminal outcomes plus `360` injection records. Maximum recovery is
+`0.102 s` against the frozen `0.25 s` gate. Hidden success, false-free rows,
+camera-less semantic claims, LiDAR/pose-less metric rows, timing-mismatch
+`agree`, late-result return and upstream mutation are all zero.
+
+Execution was strictly sequential through E35: E30 determined what E31 was
 allowed to change; E31 determined the E32 profile; E32 determined the E33
-runtime input; E32/E33 then bound the E34 layer. Exact accounting and the
-bounded nominal temporal layer are now closed, so E35 is the active critical
-path.
+runtime input; E32/E33 then bound the E34 layer; E32–E34 then bound E35.
+Exact nominal and degradation accounting are closed, so A8 is complete.
 E36 is the first generalization gate. A separate product decision follows:
 either keep the result as operator/shadow evidence, or start L5 occupied-space
 integration. No LAB in this cycle can enable navigation, commands or safety
diff --git a/docs/16_ARCHITECTURE_AUDIT_EXECUTION_ROADMAP.md b/docs/16_ARCHITECTURE_AUDIT_EXECUTION_ROADMAP.md
index 81b6559..93c87e0 100644
--- a/docs/16_ARCHITECTURE_AUDIT_EXECUTION_ROADMAP.md
+++ b/docs/16_ARCHITECTURE_AUDIT_EXECUTION_ROADMAP.md
@@ -202,7 +202,14 @@ cells per component, and emits no free cells. Geometry-only re-association is
 independent `0.75 s` deadline and records the `0.283 s` worst source-gap
 materialization delay separately. The first immutable run remains a rejected
 artifact documenting the frame-clock and incoherent-jump implementation
-failures. E35 is now the critical path.
+failures. A8/E35 is complete in immutable result
+`e35-degradation-recovery-82bdbd5c5bfde6d932737f077153c3a8472c993c343fcbe8a207c39bfa2a6288`.
+Six deterministic variants each replay all 4,489 frames; the result records
+26,934 terminal outcomes and 360 injections. Maximum recovery is `0.102 s`
+against the `0.25 s` gate. Hidden success, false free-space, unsupported
+semantic/metric claims, timing-mismatch `agree`, late-result return and
+upstream changes are all zero. A0–A8 are closed. A9/E36 is now the critical
+path and requires an eligible second mounted real source.
 
 - [x] Reproduce all 4,489 immutable E29 frames with the exact frozen profile
   before applying E31/E30 changes.
@@ -224,7 +231,7 @@ failures. E35 is now the critical path.
   pinned container image; independently verify all result artifacts.
 - [x] Build E34 as a separate short-TTL occupied/unknown temporal layer over
   accepted E32/E33 evidence.
-- [ ] Run E35 deterministic degradation/recovery variants without changing
+- [x] Run E35 deterministic degradation/recovery variants without changing
   the immutable source or accepted E32/E33 results.
 
 ### A3 residual and human-exception policy
diff --git a/docs/adr/0028-e35-deterministic-degradation-and-recovery.md b/docs/adr/0028-e35-deterministic-degradation-and-recovery.md
new file mode 100644
index 0000000..e44e5cb
--- /dev/null
+++ b/docs/adr/0028-e35-deterministic-degradation-and-recovery.md
@@ -0,0 +1,82 @@
+# ADR 0028 — E35 deterministic degradation and recovery
+
+Date: 2026-07-27
+
+Status: accepted and executed
+
+## Context
+
+E32 fixes camera-owned semantic identity and exclusive map-frame point
+ownership over all 4,489 immutable RAVNOVES00 frames. E33 proves bounded
+recorded-source-paced delivery. E34 adds a separate hit-only temporal layer
+with explicit `current/occupied`, `held/unknown` and `expired/unknown` state.
+
+Those nominal results do not yet prove that the composed pipeline fails safely
+when camera, LiDAR, pose or delivery timing degrades. A fault must not retain a
+semantic or metric claim that its required evidence no longer supports. It
+must also not turn missing data into free space or reintroduce a stale result
+after the fault window.
+
+## Predeclared decision
+
+1. E35 derives six immutable variants from the exact accepted E32/E33/E34
+   chain. It never mutates the source or any accepted upstream result.
+2. Each variant replays all 4,489 source frames. One bounded, non-overlapping
+   interval carries exactly one deterministic transformation:
+   camera loss, LiDAR loss, pose staleness, delayed frames, bounded frame drops
+   or camera↔LiDAR timing offset.
+3. Camera loss removes camera observations. Current metric point ownership is
+   retained only as unknown-class `geometry-only`; E35 cannot preserve or
+   invent semantic class.
+4. LiDAR loss retains camera identity as `camera-only` but removes current
+   metric rows. Prior occupied evidence may age through the E34 held/expired
+   contract, but no new occupied or free cells may be created.
+5. Pose age of `0.5 s` exceeds the accepted `0.1 s` binding gate. Map-frame
+   points are therefore withheld and camera claims remain non-metric.
+6. A deterministic `1.0 s` delivery delay exceeds the `0.75 s` occupied TTL.
+   Delayed results are explicitly discarded and may not re-enter after their
+   logical deadline.
+7. The bounded-drop variant drops every third frame in its 60-frame interval.
+   Every drop is journalled; intervening frames remain ordered and the layer
+   exposes held/expired uncertainty instead of silent continuity.
+8. A `250 ms` camera↔LiDAR offset exceeds the admitted binding. Camera
+   observations and point-backed geometry are split into separate
+   `camera-only` and `geometry-only` evidence. The mismatched pair cannot
+   publish `agree`.
+9. Every variant records one terminal outcome per source frame, every injected
+   transformation, layer-state transitions, current/held/expired counts,
+   excluded semantic/metric claims, recovery time and artifact digests.
+10. Acceptance requires six complete 4,489-frame variants, exact unchanged
+    upstream artifacts, zero hidden success, zero false-free rows, zero
+    semantic claims during camera loss, zero metric rows during LiDAR or pose
+    loss, zero late-result reintroduction and explicit recovery no later than
+    `0.25 s` after the fault interval.
+11. The E34 profile, TTL, association gates and bounds remain frozen. E35 may
+    vary only the declared source/channel transformation.
+12. Persistent reconstruction, planner input, commands, navigation and safety
+    authority remain unavailable.
+
+## Consequences
+
+- A passed E35 closes A8 only as a source-scoped diagnostic/shadow
+  degradation contract.
+- Safe degradation is represented as explicit loss of confidence and
+  capability, not as guessed class, extrapolated free space or a green
+  aggregate status.
+- A failed scenario remains immutable evidence. Threshold relaxation or a new
+  transformation definition requires a new profile and result rather than
+  rewriting E35.
+- E36 remains the first transfer/generalization gate and requires an eligible
+  second mounted real source with the frozen E32–E35 profile.
+
+## Outcome
+
+Immutable result:
+`e35-degradation-recovery-82bdbd5c5bfde6d932737f077153c3a8472c993c343fcbe8a207c39bfa2a6288`.
+
+All six variants replayed all 4,489 frames, producing 26,934 terminal outcomes
+and 360 injection records. Maximum recovery was 0.102 s against the
+predeclared 0.25 s gate. Hidden success, false-free rows, camera-less semantic
+claims, LiDAR/pose-less metric rows, timing-mismatch `agree`, late-result
+reintroduction and upstream mutations were all zero. E35 is accepted and A8
+is closed; A9/E36 is next.
diff --git a/experiments/perception/LAB_E35_REPORT_2026-07-27.md b/experiments/perception/LAB_E35_REPORT_2026-07-27.md
new file mode 100644
index 0000000..5e20159
--- /dev/null
+++ b/experiments/perception/LAB_E35_REPORT_2026-07-27.md
@@ -0,0 +1,153 @@
+# LAB E35 — deterministic degradation and recovery
+
+Date: 2026-07-27
+Status: accepted for source-scoped diagnostic/shadow use; persistent
+reconstruction, planner, navigation, safety and command authority remain
+unavailable
+Immutable result:
+`e35-degradation-recovery-82bdbd5c5bfde6d932737f077153c3a8472c993c343fcbe8a207c39bfa2a6288`
+
+## Objective and architecture stage
+
+E35 closes the degradation half of A8. It asks whether the accepted
+E32 TrackGeometry, E33 delivery envelope and E34 temporal occupied/unknown
+layer fail safely and recover explicitly when one required source or timing
+property degrades.
+
+The experiment does not mutate or replace any accepted input. It derives six
+complete deterministic variants from the exact RAVNOVES00 replay, applies one
+bounded transformation in each variant and replays every variant through a
+fresh E34 state machine with its frozen profile.
+
+## Immutable inputs and predeclared profile
+
+- E32:
+  `e32-track-geometry-a14ca0e7fb3850ca0dfa3c41634e1b490a2d58ab74d101afc6d6921fbdb0e6fd`.
+- E33:
+  `e33-worker-shadow-05cc0bb264410fd49536df90e94067ac39731aff0322a8873700d40008a8bb3a`.
+- E34:
+  `e34-temporal-occupied-8d9abb3f2cc072cfdbb16cc4e55798e05c35a0abe0b8f691096770e091573a73`.
+- Source: RAVNOVES00 / `20260720T065719Z_viewer_live`.
+- Frames: `4,489` per variant, `26,934` terminal variant-frame outcomes.
+- Profile:
+  `missioncore.e35-degradation-profile/v1`,
+  `e35-six-channel-degradation-recovery/v1`.
+- Frozen E34 layer: `0.45 m` voxels, `0.75 s` occupied TTL and the accepted
+  component/association bounds.
+
+The profile and ADR 0028 were written before the full replay. Each fault
+occupies a distinct 60-frame interval:
+
+1. camera observations unavailable;
+2. LiDAR points unavailable;
+3. pose age `0.5 s`, above the admitted `0.1 s` binding;
+4. result delay `1.0 s`, above the `0.75 s` TTL, with discard policy;
+5. every third input frame dropped;
+6. camera↔LiDAR offset `250 ms`, above the admitted `100 ms` gate.
+
+Acceptance required complete accounting, an explicit injection journal, all
+variants recovered within `0.25 s`, and zero hidden success, false free-space,
+semantic claims without camera, metric rows without LiDAR/current pose, `agree`
+claims under timing mismatch and late-result reintroduction.
+
+## Method and algorithms
+
+For every source frame and every scenario E35:
+
+1. reconstructs the exact validated E32 `TrackGeometryFrame` and `PointSlab`;
+2. records a digest of the original frame;
+3. applies one pure frame-local transformation only inside the declared
+   interval;
+4. removes semantic identity on camera loss while retaining hit-backed points
+   only as `geometry-only`;
+5. removes map-frame point rows on LiDAR loss or stale pose while retaining
+   camera observations only as non-metric `camera-only`;
+6. discards late frames and prevents them from returning after their logical
+   deadline;
+7. journals every dropped frame and passes intervening bounded-drop frames in
+   original order;
+8. splits mismatched camera and LiDAR evidence into separate `camera-only` and
+   `geometry-only` claims so the pair cannot publish `agree`;
+9. feeds the transformed frame into an independent frozen E34 temporal layer;
+10. records terminal layer state, current/held/expired counts, recovery,
+    transformation digests, policy and authority.
+
+No missing point set is treated as free space. No transform writes into the
+persistent reconstruction or any accepted upstream artifact.
+
+## Accepted result
+
+Result:
+`e35-degradation-recovery-82bdbd5c5bfde6d932737f077153c3a8472c993c343fcbe8a207c39bfa2a6288`.
+
+| Scenario | Injected frames | Explicit drops | Recovery | Unsafe claims |
+| --- | ---: | ---: | ---: | ---: |
+| camera loss | 60 | 0 | 0.086 s | 0 semantics |
+| LiDAR loss | 60 | 0 | 0.100 s | 0 metric rows |
+| pose staleness | 60 | 0 | 0.101 s | 0 metric rows |
+| delayed frames | 60 | 60 | 0.088 s | 0 late returns |
+| bounded drop | 60 | 20 | 0.101 s | 0 hidden success |
+| timing offset | 60 | 0 | 0.102 s | 0 `agree` |
+
+All six variants processed `4,489 / 4,489` frames. The immutable artifacts
+contain `26,934` terminal outcomes and `360` explicit injection records.
+Maximum recovery was `0.102 s`, below the predeclared `0.25 s` gate.
+
+Across all variants:
+
+- hidden success frames: `0`;
+- false free cell rows: `0`;
+- semantic claims during camera loss: `0`;
+- metric rows during LiDAR loss or stale pose: `0`;
+- `agree` claims during timing offset: `0`;
+- late results reintroduced: `0`;
+- upstream artifact changes: `0`;
+- variant-frame processing p95: `1.080 ms`.
+
+## Product materialization
+
+The accepted result is exposed through the path-free read-only endpoint
+`GET /api/v1/laboratory/e35/results?limit=1` and a separate
+`LAB E35 · degradation recovery` entry in the laboratory contour.
+
+The UI extends the fixed `missioncore.laboratory-report/v1` template. It shows:
+
+- the task, immutable method and human-readable conclusion;
+- six selectable fault scenarios;
+- a compact before/during/after recovery timeline;
+- current, held and expired spatial evidence in the existing laboratory
+  viewer with admitted 3D/plan and fullscreen controls;
+- explicit fault action, channel state, recovery time, unsafe-claim count and
+  acceptance decision;
+- proved, not proved and next-gate statements.
+
+E35 does not add a new generic control, a separate page anatomy or a
+run-specific visual language.
+
+## Interpretation and limitations
+
+E35 proves, on this immutable source and frozen profile:
+
+- each declared channel/timing failure loses unsupported capability explicitly;
+- the temporal layer ages prior evidence as held/expired unknown rather than
+  inventing free space;
+- late evidence is discarded and cannot silently return;
+- nominal current evidence returns on the next source frame after every fault;
+- accounting and authority remain closed.
+
+E35 does not prove:
+
+- detector accuracy or human ground truth;
+- transfer to another capture, device or mount;
+- ray-cleared free space, traversability, TSDF or ESDF;
+- planner, navigation, safety or command acceptance.
+
+## Decision and next stage
+
+E35 is accepted and closes A8. Workstream A has completed A0–A8.
+
+The next critical-path gate is A9/E36: run the frozen E32–E35 profile without
+retuning on an eligible second mounted real source. The source catalog must be
+audited first. If no recording contains the required camera, LiDAR, pose,
+time, calibration and mount identities, E36 remains explicitly blocked; no
+empty LAB, fabricated result or new capture is created by default.
diff --git a/experiments/perception/e35_deterministic_degradation_profile.json b/experiments/perception/e35_deterministic_degradation_profile.json
new file mode 100644
index 0000000..27c49b7
--- /dev/null
+++ b/experiments/perception/e35_deterministic_degradation_profile.json
@@ -0,0 +1,88 @@
+{
+  "schema_version": "missioncore.e35-degradation-profile/v1",
+  "profile_id": "e35-six-channel-degradation-recovery/v1",
+  "expected_e32_result_id": "e32-track-geometry-a14ca0e7fb3850ca0dfa3c41634e1b490a2d58ab74d101afc6d6921fbdb0e6fd",
+  "expected_e33_result_id": "e33-worker-shadow-05cc0bb264410fd49536df90e94067ac39731aff0322a8873700d40008a8bb3a",
+  "expected_e34_result_id": "e34-temporal-occupied-8d9abb3f2cc072cfdbb16cc4e55798e05c35a0abe0b8f691096770e091573a73",
+  "scenarios": [
+    {
+      "scenario_id": "camera-loss",
+      "kind": "camera-loss",
+      "frame_start": 600,
+      "frame_end": 659,
+      "parameters": {
+        "drop_camera_observations": true
+      }
+    },
+    {
+      "scenario_id": "lidar-loss",
+      "kind": "lidar-loss",
+      "frame_start": 1200,
+      "frame_end": 1259,
+      "parameters": {
+        "drop_lidar_points": true
+      }
+    },
+    {
+      "scenario_id": "pose-staleness",
+      "kind": "pose-staleness",
+      "frame_start": 1800,
+      "frame_end": 1859,
+      "parameters": {
+        "pose_age_seconds": 0.5
+      }
+    },
+    {
+      "scenario_id": "delayed-frames",
+      "kind": "delayed-frames",
+      "frame_start": 2400,
+      "frame_end": 2459,
+      "parameters": {
+        "delay_seconds": 1.0,
+        "late_result_policy": "discard"
+      }
+    },
+    {
+      "scenario_id": "bounded-drop",
+      "kind": "bounded-drop",
+      "frame_start": 3000,
+      "frame_end": 3059,
+      "parameters": {
+        "drop_every_nth_frame": 3
+      }
+    },
+    {
+      "scenario_id": "timing-offset",
+      "kind": "timing-offset",
+      "frame_start": 3600,
+      "frame_end": 3659,
+      "parameters": {
+        "camera_lidar_offset_ms": 250
+      }
+    }
+  ],
+  "acceptance": {
+    "expected_scenario_count": 6,
+    "maximum_recovery_seconds": 0.25,
+    "maximum_hidden_success_frames": 0,
+    "maximum_false_free_rows": 0,
+    "maximum_semantic_claims_during_camera_loss": 0,
+    "maximum_metric_rows_during_lidar_or_pose_loss": 0,
+    "maximum_late_results_reintroduced": 0,
+    "require_complete_variant_frame_accounting": true,
+    "require_exact_upstream_artifact_identity": true,
+    "require_explicit_injection_journal": true,
+    "require_every_variant_to_recover": true
+  },
+  "policy": {
+    "absence_of_points_means_free": false,
+    "late_results_may_reenter": false,
+    "timing_mismatch_may_publish_agree": false,
+    "pose_stale_points_may_publish_map_occupancy": false,
+    "persistent_reconstruction_mutation_allowed": false
+  },
+  "authority": {
+    "commands_enabled": false,
+    "navigation_or_safety_accepted": false
+  }
+}
diff --git a/experiments/perception/run_e35_degradation_recovery.py b/experiments/perception/run_e35_degradation_recovery.py
new file mode 100644
index 0000000..1565f87
--- /dev/null
+++ b/experiments/perception/run_e35_degradation_recovery.py
@@ -0,0 +1,51 @@
+#!/usr/bin/env python3
+"""Build the immutable E35 degradation and recovery qualification."""
+
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+
+from k1link.compute.e35_degradation_replay import (
+    build_e35_degradation_replay,
+)
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--e32-result", type=Path, required=True)
+    parser.add_argument("--e33-result", type=Path, required=True)
+    parser.add_argument("--e34-result", type=Path, required=True)
+    parser.add_argument("--e34-profile", type=Path, required=True)
+    parser.add_argument("--profile", type=Path, required=True)
+    parser.add_argument("--output-root", type=Path, required=True)
+    args = parser.parse_args()
+    result = build_e35_degradation_replay(
+        e32_result_root=args.e32_result,
+        e33_result_root=args.e33_result,
+        e34_result_root=args.e34_result,
+        e34_profile_path=args.e34_profile,
+        profile_path=args.profile,
+        output_root=args.output_root,
+    )
+    print(
+        json.dumps(
+            {
+                "result_id": result.result_id,
+                "result_root": str(result.result_root),
+                "accepted": result.accepted,
+                "metrics": result.report["metrics"],
+                "rejection_reasons": result.report["acceptance"][
+                    "rejection_reasons"
+                ],
+            },
+            ensure_ascii=False,
+            sort_keys=True,
+        )
+    )
+    return 0 if result.accepted else 2
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/src/k1link/compute/degradation_recovery.py b/src/k1link/compute/degradation_recovery.py
new file mode 100644
index 0000000..19d800e
--- /dev/null
+++ b/src/k1link/compute/degradation_recovery.py
@@ -0,0 +1,623 @@
+"""Deterministic E35 source degradation transforms over TrackGeometry v1.
+
+The transforms are pure and frame-local.  They never alter the accepted E32
+source, infer free space, retain evidence whose required channel is absent, or
+grant runtime authority.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import math
+from dataclasses import dataclass
+from enum import StrEnum
+from typing import Any, Final
+
+import numpy as np
+
+from .track_geometry import (
+    PointSlab,
+    TrackGeometry,
+    TrackGeometryCurrentness,
+    TrackGeometryEvidenceState,
+    TrackGeometryFrame,
+    TrackGeometryMetricBasis,
+    TrackGeometryOwnerKind,
+)
+
+E35_SCENARIO_SCHEMA: Final = "missioncore.e35-degradation-scenario/v1"
+E35_TRANSFORMATION_SCHEMA: Final = "missioncore.e35-frame-transformation/v1"
+
+
+class DegradationRecoveryError(ValueError):
+    """An E35 scenario or transformed frame violates the frozen contract."""
+
+
+class DegradationKind(StrEnum):
+    CAMERA_LOSS = "camera-loss"
+    LIDAR_LOSS = "lidar-loss"
+    POSE_STALENESS = "pose-staleness"
+    DELAYED_FRAMES = "delayed-frames"
+    BOUNDED_DROP = "bounded-drop"
+    TIMING_OFFSET = "timing-offset"
+
+
+@dataclass(frozen=True, slots=True)
+class DegradationScenario:
+    """One bounded deterministic source transformation."""
+
+    scenario_id: str
+    kind: DegradationKind
+    frame_start: int
+    frame_end: int
+    parameters: dict[str, Any]
+
+    def __post_init__(self) -> None:
+        if (
+            not self.scenario_id
+            or len(self.scenario_id) > 80
+            or self.scenario_id != self.kind.value
+            or not isinstance(self.frame_start, int)
+            or isinstance(self.frame_start, bool)
+            or not isinstance(self.frame_end, int)
+            or isinstance(self.frame_end, bool)
+            or self.frame_start < 1
+            or self.frame_end < self.frame_start
+        ):
+            raise DegradationRecoveryError("degradation scenario bounds are invalid")
+        self._validate_parameters()
+
+    def _validate_parameters(self) -> None:
+        expected: dict[DegradationKind, set[str]] = {
+            DegradationKind.CAMERA_LOSS: {"drop_camera_observations"},
+            DegradationKind.LIDAR_LOSS: {"drop_lidar_points"},
+            DegradationKind.POSE_STALENESS: {"pose_age_seconds"},
+            DegradationKind.DELAYED_FRAMES: {
+                "delay_seconds",
+                "late_result_policy",
+            },
+            DegradationKind.BOUNDED_DROP: {"drop_every_nth_frame"},
+            DegradationKind.TIMING_OFFSET: {"camera_lidar_offset_ms"},
+        }
+        if set(self.parameters) != expected[self.kind]:
+            raise DegradationRecoveryError(
+                "degradation scenario parameters are incompatible"
+            )
+        if self.kind is DegradationKind.CAMERA_LOSS:
+            _require_true(self.parameters["drop_camera_observations"])
+        elif self.kind is DegradationKind.LIDAR_LOSS:
+            _require_true(self.parameters["drop_lidar_points"])
+        elif self.kind is DegradationKind.POSE_STALENESS:
+            _positive_number(self.parameters["pose_age_seconds"], "pose age")
+        elif self.kind is DegradationKind.DELAYED_FRAMES:
+            _positive_number(self.parameters["delay_seconds"], "delivery delay")
+            if self.parameters["late_result_policy"] != "discard":
+                raise DegradationRecoveryError(
+                    "late E35 results must be discarded"
+                )
+        elif self.kind is DegradationKind.BOUNDED_DROP:
+            value = self.parameters["drop_every_nth_frame"]
+            if (
+                not isinstance(value, int)
+                or isinstance(value, bool)
+                or value < 2
+            ):
+                raise DegradationRecoveryError(
+                    "bounded drop cadence is invalid"
+                )
+        else:
+            value = self.parameters["camera_lidar_offset_ms"]
+            if (
+                not isinstance(value, int)
+                or isinstance(value, bool)
+                or abs(value) <= 100
+                or abs(value) > 1_000
+            ):
+                raise DegradationRecoveryError(
+                    "timing offset must exceed the admitted binding"
+                )
+
+    @property
+    def frame_count(self) -> int:
+        return self.frame_end - self.frame_start + 1
+
+    def active(self, frame_index: int) -> bool:
+        return self.frame_start <= frame_index <= self.frame_end
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "schema_version": E35_SCENARIO_SCHEMA,
+            "scenario_id": self.scenario_id,
+            "kind": self.kind.value,
+            "frame_start": self.frame_start,
+            "frame_end": self.frame_end,
+            "parameters": self.parameters,
+        }
+
+    @classmethod
+    def from_dict(cls, value: object) -> DegradationScenario:
+        document = _object(value, "degradation scenario")
+        if set(document) != {
+            "scenario_id",
+            "kind",
+            "frame_start",
+            "frame_end",
+            "parameters",
+        }:
+            raise DegradationRecoveryError(
+                "degradation scenario fields are incompatible"
+            )
+        try:
+            kind = DegradationKind(
+                _string(document.get("kind"), "degradation kind")
+            )
+        except ValueError as exc:
+            raise DegradationRecoveryError(
+                "degradation scenario kind is invalid"
+            ) from exc
+        parameters = _object(
+            document.get("parameters"),
+            "degradation scenario parameters",
+        )
+        return cls(
+            scenario_id=_string(document.get("scenario_id"), "scenario id"),
+            kind=kind,
+            frame_start=_integer(document.get("frame_start"), "frame start"),
+            frame_end=_integer(document.get("frame_end"), "frame end"),
+            parameters=parameters,
+        )
+
+
+@dataclass(frozen=True, slots=True)
+class TransformedTrackGeometryFrame:
+    """One E35 frame and its explicit transformation document."""
+
+    frame: TrackGeometryFrame
+    transformation: dict[str, Any]
+
+
+def transform_track_geometry_frame(
+    frame: TrackGeometryFrame,
+    scenario: DegradationScenario,
+) -> TransformedTrackGeometryFrame:
+    """Apply one scenario without mutating the accepted source frame."""
+
+    if not scenario.active(frame.frame_index):
+        return TransformedTrackGeometryFrame(
+            frame=frame,
+            transformation=_transformation(
+                frame,
+                scenario,
+                active=False,
+                action="none",
+                channels=_nominal_channels(frame),
+                transformed_frame=frame,
+            ),
+        )
+
+    if scenario.kind is DegradationKind.CAMERA_LOSS:
+        transformed = _camera_loss(frame)
+        action = "camera-observations-removed"
+        channels = {
+            "camera": "unavailable",
+            "lidar": _lidar_state(frame),
+            "pose": "available",
+            "delivery": "on-time",
+        }
+    elif scenario.kind is DegradationKind.LIDAR_LOSS:
+        transformed = _metric_unavailable(
+            frame,
+            reason="e35-lidar-unavailable",
+            source_available=False,
+        )
+        action = "lidar-points-withheld"
+        channels = {
+            "camera": "available",
+            "lidar": "unavailable",
+            "pose": "available",
+            "delivery": "on-time",
+        }
+    elif scenario.kind is DegradationKind.POSE_STALENESS:
+        transformed = _metric_unavailable(
+            frame,
+            reason="e35-pose-stale",
+            source_available=frame.source_available,
+        )
+        action = "map-points-withheld-for-stale-pose"
+        channels = {
+            "camera": "available",
+            "lidar": _lidar_state(frame),
+            "pose": "stale",
+            "delivery": "on-time",
+        }
+    elif scenario.kind is DegradationKind.DELAYED_FRAMES:
+        transformed = _empty_frame(frame)
+        action = "late-frame-discarded"
+        channels = {
+            "camera": "late-discarded",
+            "lidar": "late-discarded",
+            "pose": "late-discarded",
+            "delivery": "late-discarded",
+        }
+    elif scenario.kind is DegradationKind.BOUNDED_DROP:
+        cadence = int(scenario.parameters["drop_every_nth_frame"])
+        dropped = (frame.frame_index - scenario.frame_start) % cadence == 0
+        transformed = _empty_frame(frame) if dropped else frame
+        action = "input-frame-dropped" if dropped else "bounded-drop-pass"
+        channels = (
+            {
+                "camera": "dropped",
+                "lidar": "dropped",
+                "pose": "dropped",
+                "delivery": "dropped",
+            }
+            if dropped
+            else _nominal_channels(frame)
+        )
+    else:
+        transformed = _timing_offset(frame)
+        action = "camera-lidar-evidence-split"
+        channels = {
+            "camera": "offset",
+            "lidar": _lidar_state(frame),
+            "pose": "available",
+            "delivery": "on-time",
+        }
+
+    return TransformedTrackGeometryFrame(
+        frame=transformed,
+        transformation=_transformation(
+            frame,
+            scenario,
+            active=True,
+            action=action,
+            channels=channels,
+            transformed_frame=transformed,
+        ),
+    )
+
+
+def frame_digest(frame: TrackGeometryFrame) -> str:
+    """Digest one complete frame without serializing large point arrays."""
+
+    digest = hashlib.sha256()
+    compact = {
+        "binding": frame.binding.to_dict(),
+        "frame_index": frame.frame_index,
+        "source_frame_index": frame.source_frame_index,
+        "session_seconds": frame.session_seconds,
+        "source_available": frame.source_available,
+        "source_point_count": frame.point_slab.source_point_count,
+        "coordinate_frame": frame.point_slab.coordinate_frame,
+        "owner_keys": list(frame.point_slab.owner_keys),
+        "geometries": [geometry.to_dict() for geometry in frame.geometries],
+    }
+    digest.update(_canonical_json(compact))
+    digest.update(frame.point_slab.source_indices.astype("<i8", copy=False).tobytes())
+    digest.update(frame.point_slab.points_xyz_m.astype("<f4", copy=False).tobytes())
+    digest.update(frame.point_slab.owner_indices.astype("<u4", copy=False).tobytes())
+    return digest.hexdigest()
+
+
+def _camera_loss(frame: TrackGeometryFrame) -> TrackGeometryFrame:
+    geometries: list[TrackGeometry] = []
+    owner_map: dict[str, str | None] = {}
+    for geometry in frame.geometries:
+        if geometry.owner_kind is TrackGeometryOwnerKind.GEOMETRY_CLUSTER:
+            geometries.append(geometry)
+            if geometry.metric_basis is TrackGeometryMetricBasis.CURRENT_POINTS:
+                owner_map[geometry.owner_key] = geometry.owner_key
+            continue
+        if geometry.metric_basis is not TrackGeometryMetricBasis.CURRENT_POINTS:
+            owner_map[geometry.owner_key] = None
+            continue
+        owner_key = f"e35-camera-loss:{geometry.owner_key}"
+        geometries.append(
+            TrackGeometry(
+                owner_key=owner_key,
+                owner_kind=TrackGeometryOwnerKind.GEOMETRY_CLUSTER,
+                evidence_state=TrackGeometryEvidenceState.GEOMETRY_ONLY,
+                currentness=TrackGeometryCurrentness.CURRENT,
+                metric_basis=TrackGeometryMetricBasis.CURRENT_POINTS,
+                reason_codes=(
+                    "e35-camera-unavailable",
+                    "geometry-retained-without-semantics",
+                ),
+                range_m=geometry.range_m,
+            )
+        )
+        owner_map[geometry.owner_key] = owner_key
+    return _frame_with(
+        frame,
+        geometries=geometries,
+        point_slab=_remap_slab(frame, geometries, owner_map),
+        source_available=frame.source_available,
+    )
+
+
+def _metric_unavailable(
+    frame: TrackGeometryFrame,
+    *,
+    reason: str,
+    source_available: bool,
+) -> TrackGeometryFrame:
+    geometries: list[TrackGeometry] = []
+    for geometry in frame.geometries:
+        if geometry.owner_kind is TrackGeometryOwnerKind.GEOMETRY_CLUSTER:
+            continue
+        if geometry.metric_basis is TrackGeometryMetricBasis.CURRENT_POINTS:
+            geometries.append(
+                TrackGeometry(
+                    owner_key=geometry.owner_key,
+                    owner_kind=TrackGeometryOwnerKind.CAMERA_TRACK,
+                    evidence_state=TrackGeometryEvidenceState.CAMERA_ONLY,
+                    currentness=TrackGeometryCurrentness.CURRENT,
+                    metric_basis=TrackGeometryMetricBasis.UNAVAILABLE,
+                    reason_codes=(reason, "camera-remains-nonmetric"),
+                    semantic_track_id=geometry.semantic_track_id,
+                    semantic_label=geometry.semantic_label,
+                    bbox_xyxy=geometry.bbox_xyxy,
+                )
+            )
+        else:
+            geometries.append(geometry)
+    return _frame_with(
+        frame,
+        geometries=geometries,
+        point_slab=_empty_slab(frame),
+        source_available=source_available,
+    )
+
+
+def _timing_offset(frame: TrackGeometryFrame) -> TrackGeometryFrame:
+    geometries: list[TrackGeometry] = []
+    owner_map: dict[str, str | None] = {}
+    for geometry in frame.geometries:
+        if (
+            geometry.owner_kind is TrackGeometryOwnerKind.CAMERA_TRACK
+            and geometry.metric_basis is TrackGeometryMetricBasis.CURRENT_POINTS
+        ):
+            geometries.append(
+                TrackGeometry(
+                    owner_key=geometry.owner_key,
+                    owner_kind=TrackGeometryOwnerKind.CAMERA_TRACK,
+                    evidence_state=TrackGeometryEvidenceState.CAMERA_ONLY,
+                    currentness=TrackGeometryCurrentness.CURRENT,
+                    metric_basis=TrackGeometryMetricBasis.UNAVAILABLE,
+                    reason_codes=(
+                        "e35-camera-lidar-offset-unqualified",
+                        "camera-remains-nonmetric",
+                    ),
+                    semantic_track_id=geometry.semantic_track_id,
+                    semantic_label=geometry.semantic_label,
+                    bbox_xyxy=geometry.bbox_xyxy,
+                )
+            )
+            geometry_owner = f"e35-timing-offset:{geometry.owner_key}"
+            geometries.append(
+                TrackGeometry(
+                    owner_key=geometry_owner,
+                    owner_kind=TrackGeometryOwnerKind.GEOMETRY_CLUSTER,
+                    evidence_state=TrackGeometryEvidenceState.GEOMETRY_ONLY,
+                    currentness=TrackGeometryCurrentness.CURRENT,
+                    metric_basis=TrackGeometryMetricBasis.CURRENT_POINTS,
+                    reason_codes=(
+                        "e35-camera-lidar-offset-unqualified",
+                        "geometry-retained-without-semantics",
+                    ),
+                    range_m=geometry.range_m,
+                )
+            )
+            owner_map[geometry.owner_key] = geometry_owner
+        else:
+            geometries.append(geometry)
+            if geometry.metric_basis is TrackGeometryMetricBasis.CURRENT_POINTS:
+                owner_map[geometry.owner_key] = geometry.owner_key
+    return _frame_with(
+        frame,
+        geometries=geometries,
+        point_slab=_remap_slab(frame, geometries, owner_map),
+        source_available=frame.source_available,
+    )
+
+
+def _empty_frame(frame: TrackGeometryFrame) -> TrackGeometryFrame:
+    return _frame_with(
+        frame,
+        geometries=[],
+        point_slab=_empty_slab(frame),
+        source_available=False,
+    )
+
+
+def _frame_with(
+    frame: TrackGeometryFrame,
+    *,
+    geometries: list[TrackGeometry],
+    point_slab: PointSlab,
+    source_available: bool,
+) -> TrackGeometryFrame:
+    return TrackGeometryFrame(
+        binding=frame.binding,
+        frame_index=frame.frame_index,
+        source_frame_index=frame.source_frame_index,
+        session_seconds=frame.session_seconds,
+        source_available=source_available,
+        point_slab=point_slab,
+        geometries=tuple(geometries),
+    )
+
+
+def _empty_slab(frame: TrackGeometryFrame) -> PointSlab:
+    return PointSlab(
+        frame_index=frame.frame_index,
+        source_frame_index=frame.source_frame_index,
+        source_point_count=frame.point_slab.source_point_count,
+        coordinate_frame=frame.point_slab.coordinate_frame,
+        owner_keys=(),
+        source_indices=np.empty(0, dtype="<i8"),
+        points_xyz_m=np.empty((0, 3), dtype="<f4"),
+        owner_indices=np.empty(0, dtype="<u4"),
+    )
+
+
+def _remap_slab(
+    frame: TrackGeometryFrame,
+    geometries: list[TrackGeometry],
+    owner_map: dict[str, str | None],
+) -> PointSlab:
+    owner_keys = tuple(
+        geometry.owner_key
+        for geometry in geometries
+        if geometry.metric_basis is TrackGeometryMetricBasis.CURRENT_POINTS
+    )
+    owner_indices_by_key = {
+        owner_key: owner_index
+        for owner_index, owner_key in enumerate(owner_keys)
+    }
+    source_indices: list[int] = []
+    points: list[list[float]] = []
+    owner_indices: list[int] = []
+    for row_index, source_index in enumerate(frame.point_slab.source_indices):
+        old_owner = frame.point_slab.owner_keys[
+            int(frame.point_slab.owner_indices[row_index])
+        ]
+        new_owner = owner_map.get(old_owner)
+        if new_owner is None:
+            continue
+        source_indices.append(int(source_index))
+        points.append(frame.point_slab.points_xyz_m[row_index].tolist())
+        owner_indices.append(owner_indices_by_key[new_owner])
+    return PointSlab(
+        frame_index=frame.frame_index,
+        source_frame_index=frame.source_frame_index,
+        source_point_count=frame.point_slab.source_point_count,
+        coordinate_frame=frame.point_slab.coordinate_frame,
+        owner_keys=owner_keys,
+        source_indices=np.asarray(source_indices, dtype="<i8"),
+        points_xyz_m=(
+            np.asarray(points, dtype="<f4")
+            if points
+            else np.empty((0, 3), dtype="<f4")
+        ),
+        owner_indices=np.asarray(owner_indices, dtype="<u4"),
+    )
+
+
+def _transformation(
+    original_frame: TrackGeometryFrame,
+    scenario: DegradationScenario,
+    *,
+    active: bool,
+    action: str,
+    channels: dict[str, str],
+    transformed_frame: TrackGeometryFrame,
+) -> dict[str, Any]:
+    return {
+        "schema_version": E35_TRANSFORMATION_SCHEMA,
+        "scenario_id": scenario.scenario_id,
+        "kind": scenario.kind.value,
+        "frame_index": original_frame.frame_index,
+        "active": active,
+        "action": action,
+        "parameters": scenario.parameters if active else {},
+        "channels": channels,
+        "original_frame_sha256": frame_digest(original_frame),
+        "transformed_frame_sha256": frame_digest(transformed_frame),
+        "original": _frame_counts(original_frame),
+        "transformed": _frame_counts(transformed_frame),
+        "policy": {
+            "absence_of_points_means_free": False,
+            "late_results_may_reenter": False,
+            "persistent_reconstruction_modified": False,
+        },
+        "authority": _authority(),
+    }
+
+
+def _frame_counts(frame: TrackGeometryFrame) -> dict[str, int | bool]:
+    return {
+        "source_available": frame.source_available,
+        "point_rows": frame.point_slab.row_count,
+        "camera_tracks": sum(
+            geometry.owner_kind is TrackGeometryOwnerKind.CAMERA_TRACK
+            for geometry in frame.geometries
+        ),
+        "geometry_clusters": sum(
+            geometry.owner_kind is TrackGeometryOwnerKind.GEOMETRY_CLUSTER
+            for geometry in frame.geometries
+        ),
+        "agree": sum(
+            geometry.evidence_state is TrackGeometryEvidenceState.AGREE
+            for geometry in frame.geometries
+        ),
+    }
+
+
+def _nominal_channels(frame: TrackGeometryFrame) -> dict[str, str]:
+    return {
+        "camera": "available",
+        "lidar": _lidar_state(frame),
+        "pose": "available",
+        "delivery": "on-time",
+    }
+
+
+def _lidar_state(frame: TrackGeometryFrame) -> str:
+    return "available" if frame.source_available else "source-unavailable"
+
+
+def _canonical_json(value: object) -> bytes:
+    return json.dumps(
+        value,
+        ensure_ascii=False,
+        sort_keys=True,
+        separators=(",", ":"),
+        allow_nan=False,
+    ).encode("utf-8")
+
+
+def _authority() -> dict[str, bool]:
+    return {
+        "commands_enabled": False,
+        "navigation_or_safety_accepted": False,
+    }
+
+
+def _require_true(value: object) -> None:
+    if value is not True:
+        raise DegradationRecoveryError(
+            "degradation source removal must be enabled"
+        )
+
+
+def _positive_number(value: object, label: str) -> float:
+    if (
+        not isinstance(value, (int, float))
+        or isinstance(value, bool)
+        or not math.isfinite(float(value))
+        or float(value) <= 0.0
+    ):
+        raise DegradationRecoveryError(f"{label} is invalid")
+    return float(value)
+
+
+def _integer(value: object, label: str) -> int:
+    if not isinstance(value, int) or isinstance(value, bool):
+        raise DegradationRecoveryError(f"{label} is invalid")
+    return value
+
+
+def _string(value: object, label: str) -> str:
+    if not isinstance(value, str) or not value:
+        raise DegradationRecoveryError(f"{label} is invalid")
+    return value
+
+
+def _object(value: object, label: str) -> dict[str, Any]:
+    if not isinstance(value, dict) or any(
+        not isinstance(key, str) for key in value
+    ):
+        raise DegradationRecoveryError(f"{label} must be an object")
+    return value
diff --git a/src/k1link/compute/e35_degradation_replay.py b/src/k1link/compute/e35_degradation_replay.py
new file mode 100644
index 0000000..4b41c35
--- /dev/null
+++ b/src/k1link/compute/e35_degradation_replay.py
@@ -0,0 +1,1283 @@
+"""Immutable E35 degradation and recovery replay over E32/E33/E34 evidence."""
+
+from __future__ import annotations
+
+import copy
+import hashlib
+import json
+import math
+import os
+import re
+import shutil
+import time
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Final, TextIO
+
+import numpy as np
+
+from k1link.artifacts import utc_now_iso
+
+from .degradation_recovery import (
+    DegradationKind,
+    DegradationRecoveryError,
+    DegradationScenario,
+    transform_track_geometry_frame,
+)
+from .e32_track_geometry_replay import (
+    E32TrackGeometryReplay,
+    read_e32_track_geometry_replay,
+)
+from .e32_track_geometry_storage import (
+    E32TrackGeometryStorageError,
+    frame_from_record,
+    load_point_storage,
+    record,
+)
+from .e33_worker_shadow import (
+    E33WorkerShadowResult,
+    read_e33_worker_shadow_result,
+)
+from .e34_temporal_occupied_replay import (
+    E34TemporalOccupiedReplay,
+    read_e34_temporal_occupied_replay,
+    read_e34_temporal_profile,
+)
+from .temporal_occupied_layer import (
+    TemporalLayerConfig,
+    TemporalOccupiedLayer,
+    TemporalOccupiedLayerError,
+)
+from .track_geometry import (
+    TrackGeometryEvidenceState,
+    TrackGeometryFrame,
+    TrackGeometryOwnerKind,
+    TrackGeometrySourceBinding,
+)
+
+E35_PROFILE_SCHEMA: Final = "missioncore.e35-degradation-profile/v1"
+E35_RESULT_SCHEMA: Final = "missioncore.e35-degradation-result/v1"
+E35_OUTCOME_SCHEMA: Final = "missioncore.e35-variant-frame-outcome/v1"
+E35_JOURNAL_SCHEMA: Final = "missioncore.e35-injection-journal/v1"
+E35_REVIEW_SCHEMA: Final = "missioncore.e35-recovery-review/v1"
+E35_REPORT_SCHEMA: Final = "missioncore.e35-degradation-report/v1"
+
+E35_OUTCOMES_NAME: Final = "variant-frame-outcomes.jsonl"
+E35_JOURNAL_NAME: Final = "injection-journal.jsonl"
+E35_REVIEW_NAME: Final = "review-timeline.json"
+E35_REPORT_NAME: Final = "run-report.json"
+E35_MANIFEST_NAME: Final = "manifest.json"
+
+_E32_RESULT_ID = re.compile(r"^e32-track-geometry-[a-f0-9]{64}$")
+_E33_RESULT_ID = re.compile(r"^e33-worker-shadow-[a-f0-9]{64}$")
+_E34_RESULT_ID = re.compile(r"^e34-temporal-occupied-[a-f0-9]{64}$")
+_E35_RESULT_ID = re.compile(r"^e35-degradation-recovery-[a-f0-9]{64}$")
+_SHA256 = re.compile(r"^[a-f0-9]{64}$")
+
+
+class E35DegradationReplayError(RuntimeError):
+    """The E35 profile, input, replay or immutable result is invalid."""
+
+
+@dataclass(frozen=True, slots=True)
+class E35DegradationReplay:
+    """One fully validated immutable E35 result."""
+
+    result_root: Path
+    result_id: str
+    manifest: dict[str, Any]
+    report: dict[str, Any]
+    review: dict[str, Any]
+
+    @property
+    def accepted(self) -> bool:
+        return bool(self.report["acceptance"]["accepted"])
+
+
+def build_e35_degradation_replay(
+    *,
+    e32_result_root: Path,
+    e33_result_root: Path,
+    e34_result_root: Path,
+    e34_profile_path: Path,
+    profile_path: Path,
+    output_root: Path,
+) -> E35DegradationReplay:
+    """Build or verify a complete six-variant E35 replay."""
+
+    e32 = read_e32_track_geometry_replay(e32_result_root)
+    e33 = read_e33_worker_shadow_result(e33_result_root)
+    e34 = read_e34_temporal_occupied_replay(e34_result_root)
+    e34_profile, config = read_e34_temporal_profile(e34_profile_path)
+    profile, scenarios = read_e35_degradation_profile(profile_path)
+    _validate_upstream(
+        e32=e32,
+        e33=e33,
+        e34=e34,
+        e34_profile=e34_profile,
+        profile=profile,
+    )
+    artifact_sets = {
+        "e32": _verified_artifacts(
+            e32.result_root,
+            e32.manifest.get("artifacts"),
+            role_key="role",
+        ),
+        "e33": _verified_artifacts(
+            e33.result_root,
+            e33.result.get("artifacts"),
+            role_key="kind",
+        ),
+        "e34": _verified_artifacts(
+            e34.result_root,
+            e34.manifest.get("artifacts"),
+            role_key="kind",
+        ),
+    }
+    upstream_before = {
+        key: _artifact_identity(value)
+        for key, value in artifact_sets.items()
+    }
+    e32_identity = _object(e32.manifest.get("identity"), "E32 identity")
+    binding = TrackGeometrySourceBinding.from_dict(
+        e32_identity.get("track_geometry_binding")
+    )
+    identity = {
+        "schema_version": E35_RESULT_SCHEMA,
+        "pipeline": "track-geometry/temporal-layer/degradation-recovery/v1",
+        "profile": profile,
+        "profile_sha256": _sha256(profile_path.resolve(strict=True)),
+        "frozen_e34_profile": e34_profile,
+        "frozen_e34_profile_sha256": _sha256(
+            e34_profile_path.resolve(strict=True)
+        ),
+        "e32_result_id": e32.result_id,
+        "e32_identity_sha256": e32.manifest["identity_sha256"],
+        "e33_result_id": e33.result_id,
+        "e33_identity_sha256": e33.result["identity_sha256"],
+        "e34_result_id": e34.result_id,
+        "e34_identity_sha256": e34.manifest["identity_sha256"],
+        "source_session_id": binding.source_session_id,
+        "coordinate_frame": binding.coordinate_frame,
+        "frame_count": e32_identity["frame_count"],
+        "variant_count": len(scenarios),
+        "timeline_start_seconds": e32_identity["timeline_start_seconds"],
+        "timeline_end_seconds": e32_identity["timeline_end_seconds"],
+        "upstream_artifacts": upstream_before,
+        "producer": {
+            "e35_replay_sha256": _sha256(Path(__file__)),
+            "degradation_transform_sha256": _sha256(
+                Path(__file__).with_name("degradation_recovery.py")
+            ),
+            "temporal_layer_sha256": _sha256(
+                Path(__file__).with_name("temporal_occupied_layer.py")
+            ),
+        },
+        "policy": copy.deepcopy(profile["policy"]),
+        "authority": _authority(),
+    }
+    identity_sha256 = hashlib.sha256(_canonical_json(identity)).hexdigest()
+    result_id = f"e35-degradation-recovery-{identity_sha256}"
+    destination = output_root.expanduser().absolute()
+    destination.mkdir(mode=0o700, parents=True, exist_ok=True)
+    result_root = destination / result_id
+    if result_root.exists():
+        return read_e35_degradation_replay(result_root)
+    staging = destination / f".{result_id}.{os.getpid()}.incomplete"
+    staging.mkdir(mode=0o700, exist_ok=False)
+    try:
+        report, review = _run_replay(
+            staging=staging,
+            result_id=result_id,
+            identity=identity,
+            e32=e32,
+            e32_artifacts=artifact_sets["e32"],
+            scenarios=scenarios,
+            config=config,
+        )
+        upstream_after = {
+            key: _artifact_identity(value)
+            for key, value in artifact_sets.items()
+        }
+        report = _finalize_report(
+            report,
+            profile=profile,
+            upstream_unchanged=upstream_after == upstream_before,
+        )
+        _write_json(staging / E35_REVIEW_NAME, review)
+        _write_json(staging / E35_REPORT_NAME, report)
+        artifacts = [
+            _artifact(
+                staging / E35_OUTCOMES_NAME,
+                "variant-frame-outcomes",
+                "application/x-ndjson",
+                E35_OUTCOME_SCHEMA,
+            ),
+            _artifact(
+                staging / E35_JOURNAL_NAME,
+                "injection-journal",
+                "application/x-ndjson",
+                E35_JOURNAL_SCHEMA,
+            ),
+            _artifact(
+                staging / E35_REVIEW_NAME,
+                "review-timeline",
+                "application/json",
+                E35_REVIEW_SCHEMA,
+            ),
+            _artifact(
+                staging / E35_REPORT_NAME,
+                "run-report",
+                "application/json",
+                E35_REPORT_SCHEMA,
+            ),
+        ]
+        manifest = {
+            "schema_version": E35_RESULT_SCHEMA,
+            "result_id": result_id,
+            "identity_sha256": identity_sha256,
+            "identity": identity,
+            "created_at_utc": report["created_at_utc"],
+            "acceptance_state": (
+                "accepted-deterministic-degradation-recovery"
+                if report["acceptance"]["accepted"]
+                else "rejected-fail-closed"
+            ),
+            "publication_scope": "diagnostic-shadow-only",
+            "ground_truth": False,
+            "artifacts": artifacts,
+            "authority": _authority(),
+        }
+        _write_json(staging / E35_MANIFEST_NAME, manifest)
+        os.replace(staging, result_root)
+    except BaseException:
+        shutil.rmtree(staging, ignore_errors=True)
+        raise
+    return read_e35_degradation_replay(result_root)
+
+
+def read_e35_degradation_replay(root: Path) -> E35DegradationReplay:
+    """Read and strictly validate one immutable E35 result."""
+
+    resolved = root.expanduser().resolve(strict=True)
+    if not resolved.is_dir() or _E35_RESULT_ID.fullmatch(resolved.name) is None:
+        raise E35DegradationReplayError("E35 result root is invalid")
+    manifest = _read_json(resolved / E35_MANIFEST_NAME)
+    identity = _object(manifest.get("identity"), "E35 identity")
+    identity_sha256 = manifest.get("identity_sha256")
+    if (
+        manifest.get("schema_version") != E35_RESULT_SCHEMA
+        or manifest.get("result_id") != resolved.name
+        or not isinstance(identity_sha256, str)
+        or _SHA256.fullmatch(identity_sha256) is None
+        or resolved.name != f"e35-degradation-recovery-{identity_sha256}"
+        or hashlib.sha256(_canonical_json(identity)).hexdigest()
+        != identity_sha256
+        or manifest.get("publication_scope") != "diagnostic-shadow-only"
+        or manifest.get("ground_truth") is not False
+        or manifest.get("authority") != _authority()
+    ):
+        raise E35DegradationReplayError("E35 result identity is inconsistent")
+    artifacts = _verified_artifacts(
+        resolved,
+        manifest.get("artifacts"),
+        role_key="kind",
+    )
+    expected_roles = {
+        "variant-frame-outcomes",
+        "injection-journal",
+        "review-timeline",
+        "run-report",
+    }
+    if set(artifacts) != expected_roles:
+        raise E35DegradationReplayError("E35 artifact set changed")
+    report = _read_json(artifacts["run-report"])
+    review = _read_json(artifacts["review-timeline"])
+    acceptance = _object(report.get("acceptance"), "E35 acceptance")
+    accepted = _boolean(acceptance.get("accepted"), "E35 accepted")
+    if (
+        report.get("schema_version") != E35_REPORT_SCHEMA
+        or report.get("result_id") != resolved.name
+        or report.get("identity") != identity
+        or report.get("authority") != _authority()
+        or review.get("schema_version") != E35_REVIEW_SCHEMA
+        or review.get("result_id") != resolved.name
+        or review.get("authority") != _authority()
+        or manifest.get("acceptance_state")
+        != (
+            "accepted-deterministic-degradation-recovery"
+            if accepted
+            else "rejected-fail-closed"
+        )
+    ):
+        raise E35DegradationReplayError(
+            "E35 report or review identity is inconsistent"
+        )
+    frame_count = _positive_int(identity.get("frame_count"), "E35 frame count")
+    variant_count = _positive_int(
+        identity.get("variant_count"),
+        "E35 variant count",
+    )
+    observed_outcomes = _validate_outcomes(
+        artifacts["variant-frame-outcomes"],
+        frame_count=frame_count,
+        variant_count=variant_count,
+    )
+    observed_journal = _validate_journal(artifacts["injection-journal"])
+    metrics = _object(report.get("metrics"), "E35 metrics")
+    accounting = _object(metrics.get("accounting"), "E35 accounting")
+    if (
+        observed_outcomes != frame_count * variant_count
+        or observed_outcomes != accounting.get("variant_frame_outcomes")
+        or observed_journal != accounting.get("injection_records")
+    ):
+        raise E35DegradationReplayError("E35 artifact accounting changed")
+    return E35DegradationReplay(
+        result_root=resolved,
+        result_id=resolved.name,
+        manifest=manifest,
+        report=report,
+        review=review,
+    )
+
+
+def read_e35_degradation_profile(
+    path: Path,
+) -> tuple[dict[str, Any], tuple[DegradationScenario, ...]]:
+    """Read the predeclared six-scenario E35 profile."""
+
+    profile = _read_json(path.resolve(strict=True))
+    expected_keys = {
+        "schema_version",
+        "profile_id",
+        "expected_e32_result_id",
+        "expected_e33_result_id",
+        "expected_e34_result_id",
+        "scenarios",
+        "acceptance",
+        "policy",
+        "authority",
+    }
+    if (
+        set(profile) != expected_keys
+        or profile.get("schema_version") != E35_PROFILE_SCHEMA
+        or not isinstance(profile.get("profile_id"), str)
+        or not isinstance(profile.get("expected_e32_result_id"), str)
+        or _E32_RESULT_ID.fullmatch(profile["expected_e32_result_id"]) is None
+        or not isinstance(profile.get("expected_e33_result_id"), str)
+        or _E33_RESULT_ID.fullmatch(profile["expected_e33_result_id"]) is None
+        or not isinstance(profile.get("expected_e34_result_id"), str)
+        or _E34_RESULT_ID.fullmatch(profile["expected_e34_result_id"]) is None
+        or profile.get("authority") != _authority()
+    ):
+        raise E35DegradationReplayError("E35 profile identity is invalid")
+    try:
+        scenarios = tuple(
+            DegradationScenario.from_dict(value)
+            for value in _array(profile.get("scenarios"), "E35 scenarios")
+        )
+    except DegradationRecoveryError as exc:
+        raise E35DegradationReplayError(str(exc)) from exc
+    kinds = {scenario.kind for scenario in scenarios}
+    expected_kinds = set(DegradationKind)
+    intervals = [
+        (scenario.frame_start, scenario.frame_end)
+        for scenario in scenarios
+    ]
+    if (
+        len(scenarios) != len(expected_kinds)
+        or kinds != expected_kinds
+        or len({scenario.scenario_id for scenario in scenarios})
+        != len(scenarios)
+        or any(
+            start_a <= end_b and start_b <= end_a
+            for index, (start_a, end_a) in enumerate(intervals)
+            for start_b, end_b in intervals[index + 1 :]
+        )
+    ):
+        raise E35DegradationReplayError(
+            "E35 requires six unique non-overlapping scenarios"
+        )
+    acceptance = _object(profile.get("acceptance"), "E35 acceptance")
+    policy = _object(profile.get("policy"), "E35 policy")
+    required_acceptance = {
+        "expected_scenario_count",
+        "maximum_recovery_seconds",
+        "maximum_hidden_success_frames",
+        "maximum_false_free_rows",
+        "maximum_semantic_claims_during_camera_loss",
+        "maximum_metric_rows_during_lidar_or_pose_loss",
+        "maximum_late_results_reintroduced",
+        "require_complete_variant_frame_accounting",
+        "require_exact_upstream_artifact_identity",
+        "require_explicit_injection_journal",
+        "require_every_variant_to_recover",
+    }
+    expected_policy = {
+        "absence_of_points_means_free": False,
+        "late_results_may_reenter": False,
+        "timing_mismatch_may_publish_agree": False,
+        "pose_stale_points_may_publish_map_occupancy": False,
+        "persistent_reconstruction_mutation_allowed": False,
+    }
+    if (
+        set(acceptance) != required_acceptance
+        or acceptance.get("expected_scenario_count") != len(expected_kinds)
+        or policy != expected_policy
+        or any(
+            acceptance.get(key) is not True
+            for key in (
+                "require_complete_variant_frame_accounting",
+                "require_exact_upstream_artifact_identity",
+                "require_explicit_injection_journal",
+                "require_every_variant_to_recover",
+            )
+        )
+    ):
+        raise E35DegradationReplayError(
+            "E35 conservative acceptance contract changed"
+        )
+    _positive_float(
+        acceptance.get("maximum_recovery_seconds"),
+        "E35 maximum recovery",
+    )
+    for key in (
+        "maximum_hidden_success_frames",
+        "maximum_false_free_rows",
+        "maximum_semantic_claims_during_camera_loss",
+        "maximum_metric_rows_during_lidar_or_pose_loss",
+        "maximum_late_results_reintroduced",
+    ):
+        _nonnegative_int(acceptance.get(key), f"E35 {key}")
+    return profile, scenarios
+
+
+def _run_replay(
+    *,
+    staging: Path,
+    result_id: str,
+    identity: dict[str, Any],
+    e32: E32TrackGeometryReplay,
+    e32_artifacts: dict[str, Path],
+    scenarios: tuple[DegradationScenario, ...],
+    config: TemporalLayerConfig,
+) -> tuple[dict[str, Any], dict[str, Any]]:
+    e32_identity = _object(e32.manifest.get("identity"), "E32 identity")
+    frame_count = _positive_int(e32_identity.get("frame_count"), "E32 frame count")
+    try:
+        offsets, source_indices, points, owner_indices = load_point_storage(
+            e32_artifacts,
+            frame_count=frame_count,
+        )
+    except E32TrackGeometryStorageError as exc:
+        raise E35DegradationReplayError(str(exc)) from exc
+    if any(scenario.frame_end + 1 >= frame_count for scenario in scenarios):
+        raise E35DegradationReplayError(
+            "E35 scenario lacks a post-fault recovery frame"
+        )
+    binding = TrackGeometrySourceBinding.from_dict(
+        e32_identity.get("track_geometry_binding")
+    )
+    layers = {
+        scenario.scenario_id: TemporalOccupiedLayer(config)
+        for scenario in scenarios
+    }
+    metrics = {
+        scenario.scenario_id: _initial_scenario_metrics(scenario)
+        for scenario in scenarios
+    }
+    review_indices = {
+        scenario.scenario_id: {
+            scenario.frame_start - 1,
+            scenario.frame_start,
+            (scenario.frame_start + scenario.frame_end) // 2,
+            scenario.frame_end,
+            scenario.frame_end + 1,
+        }
+        for scenario in scenarios
+    }
+    reviews: dict[str, list[dict[str, Any]]] = {
+        scenario.scenario_id: [] for scenario in scenarios
+    }
+    processing_ms: list[float] = []
+    started = time.perf_counter()
+    observed_frames = 0
+    with (
+        e32_artifacts["track-geometry-frames"].open(
+            "r",
+            encoding="utf-8",
+        ) as source,
+        (staging / E35_OUTCOMES_NAME).open(
+            "x",
+            encoding="utf-8",
+            newline="\n",
+        ) as outcomes,
+        (staging / E35_JOURNAL_NAME).open(
+            "x",
+            encoding="utf-8",
+            newline="\n",
+        ) as journal,
+    ):
+        for frame_index, line in enumerate(source):
+            if frame_index >= frame_count:
+                raise E35DegradationReplayError(
+                    "E32 frame stream has extra rows"
+                )
+            value = record(line, expected_frame_index=frame_index)
+            try:
+                source_frame = frame_from_record(
+                    record_value=value,
+                    binding=binding,
+                    frame_offsets=offsets,
+                    source_indices=source_indices,
+                    points=points,
+                    owner_indices=owner_indices,
+                )
+            except E32TrackGeometryStorageError as exc:
+                raise E35DegradationReplayError(str(exc)) from exc
+            for scenario in scenarios:
+                frame_started = time.perf_counter()
+                transformed = transform_track_geometry_frame(
+                    source_frame,
+                    scenario,
+                )
+                try:
+                    projection = layers[scenario.scenario_id].update(
+                        transformed.frame
+                    )
+                except TemporalOccupiedLayerError as exc:
+                    raise E35DegradationReplayError(str(exc)) from exc
+                outcome = _frame_outcome(
+                    scenario=scenario,
+                    source_frame=source_frame,
+                    transformed_frame=transformed.frame,
+                    transformation=transformed.transformation,
+                    projection=projection.document,
+                )
+                _write_jsonl(outcomes, outcome)
+                if transformed.transformation["active"]:
+                    transformation = transformed.transformation
+                    _write_jsonl(
+                        journal,
+                        {
+                            **{
+                                key: value
+                                for key, value in transformation.items()
+                                if key != "schema_version"
+                            },
+                            "schema_version": E35_JOURNAL_SCHEMA,
+                            "transformation_schema_version": transformation[
+                                "schema_version"
+                            ],
+                        },
+                    )
+                _observe_metrics(
+                    metrics[scenario.scenario_id],
+                    scenario=scenario,
+                    source_frame=source_frame,
+                    transformed_frame=transformed.frame,
+                    transformation=transformed.transformation,
+                    projection=projection.document,
+                )
+                if frame_index in review_indices[scenario.scenario_id]:
+                    reviews[scenario.scenario_id].append(
+                        _review_frame(
+                            scenario=scenario,
+                            source_frame=source_frame,
+                            transformed_frame=transformed.frame,
+                            transformation=transformed.transformation,
+                            projection=projection.document,
+                            cell_rows=projection.cell_rows,
+                            voxel_size_m=config.voxel_size_m,
+                        )
+                    )
+                processing_ms.append(
+                    (time.perf_counter() - frame_started) * 1_000.0
+                )
+            observed_frames += 1
+    if observed_frames != frame_count:
+        raise E35DegradationReplayError("E32 frame stream is incomplete")
+    scenario_reports = []
+    for scenario in scenarios:
+        scenario_metrics = metrics[scenario.scenario_id]
+        _finish_scenario_metrics(scenario_metrics)
+        scenario_reports.append(scenario_metrics)
+    review = {
+        "schema_version": E35_REVIEW_SCHEMA,
+        "result_id": result_id,
+        "selection": {
+            "policy": "pre-fault/start/mid/end/post-recovery-per-scenario/v1",
+            "frames_per_scenario": 5,
+            "not_ground_truth": True,
+        },
+        "voxel_size_m": config.voxel_size_m,
+        "scenarios": [
+            {
+                "scenario": scenario.to_dict(),
+                "frames": reviews[scenario.scenario_id],
+            }
+            for scenario in scenarios
+        ],
+        "authority": _authority(),
+    }
+    report = {
+        "schema_version": E35_REPORT_SCHEMA,
+        "result_id": result_id,
+        "identity": identity,
+        "created_at_utc": utc_now_iso(),
+        "status": "pending-acceptance-finalization",
+        "metrics": {
+            "accounting": {
+                "source_frames": frame_count,
+                "variant_count": len(scenarios),
+                "variant_frame_outcomes": frame_count * len(scenarios),
+                "injection_records": sum(
+                    scenario.frame_count for scenario in scenarios
+                ),
+            },
+            "scenarios": scenario_reports,
+            "runtime": {
+                "build_elapsed_ms": (time.perf_counter() - started) * 1_000.0,
+                "variant_frame_processing_ms": _distribution(processing_ms),
+            },
+        },
+        "acceptance": None,
+        "decision": {
+            "source_and_upstream_results_modified": False,
+            "free_space_published": False,
+            "persistent_reconstruction_modified": False,
+            "late_results_reintroduced": False,
+            "planner_or_navigation_authority": False,
+        },
+        "authority": _authority(),
+    }
+    return report, review
+
+
+def _initial_scenario_metrics(
+    scenario: DegradationScenario,
+) -> dict[str, Any]:
+    return {
+        "scenario_id": scenario.scenario_id,
+        "kind": scenario.kind.value,
+        "frame_start": scenario.frame_start,
+        "frame_end": scenario.frame_end,
+        "frames_processed": 0,
+        "injected_frames": 0,
+        "dropped_frames": 0,
+        "hidden_success_frames": 0,
+        "false_free_rows": 0,
+        "semantic_claims_during_camera_loss": 0,
+        "metric_rows_during_lidar_or_pose_loss": 0,
+        "agree_claims_during_timing_offset": 0,
+        "late_results_reintroduced": 0,
+        "maximum_current_components_during_fault": 0,
+        "maximum_held_components_during_fault": 0,
+        "expired_components_during_fault": 0,
+        "fault_end_seconds": None,
+        "recovery_frame_index": None,
+        "recovery_seconds": None,
+        "_recovery_candidate": None,
+    }
+
+
+def _observe_metrics(
+    metrics: dict[str, Any],
+    *,
+    scenario: DegradationScenario,
+    source_frame: TrackGeometryFrame,
+    transformed_frame: TrackGeometryFrame,
+    transformation: dict[str, Any],
+    projection: dict[str, Any],
+) -> None:
+    metrics["frames_processed"] += 1
+    active = bool(transformation["active"])
+    if active:
+        metrics["injected_frames"] += 1
+        current_count = len(projection["current"])
+        held_count = len(projection["held"])
+        metrics["maximum_current_components_during_fault"] = max(
+            metrics["maximum_current_components_during_fault"],
+            current_count,
+        )
+        metrics["maximum_held_components_during_fault"] = max(
+            metrics["maximum_held_components_during_fault"],
+            held_count,
+        )
+        metrics["expired_components_during_fault"] += len(
+            projection["expired"]
+        )
+        if transformation["action"] in {
+            "late-frame-discarded",
+            "input-frame-dropped",
+        }:
+            metrics["dropped_frames"] += 1
+        if transformation["action"] == "none":
+            metrics["hidden_success_frames"] += 1
+        if scenario.kind is DegradationKind.CAMERA_LOSS:
+            metrics["semantic_claims_during_camera_loss"] += sum(
+                geometry.owner_kind is TrackGeometryOwnerKind.CAMERA_TRACK
+                or geometry.semantic_label is not None
+                for geometry in transformed_frame.geometries
+            )
+        if scenario.kind in {
+            DegradationKind.LIDAR_LOSS,
+            DegradationKind.POSE_STALENESS,
+        }:
+            metrics["metric_rows_during_lidar_or_pose_loss"] += (
+                transformed_frame.point_slab.row_count
+            )
+        if scenario.kind is DegradationKind.TIMING_OFFSET:
+            metrics["agree_claims_during_timing_offset"] += sum(
+                geometry.evidence_state is TrackGeometryEvidenceState.AGREE
+                for geometry in transformed_frame.geometries
+            )
+        if scenario.kind is DegradationKind.DELAYED_FRAMES:
+            metrics["late_results_reintroduced"] += sum(
+                int(component["last_observed_frame_index"])
+                == source_frame.frame_index
+                for component in projection["current"]
+            )
+    if source_frame.frame_index == scenario.frame_end:
+        metrics["fault_end_seconds"] = source_frame.session_seconds
+    if (
+        source_frame.frame_index > scenario.frame_end
+        and metrics["_recovery_candidate"] is None
+        and transformed_frame.point_slab.row_count > 0
+        and projection["current"]
+    ):
+        metrics["_recovery_candidate"] = (
+            source_frame.frame_index,
+            source_frame.session_seconds,
+        )
+
+
+def _finish_scenario_metrics(metrics: dict[str, Any]) -> None:
+    end_seconds = metrics["fault_end_seconds"]
+    candidate = metrics.pop("_recovery_candidate")
+    if isinstance(end_seconds, float) and isinstance(candidate, tuple):
+        metrics["recovery_frame_index"] = candidate[0]
+        metrics["recovery_seconds"] = candidate[1] - end_seconds
+
+
+def _frame_outcome(
+    *,
+    scenario: DegradationScenario,
+    source_frame: TrackGeometryFrame,
+    transformed_frame: TrackGeometryFrame,
+    transformation: dict[str, Any],
+    projection: dict[str, Any],
+) -> dict[str, Any]:
+    return {
+        "schema_version": E35_OUTCOME_SCHEMA,
+        "scenario_id": scenario.scenario_id,
+        "kind": scenario.kind.value,
+        "frame_index": source_frame.frame_index,
+        "source_frame_index": source_frame.source_frame_index,
+        "session_seconds": source_frame.session_seconds,
+        "injection": {
+            "active": transformation["active"],
+            "action": transformation["action"],
+            "channels": transformation["channels"],
+        },
+        "input": {
+            "source_available": source_frame.source_available,
+            "point_rows": source_frame.point_slab.row_count,
+            "geometries": len(source_frame.geometries),
+        },
+        "transformed": {
+            "source_available": transformed_frame.source_available,
+            "point_rows": transformed_frame.point_slab.row_count,
+            "geometries": len(transformed_frame.geometries),
+            "camera_tracks": sum(
+                item.owner_kind is TrackGeometryOwnerKind.CAMERA_TRACK
+                for item in transformed_frame.geometries
+            ),
+            "geometry_clusters": sum(
+                item.owner_kind is TrackGeometryOwnerKind.GEOMETRY_CLUSTER
+                for item in transformed_frame.geometries
+            ),
+            "agree": sum(
+                item.evidence_state is TrackGeometryEvidenceState.AGREE
+                for item in transformed_frame.geometries
+            ),
+            "metric_point_rows": transformed_frame.point_slab.row_count,
+        },
+        "layer": {
+            "state": projection["layer_state"],
+            "current": len(projection["current"]),
+            "held": len(projection["held"]),
+            "expired": len(projection["expired"]),
+            "current_cell_rows": sum(
+                int(item["cell_row_count"]) for item in projection["current"]
+            ),
+            "held_cell_rows": sum(
+                int(item["cell_row_count"]) for item in projection["held"]
+            ),
+            "free_cell_rows": 0,
+        },
+        "terminal": True,
+        "policy": transformation["policy"],
+        "authority": _authority(),
+    }
+
+
+def _review_frame(
+    *,
+    scenario: DegradationScenario,
+    source_frame: TrackGeometryFrame,
+    transformed_frame: TrackGeometryFrame,
+    transformation: dict[str, Any],
+    projection: dict[str, Any],
+    cell_rows: np.ndarray[Any, np.dtype[np.int32]],
+    voxel_size_m: float,
+) -> dict[str, Any]:
+    if cell_rows.shape[0] > 384:
+        indices = np.linspace(
+            0,
+            cell_rows.shape[0] - 1,
+            num=384,
+        ).astype(np.int64)
+        sample = cell_rows[indices]
+    else:
+        sample = cell_rows
+    centers = (sample.astype(np.float64) + 0.5) * voxel_size_m
+    components = []
+    for key in ("current", "held", "expired"):
+        for item in projection[key]:
+            components.append(
+                {
+                    "temporal_id": item["temporal_id"],
+                    "state": item["state"],
+                    "occupancy_state": item["occupancy_state"],
+                    "owner_kind": item["owner_kind"],
+                    "semantic_labels": item["semantic_provenance"]["labels"],
+                    "last_observed_age_seconds": item[
+                        "last_observed_age_seconds"
+                    ],
+                    "centroid_map_xyz_m": item["centroid_map_xyz_m"],
+                }
+            )
+    return {
+        "scenario_id": scenario.scenario_id,
+        "kind": scenario.kind.value,
+        "frame_index": source_frame.frame_index,
+        "source_frame_index": source_frame.source_frame_index,
+        "session_seconds": source_frame.session_seconds,
+        "fault_phase": (
+            "before"
+            if source_frame.frame_index < scenario.frame_start
+            else (
+                "during"
+                if source_frame.frame_index <= scenario.frame_end
+                else "after"
+            )
+        ),
+        "action": transformation["action"],
+        "channels": transformation["channels"],
+        "input_point_rows": source_frame.point_slab.row_count,
+        "transformed_point_rows": transformed_frame.point_slab.row_count,
+        "layer_state": projection["layer_state"],
+        "counts": {
+            "current": len(projection["current"]),
+            "held": len(projection["held"]),
+            "expired": len(projection["expired"]),
+        },
+        "components": components,
+        "cell_centers_map_xyz_m": centers.tolist(),
+    }
+
+
+def _finalize_report(
+    report: dict[str, Any],
+    *,
+    profile: dict[str, Any],
+    upstream_unchanged: bool,
+) -> dict[str, Any]:
+    result = copy.deepcopy(report)
+    metrics = _object(result.get("metrics"), "E35 metrics")
+    accounting = _object(metrics.get("accounting"), "E35 accounting")
+    scenarios = [
+        _object(item, "E35 scenario metrics")
+        for item in _array(metrics.get("scenarios"), "E35 scenario metrics")
+    ]
+    acceptance = _object(profile.get("acceptance"), "E35 acceptance profile")
+    expected_outcomes = (
+        accounting["source_frames"] * acceptance["expected_scenario_count"]
+    )
+    requirements = {
+        "six_scenarios_completed": (
+            accounting.get("variant_count")
+            == acceptance["expected_scenario_count"]
+            == len(scenarios)
+        ),
+        "complete_variant_frame_accounting": (
+            accounting.get("variant_frame_outcomes") == expected_outcomes
+            and all(
+                item.get("frames_processed") == accounting["source_frames"]
+                for item in scenarios
+            )
+        ),
+        "explicit_injection_journal_complete": (
+            accounting.get("injection_records")
+            == sum(
+                int(item["frame_end"]) - int(item["frame_start"]) + 1
+                for item in scenarios
+            )
+        ),
+        "every_variant_recovered": all(
+            item.get("recovery_seconds") is not None for item in scenarios
+        ),
+        "recovery_within_gate": all(
+            item.get("recovery_seconds") is not None
+            and float(item["recovery_seconds"])
+            <= float(acceptance["maximum_recovery_seconds"]) + 1e-9
+            for item in scenarios
+        ),
+        "no_hidden_success": sum(
+            int(item["hidden_success_frames"]) for item in scenarios
+        )
+        <= acceptance["maximum_hidden_success_frames"],
+        "no_false_free_rows": sum(
+            int(item["false_free_rows"]) for item in scenarios
+        )
+        <= acceptance["maximum_false_free_rows"],
+        "no_semantics_during_camera_loss": sum(
+            int(item["semantic_claims_during_camera_loss"])
+            for item in scenarios
+        )
+        <= acceptance["maximum_semantic_claims_during_camera_loss"],
+        "no_metric_rows_during_lidar_or_pose_loss": sum(
+            int(item["metric_rows_during_lidar_or_pose_loss"])
+            for item in scenarios
+        )
+        <= acceptance["maximum_metric_rows_during_lidar_or_pose_loss"],
+        "no_agree_during_timing_offset": sum(
+            int(item["agree_claims_during_timing_offset"])
+            for item in scenarios
+        )
+        == 0,
+        "no_late_result_reintroduction": sum(
+            int(item["late_results_reintroduced"]) for item in scenarios
+        )
+        <= acceptance["maximum_late_results_reintroduced"],
+        "upstream_artifacts_unchanged": upstream_unchanged,
+        "persistent_reconstruction_unmodified": True,
+        "navigation_or_safety_authority_false": True,
+    }
+    failed = [name for name, passed in requirements.items() if not passed]
+    result["acceptance"] = {
+        "accepted": not failed,
+        "requirements": requirements,
+        "rejection_reasons": failed,
+        "scope": "deterministic-source-degradation-recovery-shadow",
+        "commands_enabled": False,
+        "navigation_or_safety_accepted": False,
+    }
+    result["status"] = (
+        "accepted-deterministic-degradation-recovery"
+        if not failed
+        else "rejected-fail-closed"
+    )
+    result["decision"]["next_gate"] = (
+        "A9/E36 second-source transfer qualification"
+        if not failed
+        else "E35 rejected; inspect immutable scenario evidence"
+    )
+    return result
+
+
+def _validate_upstream(
+    *,
+    e32: E32TrackGeometryReplay,
+    e33: E33WorkerShadowResult,
+    e34: E34TemporalOccupiedReplay,
+    e34_profile: dict[str, Any],
+    profile: dict[str, Any],
+) -> None:
+    e33_identity = _object(e33.result.get("identity"), "E33 identity")
+    e34_identity = _object(e34.manifest.get("identity"), "E34 identity")
+    if (
+        e32.report.get("status")
+        != "accepted-diagnostic-track-geometry-replay"
+        or not e33.accepted
+        or not e34.accepted
+        or profile.get("expected_e32_result_id") != e32.result_id
+        or profile.get("expected_e33_result_id") != e33.result_id
+        or profile.get("expected_e34_result_id") != e34.result_id
+        or e33_identity.get("e32_result_id") != e32.result_id
+        or e34_identity.get("e32_result_id") != e32.result_id
+        or e34_identity.get("e33_result_id") != e33.result_id
+        or e34_identity.get("profile") != e34_profile
+    ):
+        raise E35DegradationReplayError(
+            "E35 profile does not bind accepted E32/E33/E34 evidence"
+        )
+
+
+def _validate_outcomes(
+    path: Path,
+    *,
+    frame_count: int,
+    variant_count: int,
+) -> int:
+    observed = 0
+    previous_frame = -1
+    scenario_ids: set[str] = set()
+    with path.open("r", encoding="utf-8") as stream:
+        for line in stream:
+            value = _json_line(line, "E35 outcome")
+            frame_index = _nonnegative_int(
+                value.get("frame_index"),
+                "E35 outcome frame",
+            )
+            scenario_id = value.get("scenario_id")
+            if frame_index != previous_frame:
+                if previous_frame >= 0 and len(scenario_ids) != variant_count:
+                    raise E35DegradationReplayError(
+                        "E35 outcome scenario accounting changed"
+                    )
+                if frame_index != previous_frame + 1:
+                    raise E35DegradationReplayError(
+                        "E35 outcome frame order changed"
+                    )
+                previous_frame = frame_index
+                scenario_ids = set()
+            if (
+                value.get("schema_version") != E35_OUTCOME_SCHEMA
+                or frame_index >= frame_count
+                or not isinstance(scenario_id, str)
+                or scenario_id in scenario_ids
+                or value.get("terminal") is not True
+                or value.get("authority") != _authority()
+            ):
+                raise E35DegradationReplayError(
+                    "E35 outcome contract changed"
+                )
+            scenario_ids.add(scenario_id)
+            observed += 1
+    if scenario_ids and len(scenario_ids) != variant_count:
+        raise E35DegradationReplayError(
+            "E35 outcome final scenario accounting changed"
+        )
+    if observed != frame_count * variant_count:
+        raise E35DegradationReplayError("E35 outcome stream is incomplete")
+    return observed
+
+
+def _validate_journal(path: Path) -> int:
+    observed = 0
+    with path.open("r", encoding="utf-8") as stream:
+        for line in stream:
+            value = _json_line(line, "E35 journal")
+            if (
+                value.get("schema_version") != E35_JOURNAL_SCHEMA
+                or value.get("active") is not True
+                or not isinstance(value.get("scenario_id"), str)
+                or not isinstance(value.get("frame_index"), int)
+                or value.get("authority") != _authority()
+                or _SHA256.fullmatch(
+                    str(value.get("original_frame_sha256"))
+                )
+                is None
+                or _SHA256.fullmatch(
+                    str(value.get("transformed_frame_sha256"))
+                )
+                is None
+            ):
+                raise E35DegradationReplayError(
+                    "E35 injection journal changed"
+                )
+            observed += 1
+    return observed
+
+
+def _verified_artifacts(
+    root: Path,
+    raw: object,
+    *,
+    role_key: str,
+) -> dict[str, Path]:
+    result: dict[str, Path] = {}
+    for value in _array(raw, "artifact descriptors"):
+        item = _object(value, "artifact descriptor")
+        role = item.get(role_key)
+        relative = item.get("path")
+        if (
+            not isinstance(role, str)
+            or not role
+            or role in result
+            or not isinstance(relative, str)
+            or not relative
+            or Path(relative).is_absolute()
+            or ".." in Path(relative).parts
+        ):
+            raise E35DegradationReplayError("artifact descriptor is invalid")
+        path = root / relative
+        if (
+            not path.is_file()
+            or path.is_symlink()
+            or item.get("byte_length") != path.stat().st_size
+            or item.get("sha256") != _sha256(path)
+        ):
+            raise E35DegradationReplayError(
+                "upstream or E35 artifact identity changed"
+            )
+        result[role] = path
+    if not result:
+        raise E35DegradationReplayError("artifact set is empty")
+    return result
+
+
+def _artifact_identity(artifacts: dict[str, Path]) -> dict[str, Any]:
+    return {
+        role: {
+            "byte_length": path.stat().st_size,
+            "sha256": _sha256(path),
+        }
+        for role, path in sorted(artifacts.items())
+    }
+
+
+def _artifact(
+    path: Path,
+    kind: str,
+    media_type: str,
+    schema_version: str,
+) -> dict[str, Any]:
+    return {
+        "kind": kind,
+        "path": path.name,
+        "media_type": media_type,
+        "schema_version": schema_version,
+        "byte_length": path.stat().st_size,
+        "sha256": _sha256(path),
+    }
+
+
+def _distribution(values: list[float]) -> dict[str, float | int | None]:
+    if not values:
+        return {
+            "sample_count": 0,
+            "minimum": None,
+            "p50": None,
+            "p95": None,
+            "maximum": None,
+            "mean": None,
+        }
+    array = np.asarray(values, dtype=np.float64)
+    return {
+        "sample_count": len(values),
+        "minimum": float(np.min(array)),
+        "p50": float(np.percentile(array, 50)),
+        "p95": float(np.percentile(array, 95)),
+        "maximum": float(np.max(array)),
+        "mean": float(np.mean(array)),
+    }
+
+
+def _authority() -> dict[str, bool]:
+    return {
+        "commands_enabled": False,
+        "navigation_or_safety_accepted": False,
+    }
+
+
+def _positive_float(value: object, label: str) -> float:
+    if (
+        not isinstance(value, (int, float))
+        or isinstance(value, bool)
+        or not math.isfinite(float(value))
+        or float(value) <= 0.0
+    ):
+        raise E35DegradationReplayError(f"{label} is invalid")
+    return float(value)
+
+
+def _positive_int(value: object, label: str) -> int:
+    result = _nonnegative_int(value, label)
+    if result == 0:
+        raise E35DegradationReplayError(f"{label} is invalid")
+    return result
+
+
+def _nonnegative_int(value: object, label: str) -> int:
+    if not isinstance(value, int) or isinstance(value, bool) or value < 0:
+        raise E35DegradationReplayError(f"{label} is invalid")
+    return value
+
+
+def _boolean(value: object, label: str) -> bool:
+    if not isinstance(value, bool):
+        raise E35DegradationReplayError(f"{label} is invalid")
+    return value
+
+
+def _object(value: object, label: str) -> dict[str, Any]:
+    if not isinstance(value, dict) or any(
+        not isinstance(key, str) for key in value
+    ):
+        raise E35DegradationReplayError(f"{label} must be an object")
+    return value
+
+
+def _array(value: object, label: str) -> list[Any]:
+    if not isinstance(value, list):
+        raise E35DegradationReplayError(f"{label} must be an array")
+    return value
+
+
+def _canonical_json(value: object) -> bytes:
+    return json.dumps(
+        value,
+        sort_keys=True,
+        separators=(",", ":"),
+        allow_nan=False,
+    ).encode()
+
+
+def _sha256(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as stream:
+        while chunk := stream.read(1024 * 1024):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+def _read_json(path: Path) -> dict[str, Any]:
+    try:
+        value = json.loads(path.read_text(encoding="utf-8-sig"))
+    except (OSError, json.JSONDecodeError) as exc:
+        raise E35DegradationReplayError(
+            f"JSON artifact is invalid: {path.name}"
+        ) from exc
+    return _object(value, path.name)
+
+
+def _json_line(line: str, label: str) -> dict[str, Any]:
+    try:
+        value = json.loads(line)
+    except json.JSONDecodeError as exc:
+        raise E35DegradationReplayError(f"{label} JSON is invalid") from exc
+    return _object(value, label)
+
+
+def _write_json(path: Path, value: object) -> None:
+    with path.open("x", encoding="utf-8", newline="\n") as stream:
+        json.dump(value, stream, ensure_ascii=False, indent=2, sort_keys=True)
+        stream.write("\n")
+        stream.flush()
+        os.fsync(stream.fileno())
+
+
+def _write_jsonl(stream: TextIO, value: object) -> None:
+    stream.write(
+        json.dumps(
+            value,
+            ensure_ascii=False,
+            sort_keys=True,
+            separators=(",", ":"),
+            allow_nan=False,
+        )
+    )
+    stream.write("\n")
diff --git a/src/k1link/web/advanced_laboratory_api.py b/src/k1link/web/advanced_laboratory_api.py
index e1ee7c5..cd2dacd 100644
--- a/src/k1link/web/advanced_laboratory_api.py
+++ b/src/k1link/web/advanced_laboratory_api.py
@@ -29,6 +29,11 @@ from k1link.compute.e34_temporal_occupied_replay import (
     E34TemporalOccupiedReplayError,
     read_e34_temporal_occupied_replay,
 )
+from k1link.compute.e35_degradation_replay import (
+    E35DegradationReplay,
+    E35DegradationReplayError,
+    read_e35_degradation_replay,
+)
 
 LABORATORY_ADVANCED_CATALOG_SCHEMA: Final = (
     "missioncore.laboratory-advanced-catalog/v1"
@@ -38,6 +43,7 @@ _E31_RESULT_ID = re.compile(r"^e31-source-qualification-[a-f0-9]{64}$")
 _E32_RESULT_ID = re.compile(r"^e32-track-geometry-[a-f0-9]{64}$")
 _E33_RESULT_ID = re.compile(r"^e33-worker-shadow-[a-f0-9]{64}$")
 _E34_RESULT_ID = re.compile(r"^e34-temporal-occupied-[a-f0-9]{64}$")
+_E35_RESULT_ID = re.compile(r"^e35-degradation-recovery-[a-f0-9]{64}$")
 
 RootProvider = Callable[[], Path | None]
 
@@ -88,6 +94,15 @@ def _read_e34_cached(
     return read_e34_temporal_occupied_replay(Path(root_text))
 
 
+@lru_cache(maxsize=16)
+def _read_e35_cached(
+    root_text: str,
+    signature: tuple[int, ...],
+) -> E35DegradationReplay:
+    del signature
+    return read_e35_degradation_replay(Path(root_text))
+
+
 def _configured_root(provider: RootProvider) -> Path | None:
     value = provider()
     if value is None:
@@ -416,6 +431,61 @@ def _project_e34(result: E34TemporalOccupiedReplay) -> dict[str, object]:
     }
 
 
+def _project_e35(result: E35DegradationReplay) -> dict[str, object]:
+    identity = _object(result.manifest.get("identity"), "E35 identity")
+    profile = _object(identity.get("profile"), "E35 profile")
+    acceptance_profile = _object(
+        profile.get("acceptance"),
+        "E35 acceptance profile",
+    )
+    metrics = _object(result.report.get("metrics"), "E35 metrics")
+    accounting = _object(metrics.get("accounting"), "E35 accounting")
+    runtime = _object(metrics.get("runtime"), "E35 runtime")
+    processing = _object(
+        runtime.get("variant_frame_processing_ms"),
+        "E35 processing",
+    )
+    acceptance = _object(result.report.get("acceptance"), "E35 acceptance")
+    if acceptance.get("accepted") is not True:
+        raise ValueError("E35 result is not accepted")
+    return {
+        "result_id": result.result_id,
+        "created_at_utc": result.manifest.get("created_at_utc"),
+        "source_session_id": identity.get("source_session_id"),
+        "status": result.manifest.get("acceptance_state"),
+        "e32_result_id": identity.get("e32_result_id"),
+        "e33_result_id": identity.get("e33_result_id"),
+        "e34_result_id": identity.get("e34_result_id"),
+        "profile_id": profile.get("profile_id"),
+        "pipeline_id": identity.get("pipeline"),
+        "coordinate_frame": identity.get("coordinate_frame"),
+        "configuration": {
+            "maximum_recovery_seconds": acceptance_profile.get(
+                "maximum_recovery_seconds"
+            ),
+            "scenario_count": acceptance_profile.get(
+                "expected_scenario_count"
+            ),
+        },
+        "metrics": {
+            "source_frames": accounting.get("source_frames"),
+            "variant_count": accounting.get("variant_count"),
+            "variant_frame_outcomes": accounting.get(
+                "variant_frame_outcomes"
+            ),
+            "injection_records": accounting.get("injection_records"),
+            "variant_frame_processing_p95_ms": processing.get("p95"),
+            "build_elapsed_ms": runtime.get("build_elapsed_ms"),
+        },
+        "scenarios": copy.deepcopy(metrics.get("scenarios")),
+        "review": copy.deepcopy(result.review),
+        "acceptance": copy.deepcopy(acceptance),
+        "decision": copy.deepcopy(result.report.get("decision")),
+        "authority": copy.deepcopy(result.report.get("authority")),
+        "access": "read-only",
+    }
+
+
 def _empty_catalog(configured: bool) -> dict[str, object]:
     return {
         "schema_version": LABORATORY_ADVANCED_CATALOG_SCHEMA,
@@ -433,6 +503,7 @@ def build_advanced_laboratory_router(
     e32_root_provider: RootProvider = lambda: None,
     e33_root_provider: RootProvider = lambda: None,
     e34_root_provider: RootProvider = lambda: None,
+    e35_root_provider: RootProvider = lambda: None,
 ) -> APIRouter:
     router = APIRouter(prefix="/api/v1/laboratory", tags=["laboratory"])
 
@@ -592,4 +663,39 @@ def build_advanced_laboratory_router(
             "invalid_total": invalid_total,
         }
 
+    @router.get("/e35/results")
+    def list_e35_results(
+        limit: int = Query(default=1, ge=1, le=10),
+    ) -> dict[str, object]:
+        root = _configured_root(e35_root_provider)
+        if root is None:
+            return _empty_catalog(False)
+        candidates = _candidates(root, _E35_RESULT_ID)
+        items: list[dict[str, object]] = []
+        invalid_total = 0
+        for candidate in candidates:
+            try:
+                result = _read_e35_cached(
+                    str(candidate.resolve()),
+                    _result_signature(candidate),
+                )
+                if not result.accepted:
+                    raise ValueError("E35 result is not accepted")
+                if len(items) < limit:
+                    items.append(_project_e35(result))
+            except (
+                E35DegradationReplayError,
+                KeyError,
+                OSError,
+                TypeError,
+                ValueError,
+            ):
+                invalid_total += 1
+        return {
+            **_empty_catalog(True),
+            "items": items,
+            "candidate_total": len(candidates),
+            "invalid_total": invalid_total,
+        }
+
     return router
diff --git a/src/k1link/web/app.py b/src/k1link/web/app.py
index 9a6fb1b..24acba2 100644
--- a/src/k1link/web/app.py
+++ b/src/k1link/web/app.py
@@ -527,6 +527,13 @@ app.include_router(
             / "e34"
             / "results"
         ),
+        e35_root_provider=lambda: (
+            REPOSITORY_ROOT
+            / ".runtime"
+            / "compute-experiments"
+            / "e35"
+            / "results"
+        ),
     )
 )
 app.include_router(
diff --git a/tests/test_advanced_laboratory_api.py b/tests/test_advanced_laboratory_api.py
index b3d5f1b..1778722 100644
--- a/tests/test_advanced_laboratory_api.py
+++ b/tests/test_advanced_laboratory_api.py
@@ -26,7 +26,7 @@ def _endpoint(router: APIRouter, path: str) -> object:
 def test_advanced_catalogs_are_empty_when_not_configured() -> None:
     router = build_advanced_laboratory_router()
 
-    for name in ("e31", "e32", "e33", "e34"):
+    for name in ("e31", "e32", "e33", "e34", "e35"):
         route = _endpoint(router, f"/api/v1/laboratory/{name}/results")
         catalog = route(limit=1)  # type: ignore[operator]
         assert catalog == {
@@ -46,20 +46,23 @@ def test_advanced_catalogs_fail_closed_on_incomplete_results(
     e32 = tmp_path / "e32"
     e33 = tmp_path / "e33"
     e34 = tmp_path / "e34"
-    for root in (e31, e32, e33, e34):
+    e35 = tmp_path / "e35"
+    for root in (e31, e32, e33, e34, e35):
         root.mkdir()
     (e31 / f"e31-source-qualification-{'1' * 64}").mkdir()
     (e32 / f"e32-track-geometry-{'2' * 64}").mkdir()
     (e33 / f"e33-worker-shadow-{'3' * 64}").mkdir()
     (e34 / f"e34-temporal-occupied-{'4' * 64}").mkdir()
+    (e35 / f"e35-degradation-recovery-{'5' * 64}").mkdir()
     router = build_advanced_laboratory_router(
         e31_root_provider=lambda: e31,
         e32_root_provider=lambda: e32,
         e33_root_provider=lambda: e33,
         e34_root_provider=lambda: e34,
+        e35_root_provider=lambda: e35,
     )
 
-    for name in ("e31", "e32", "e33", "e34"):
+    for name in ("e31", "e32", "e33", "e34", "e35"):
         route = _endpoint(router, f"/api/v1/laboratory/{name}/results")
         catalog = route(limit=1)  # type: ignore[operator]
         assert catalog["configured"] is True
@@ -209,3 +212,103 @@ def test_e34_catalog_projects_only_accepted_read_only_evidence(
     assert item["metrics"]["free_cell_rows"] == 0
     assert item["authority"] == authority
     assert item["access"] == "read-only"
+
+
+def test_e35_catalog_projects_recovery_and_review(
+    tmp_path: Path,
+    monkeypatch: MonkeyPatch,
+) -> None:
+    result_id = f"e35-degradation-recovery-{'5' * 64}"
+    root = tmp_path / "e35"
+    candidate = root / result_id
+    candidate.mkdir(parents=True)
+    (candidate / "manifest.json").write_text("{}", encoding="utf-8")
+    authority = {
+        "commands_enabled": False,
+        "navigation_or_safety_accepted": False,
+    }
+    result = SimpleNamespace(
+        result_id=result_id,
+        accepted=True,
+        manifest={
+            "created_at_utc": "2026-07-27T15:00:00Z",
+            "acceptance_state": (
+                "accepted-deterministic-degradation-recovery"
+            ),
+            "identity": {
+                "source_session_id": "source-session",
+                "e32_result_id": f"e32-track-geometry-{'2' * 64}",
+                "e33_result_id": f"e33-worker-shadow-{'3' * 64}",
+                "e34_result_id": f"e34-temporal-occupied-{'4' * 64}",
+                "pipeline": (
+                    "track-geometry/temporal-layer/"
+                    "degradation-recovery/v1"
+                ),
+                "coordinate_frame": "map",
+                "profile": {
+                    "profile_id": (
+                        "e35-six-channel-degradation-recovery/v1"
+                    ),
+                    "acceptance": {
+                        "maximum_recovery_seconds": 0.25,
+                        "expected_scenario_count": 6,
+                    },
+                },
+            },
+        },
+        report={
+            "metrics": {
+                "accounting": {
+                    "source_frames": 4489,
+                    "variant_count": 6,
+                    "variant_frame_outcomes": 26934,
+                    "injection_records": 360,
+                },
+                "scenarios": [
+                    {
+                        "scenario_id": "camera-loss",
+                        "recovery_seconds": 0.086,
+                    }
+                ],
+                "runtime": {
+                    "build_elapsed_ms": 18618.0,
+                    "variant_frame_processing_ms": {"p95": 1.08},
+                },
+            },
+            "acceptance": {"accepted": True, "requirements": {}},
+            "decision": {"next_gate": "A9/E36"},
+            "authority": authority,
+        },
+        review={
+            "schema_version": "missioncore.e35-recovery-review/v1",
+            "result_id": result_id,
+            "scenarios": [],
+        },
+    )
+
+    def fake_read(
+        root_text: str,
+        signature: tuple[int, ...],
+    ) -> SimpleNamespace:
+        assert root_text == str(candidate.resolve())
+        assert signature
+        return result
+
+    monkeypatch.setattr(advanced_api, "_read_e35_cached", fake_read)
+    router = build_advanced_laboratory_router(
+        e35_root_provider=lambda: root,
+    )
+    route = _endpoint(router, "/api/v1/laboratory/e35/results")
+    catalog = route(limit=1)  # type: ignore[operator]
+
+    assert catalog["candidate_total"] == 1
+    assert catalog["invalid_total"] == 0
+    item = catalog["items"][0]
+    assert item["status"] == (
+        "accepted-deterministic-degradation-recovery"
+    )
+    assert item["metrics"]["variant_frame_outcomes"] == 26934
+    assert item["configuration"]["maximum_recovery_seconds"] == 0.25
+    assert item["review"]["scenarios"] == []
+    assert item["authority"] == authority
+    assert item["access"] == "read-only"
diff --git a/tests/test_e35_degradation_recovery.py b/tests/test_e35_degradation_recovery.py
new file mode 100644
index 0000000..9a3b9f5
--- /dev/null
+++ b/tests/test_e35_degradation_recovery.py
@@ -0,0 +1,315 @@
+from __future__ import annotations
+
+import copy
+import json
+from pathlib import Path
+
+import numpy as np
+import pytest
+
+from k1link.compute.degradation_recovery import (
+    DegradationKind,
+    DegradationRecoveryError,
+    DegradationScenario,
+    transform_track_geometry_frame,
+)
+from k1link.compute.e35_degradation_replay import (
+    E35DegradationReplayError,
+    read_e35_degradation_profile,
+)
+from k1link.compute.track_geometry import (
+    PointSlab,
+    TrackGeometry,
+    TrackGeometryCurrentness,
+    TrackGeometryEvidenceState,
+    TrackGeometryFrame,
+    TrackGeometryMetricBasis,
+    TrackGeometryOwnerKind,
+    TrackGeometrySourceBinding,
+)
+
+
+def _binding() -> TrackGeometrySourceBinding:
+    return TrackGeometrySourceBinding(
+        source_pack_id="e10-lidar-pack-" + "a" * 64,
+        source_session_id="source-session",
+        representation_profile_id="representation-profile/v1",
+        e31_qualification_id="e31-source-qualification-" + "b" * 64,
+        calibration_sha256="c" * 64,
+        coordinate_frame="map",
+        time_basis="source-time",
+        selected_offset_ms=0,
+    )
+
+
+def _frame(frame_index: int = 10) -> TrackGeometryFrame:
+    geometries = (
+        TrackGeometry(
+            owner_key="track:7",
+            owner_kind=TrackGeometryOwnerKind.CAMERA_TRACK,
+            evidence_state=TrackGeometryEvidenceState.AGREE,
+            currentness=TrackGeometryCurrentness.CURRENT,
+            metric_basis=TrackGeometryMetricBasis.CURRENT_POINTS,
+            reason_codes=("accepted-hit-backed-support",),
+            semantic_track_id=7,
+            semantic_label="car",
+            bbox_xyxy=(1.0, 1.0, 2.0, 2.0),
+            range_m=3.0,
+        ),
+        TrackGeometry(
+            owner_key="geometry:8",
+            owner_kind=TrackGeometryOwnerKind.GEOMETRY_CLUSTER,
+            evidence_state=TrackGeometryEvidenceState.GEOMETRY_ONLY,
+            currentness=TrackGeometryCurrentness.CURRENT,
+            metric_basis=TrackGeometryMetricBasis.CURRENT_POINTS,
+            reason_codes=("accepted-hit-backed-support",),
+            range_m=4.0,
+        ),
+        TrackGeometry(
+            owner_key="track:9",
+            owner_kind=TrackGeometryOwnerKind.CAMERA_TRACK,
+            evidence_state=TrackGeometryEvidenceState.CAMERA_ONLY,
+            currentness=TrackGeometryCurrentness.CURRENT,
+            metric_basis=TrackGeometryMetricBasis.UNAVAILABLE,
+            reason_codes=("camera-without-current-points",),
+            semantic_track_id=9,
+            semantic_label="person",
+            bbox_xyxy=(2.0, 2.0, 3.0, 4.0),
+        ),
+    )
+    return TrackGeometryFrame(
+        binding=_binding(),
+        frame_index=frame_index,
+        source_frame_index=frame_index,
+        session_seconds=frame_index / 10.0,
+        source_available=True,
+        point_slab=PointSlab(
+            frame_index=frame_index,
+            source_frame_index=frame_index,
+            source_point_count=4,
+            coordinate_frame="map",
+            owner_keys=("track:7", "geometry:8"),
+            source_indices=np.asarray([0, 1, 2, 3], dtype="<i8"),
+            points_xyz_m=np.asarray(
+                [
+                    [1.0, 0.0, 0.0],
+                    [1.1, 0.0, 0.0],
+                    [2.0, 0.0, 0.0],
+                    [2.1, 0.0, 0.0],
+                ],
+                dtype="<f4",
+            ),
+            owner_indices=np.asarray([0, 0, 1, 1], dtype="<u4"),
+        ),
+        geometries=geometries,
+    )
+
+
+def _scenario(
+    kind: DegradationKind,
+    parameters: dict[str, object],
+    *,
+    frame_start: int = 10,
+    frame_end: int = 20,
+) -> DegradationScenario:
+    return DegradationScenario(
+        scenario_id=kind.value,
+        kind=kind,
+        frame_start=frame_start,
+        frame_end=frame_end,
+        parameters=parameters,
+    )
+
+
+def test_camera_loss_removes_semantics_but_retains_geometry_points() -> None:
+    transformed = transform_track_geometry_frame(
+        _frame(),
+        _scenario(
+            DegradationKind.CAMERA_LOSS,
+            {"drop_camera_observations": True},
+        ),
+    )
+
+    assert transformed.frame.point_slab.row_count == 4
+    assert all(
+        geometry.owner_kind is TrackGeometryOwnerKind.GEOMETRY_CLUSTER
+        for geometry in transformed.frame.geometries
+    )
+    assert all(
+        geometry.semantic_label is None
+        for geometry in transformed.frame.geometries
+    )
+    assert transformed.transformation["channels"]["camera"] == "unavailable"
+
+
+@pytest.mark.parametrize(
+    ("kind", "parameters", "expected_source_available"),
+    [
+        (
+            DegradationKind.LIDAR_LOSS,
+            {"drop_lidar_points": True},
+            False,
+        ),
+        (
+            DegradationKind.POSE_STALENESS,
+            {"pose_age_seconds": 0.5},
+            True,
+        ),
+    ],
+)
+def test_metric_loss_keeps_camera_nonmetric_and_withholds_map_rows(
+    kind: DegradationKind,
+    parameters: dict[str, object],
+    expected_source_available: bool,
+) -> None:
+    transformed = transform_track_geometry_frame(
+        _frame(),
+        _scenario(kind, parameters),
+    )
+
+    assert transformed.frame.point_slab.row_count == 0
+    assert transformed.frame.source_available is expected_source_available
+    assert all(
+        geometry.owner_kind is TrackGeometryOwnerKind.CAMERA_TRACK
+        for geometry in transformed.frame.geometries
+    )
+    assert all(
+        geometry.metric_basis is not TrackGeometryMetricBasis.CURRENT_POINTS
+        for geometry in transformed.frame.geometries
+    )
+    assert all(
+        geometry.evidence_state is not TrackGeometryEvidenceState.AGREE
+        for geometry in transformed.frame.geometries
+    )
+
+
+def test_delayed_frame_is_discarded_and_cannot_retain_claims() -> None:
+    transformed = transform_track_geometry_frame(
+        _frame(),
+        _scenario(
+            DegradationKind.DELAYED_FRAMES,
+            {"delay_seconds": 1.0, "late_result_policy": "discard"},
+        ),
+    )
+
+    assert not transformed.frame.source_available
+    assert transformed.frame.point_slab.row_count == 0
+    assert transformed.frame.geometries == ()
+    assert transformed.transformation["action"] == "late-frame-discarded"
+
+
+def test_bounded_drop_is_deterministic_and_journals_pass_frames() -> None:
+    scenario = _scenario(
+        DegradationKind.BOUNDED_DROP,
+        {"drop_every_nth_frame": 3},
+    )
+    dropped = transform_track_geometry_frame(_frame(10), scenario)
+    passed_input = _frame(11)
+    passed = transform_track_geometry_frame(passed_input, scenario)
+
+    assert dropped.frame.geometries == ()
+    assert dropped.transformation["action"] == "input-frame-dropped"
+    assert passed.frame is passed_input
+    assert passed.frame.geometries
+    assert passed.transformation["action"] == "bounded-drop-pass"
+
+
+def test_timing_offset_splits_camera_and_geometry_without_agree() -> None:
+    transformed = transform_track_geometry_frame(
+        _frame(),
+        _scenario(
+            DegradationKind.TIMING_OFFSET,
+            {"camera_lidar_offset_ms": 250},
+        ),
+    )
+
+    camera = [
+        geometry
+        for geometry in transformed.frame.geometries
+        if geometry.owner_kind is TrackGeometryOwnerKind.CAMERA_TRACK
+    ]
+    geometry = [
+        item
+        for item in transformed.frame.geometries
+        if item.owner_kind is TrackGeometryOwnerKind.GEOMETRY_CLUSTER
+    ]
+    assert transformed.frame.point_slab.row_count == 4
+    assert len(camera) == 2
+    assert len(geometry) == 2
+    assert all(
+        item.evidence_state is not TrackGeometryEvidenceState.AGREE
+        for item in transformed.frame.geometries
+    )
+    assert transformed.frame.point_slab.owner_keys == (
+        "e35-timing-offset:track:7",
+        "geometry:8",
+    )
+
+
+def test_outside_window_returns_exact_frame_with_inactive_journal() -> None:
+    frame = _frame(9)
+    transformed = transform_track_geometry_frame(
+        frame,
+        _scenario(
+            DegradationKind.CAMERA_LOSS,
+            {"drop_camera_observations": True},
+        ),
+    )
+
+    assert transformed.frame is frame
+    assert transformed.transformation["active"] is False
+    assert transformed.transformation["original_frame_sha256"] == (
+        transformed.transformation["transformed_frame_sha256"]
+    )
+
+
+def test_scenario_requires_exact_parameters_and_unsafe_offset_fails() -> None:
+    with pytest.raises(DegradationRecoveryError):
+        _scenario(DegradationKind.CAMERA_LOSS, {})
+    with pytest.raises(DegradationRecoveryError):
+        _scenario(
+            DegradationKind.TIMING_OFFSET,
+            {"camera_lidar_offset_ms": 100},
+        )
+
+
+def test_source_frame_and_input_arrays_are_not_mutated() -> None:
+    frame = _frame()
+    before = copy.deepcopy(frame.to_dict())
+    before_points = frame.point_slab.points_xyz_m.copy()
+
+    transform_track_geometry_frame(
+        frame,
+        _scenario(
+            DegradationKind.CAMERA_LOSS,
+            {"drop_camera_observations": True},
+        ),
+    )
+
+    assert frame.to_dict() == before
+    np.testing.assert_array_equal(frame.point_slab.points_xyz_m, before_points)
+
+
+def test_frozen_profile_contains_every_degradation_once() -> None:
+    profile, scenarios = read_e35_degradation_profile(
+        Path("experiments/perception/e35_deterministic_degradation_profile.json")
+    )
+
+    assert profile["profile_id"] == "e35-six-channel-degradation-recovery/v1"
+    assert {scenario.kind for scenario in scenarios} == set(DegradationKind)
+    assert sum(scenario.frame_count for scenario in scenarios) == 360
+
+
+def test_profile_rejects_authority_and_policy_relaxation(
+    tmp_path: Path,
+) -> None:
+    source = Path(
+        "experiments/perception/e35_deterministic_degradation_profile.json"
+    )
+    profile = json.loads(source.read_text(encoding="utf-8"))
+    profile["policy"]["late_results_may_reenter"] = True
+    path = tmp_path / "relaxed.json"
+    path.write_text(json.dumps(profile), encoding="utf-8")
+
+    with pytest.raises(E35DegradationReplayError):
+        read_e35_degradation_profile(path)