fix(observatory): preserve camera across follow transitions

feat(observatory): ship modular AI inference labs
docs(observatory): record saved replay evidence and open visual gates
2026-09-05 08:46:35 +03:00 · 2026-09-04 17:59:05 +03:00 · 2026-09-03 13:24:32 +03:00 · 2026-09-03 13:23:56 +03:00 · 2026-09-03 13:15:07 +03:00 · 2026-09-03 11:50:32 +03:00
466 changed files with 130611 additions and 1368 deletions
@@ -7,7 +7,6 @@
    "": {
      "name": "@nodedc/mission-core-control-station",
      "version": "0.1.0",
-      "hasInstallScript": true,
      "dependencies": {
        "@noble/hashes": "^2.2.0",
        "@nodedc/map-cesium-react": "file:../../../NODEDC_DESIGN_GUIDELINE/packages/map-cesium-react",
@@ -15,7 +14,7 @@
        "@nodedc/tokens": "file:../../../NODEDC_DESIGN_GUIDELINE/packages/tokens",
        "@nodedc/ui-core": "file:../../../NODEDC_DESIGN_GUIDELINE/packages/ui-core",
        "@nodedc/ui-react": "file:../../../NODEDC_DESIGN_GUIDELINE/packages/ui-react",
-        "@rerun-io/web-viewer": "0.34.1",
+        "@rerun-io/web-viewer": "0.36.3",
        "meshoptimizer": "1.1.1",
        "playcanvas": "2.21.4",
        "react": "^19.1.0",
@@ -900,9 +899,9 @@
      "link": true
    },
    "node_modules/@rerun-io/web-viewer": {
-      "version": "0.34.1",
-      "resolved": "https://registry.npmjs.org/@rerun-io/web-viewer/-/web-viewer-0.34.1.tgz",
-      "integrity": "sha512-2Oq9Mw3qOs765XArGq4e/0pAIksPFKlAqkgo+PDsRkPd77/KdnQhb835suRmYQ6tuqlbPeVCFhlNIXT0+TjmTg==",
+      "version": "0.36.3",
+      "resolved": "https://registry.npmjs.org/@rerun-io/web-viewer/-/web-viewer-0.36.3.tgz",
+      "integrity": "sha512-LMGnsxRmY5UwiGras2dZrMnEYkow5Xr4v+1hAUSspXWPPiilMqoz9G77jo8Ps/deAaX81TnOq123DFO8iX/Ulw==",
      "license": "MIT"
    },
    "node_modules/@rolldown/pluginutils": {
@@ -4,7 +4,6 @@
  "private": true,
  "type": "module",
  "scripts": {
-    "postinstall": "node scripts/patch-rerun-web-viewer.mjs",
    "dev": "vite",
    "build": "tsc -b && vite build",
    "preview": "vite preview",
@@ -18,7 +17,7 @@
    "@nodedc/tokens": "file:../../../NODEDC_DESIGN_GUIDELINE/packages/tokens",
    "@nodedc/ui-core": "file:../../../NODEDC_DESIGN_GUIDELINE/packages/ui-core",
    "@nodedc/ui-react": "file:../../../NODEDC_DESIGN_GUIDELINE/packages/ui-react",
-    "@rerun-io/web-viewer": "0.34.1",
+    "@rerun-io/web-viewer": "0.36.3",
    "meshoptimizer": "1.1.1",
    "playcanvas": "2.21.4",
    "react": "^19.1.0",
@@ -0,0 +1,16 @@
+<!doctype html>
+<html lang="ru">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Синхронизированная запись</title>
+    <style>
+      html, body, #viewer { width: 100%; height: 100%; margin: 0; overflow: hidden; }
+      canvas { display: block; }
+    </style>
+  </head>
+  <body>
+    <div id="viewer"></div>
+    <script type="module" src="/src/components/rerun/isolatedRerunEntry.ts"></script>
+  </body>
+</html>
@@ -806,6 +806,8 @@ export default function App() {
                <StatusBadge tone="neutral">Offline evaluation</StatusBadge>
              ) : activeDefinition.kind === "lab-archive" ? (
                laboratoryAnnotation.control
+              ) : activeDefinition.kind === "observatory" ? (
+                <StatusBadge tone="neutral">Только наблюдение</StatusBadge>
              ) : activeDefinition.root === "system" ? (
                <SystemWorkspaceSelector
                  value={activeDefinition.id}
@@ -1,4 +1,11 @@
 import { useEffect, useRef, useState } from "react";
+import { createIsolatedRerunHost } from "./rerun/isolatedRerunHost";
+import { keepRecordedBlueprintSession } from "../core/observation/recordedBlueprintLifecycle";
+import {
+  RECORDED_RERUN_ORBITAL_EYE,
+  RECORDED_RERUN_PLAN_EYE,
+  type RecordedRerunCameraEye,
+} from "./rerun/recordedRerunCameraJournal";

 import type { SceneSettings } from "../sceneSettings";
 import {
@@ -34,6 +41,7 @@ import {
  RECORDED_BASE_POINT_COLOR_KEY,
  canPublishRecordedPlaybackController,
  createRecordedAutoplayGate,
+  createRecordedInitialSeekGate,
  createRecordedOpenWatchdog,
 } from "../core/observation/recordedRerunLifecycle";
 import type {
@@ -59,6 +67,7 @@ export {
  attemptRecordedAutoplay,
  canPublishRecordedPlaybackController,
  createRecordedAutoplayGate,
+  createRecordedInitialSeekGate,
  createRecordedOpenWatchdog,
  isRecordedPlaybackFullyBuffered,
  isRecordedPlaybackPresentationReady,
@@ -136,6 +145,17 @@ export interface RerunViewportProps {

 interface RerunBlueprintChannel {
  endpointUrl: string;
+  cameraContract?: string | null;
+  appliedFollowTrajectory?: boolean | null;
+  pendingFollowCameraEye?: RecordedRerunCameraEye | null;
+  configureCameraJournal?: (
+    eye: RecordedRerunCameraEye,
+    spatialViewportStart: number,
+  ) => void;
+  getCameraEye?: () => RecordedRerunCameraEye;
+  setCameraViewportStart?: (spatialViewportStart: number) => void;
+  getCurrentTimeNs?: () => number | null;
+  setCameraMaxOrbitalRadius?: (maxOrbitalRadius: number) => void;
  channel: {
    readonly ready: boolean;
    send_rrd: (rrdBytes: Uint8Array) => void;
@@ -143,14 +163,37 @@ interface RerunBlueprintChannel {
  };
 }

+interface RerunNativeReceiver {
+  endpointUrl: string;
+  ready: () => boolean;
+  open: (sourceUrl: string) => void;
+  close: (sourceUrl: string) => void;
+}
+
+interface LoadedNativePerceptionSource {
+  receiver: RerunNativeReceiver;
+  descriptorUrl: string;
+  sourceUrl: string;
+  byteLength: number;
+}
+
 interface RecordedRerunIdentity {
  applicationId: "nodedc_mission_core_recorded";
  recordingId: string;
 }

 const RECORDED_RRD_PATH = /^\/api\/v1\/observation-sessions\/[A-Za-z0-9][A-Za-z0-9._:-]{0,127}\/recording\.rrd$/;
+const LAB_RECORDED_REPLAY_PATH = /^\/api\/v1\/laboratory\/vegetation-shadow\/lab-v1-vegetation-shadow-[a-f0-9]{64}\/canonical-replay\.rrd$/;
+const PORTABLE_RECORDED_REPLAY_PATH = /^\/api\/v1\/observatory\/portable-results\/(?:m49-tgs-portable-review|lab-v1-eomt-ddrnet|ai-layer-(?:ddrnet|eomt|rf-detr|object-distance))-[a-f0-9]{64}\/replays\/[a-f0-9]{64}\/recording\.rrd$/;
+const COMPOSITION_RECORDED_REPLAY_PATH = /^\/api\/v1\/observatory\/ai-composition-runs\/ai-composition-[a-f0-9]{64}\/replays\/[a-f0-9]{64}\/recording\.rrd$/;
+
+export function isRecordedRrdSource(path: string): boolean {
+  return RECORDED_RRD_PATH.test(path) || LAB_RECORDED_REPLAY_PATH.test(path)
+    || PORTABLE_RECORDED_REPLAY_PATH.test(path) || COMPOSITION_RECORDED_REPLAY_PATH.test(path);
+}
 const RECORDED_BLUEPRINT_PATH = /^\/api\/v1\/observation-sessions\/[A-Za-z0-9][A-Za-z0-9._:-]{0,127}\/blueprint\.rrd$/;
 const RECORDED_PERCEPTION_PATH = /^\/api\/v1\/observation-sessions\/[A-Za-z0-9][A-Za-z0-9._:-]{0,127}\/perception\.rrd$/;
+const LAB_RECORDED_PERCEPTION_PATH = /^\/api\/v1\/laboratory\/vegetation-shadow\/lab-v1-vegetation-shadow-[a-f0-9]{64}\/canonical-overlay\.rrd$/;
 const RECORDED_POINT_COLORS_PATH = /^\/api\/v1\/observation-sessions\/[A-Za-z0-9][A-Za-z0-9._:-]{0,127}\/point-colors\.rrd$/;
 const MAX_BLUEPRINT_BYTES = 1_048_576;
 const MAX_PERCEPTION_BYTES = 512 * 1024 * 1024;
@@ -203,12 +246,7 @@ export function resolveRerunSourceUrl(sourceUrl: string, origin: string): string
  return new URL(normalized, `${base.origin}/`).href;
 }

-/**
- * The native Rerun HTTP receiver is the only browser API in 0.34.1 with a
- * persistent incremental RRD decoder. Bind it to the exact immutable
- * generation selected by the launch contract; arbitrary `send_rrd` byte
- * slices are independently decoded files and are therefore invalid.
- */
+/** Bind the upstream Rerun HTTP receiver to one immutable source generation. */
 export function resolveRecordedViewerSourceUrl(
  descriptor: RecordedRrdArtifactDescriptor,
  origin: string,
@@ -217,7 +255,7 @@ export function resolveRecordedViewerSourceUrl(
  const expectedViewerSourceUrl = `${descriptor.sourceUrl}?generation=${descriptor.sha256}`;
  const endpoint = new URL(descriptor.viewerSourceUrl, `${base.origin}/`);
  if (
-    !RECORDED_RRD_PATH.test(descriptor.sourceUrl) ||
+    !isRecordedRrdSource(descriptor.sourceUrl) ||
    descriptor.viewerSourceUrl !== expectedViewerSourceUrl ||
    endpoint.origin !== base.origin ||
    endpoint.pathname !== descriptor.sourceUrl ||
@@ -238,16 +276,25 @@ export function rerunViewerInitialSource(
  return resolvedSourceUrl;
 }

-export function rerunViewerOpenOptions(
-  followLive: boolean,
-): { follow_if_http: true } | null {
-  return followLive ? { follow_if_http: true } : null;
-}
-
-export function resolveRecordedBlueprintUrl(sourceUrl: string, origin: string): string | null {
+export function resolveRecordedBlueprintUrl(
+  sourceUrl: string,
+  origin: string,
+  explicitSourceUrl?: string,
+): string | null {
  const normalized = sourceUrl.trim();
-  if (!RECORDED_RRD_PATH.test(normalized)) return null;
  const base = new URL(origin);
+  if (explicitSourceUrl !== undefined) {
+    const explicit = explicitSourceUrl.trim();
+    if (
+      !(LAB_RECORDED_REPLAY_PATH.test(normalized)
+        || PORTABLE_RECORDED_REPLAY_PATH.test(normalized)
+        || COMPOSITION_RECORDED_REPLAY_PATH.test(normalized))
+      || !RECORDED_BLUEPRINT_PATH.test(explicit)
+    ) return null;
+    const endpoint = new URL(explicit, `${base.origin}/`);
+    return endpoint.origin === base.origin ? endpoint.href : null;
+  }
+  if (!RECORDED_RRD_PATH.test(normalized)) return null;
  const endpoint = new URL(
    normalized.replace(/\/recording\.rrd$/, "/blueprint.rrd"),
    `${base.origin}/`,
@@ -365,6 +412,15 @@ export async function fetchRecordedBlueprintRrd(
    activeView = "spatial",
    viewResetGeneration = 0,
    followTrajectory = false,
+    semanticLayer,
+    unifiedPerception,
+    unifiedCameraShare = 0.46,
+    planView = false,
+    cameraEye,
+    eyeRelativeToTracking = false,
+    currentTimeNs,
+    reactivateUpdates = false,
+    onCameraMaxOrbitalRadius,
    perceptionLayers = {
      enabled: false,
      detections2d: false,
@@ -379,10 +435,21 @@ export async function fetchRecordedBlueprintRrd(
    activeView?: RecordedRerunView;
    viewResetGeneration?: 0 | 1;
    followTrajectory?: boolean;
+    semanticLayer?: "city" | "vegetation";
+    unifiedPerception?: boolean;
+    unifiedCameraShare?: number;
+    planView?: boolean;
+    cameraEye?: RecordedRerunCameraEye;
+    eyeRelativeToTracking?: boolean;
+    currentTimeNs?: number | null;
+    reactivateUpdates?: boolean;
+    onCameraMaxOrbitalRadius?: (maxOrbitalRadius: number) => void;
    perceptionLayers?: RecordedPerceptionLayers;
    fetcher?: typeof globalThis.fetch;
  },
 ): Promise<Uint8Array> {
+  const resolvedUnifiedPerception =
+    unifiedPerception ?? (perceptionLayers.enabled && activeView !== "spatial");
  const base = new URL(origin);
  const endpoint = new URL(endpointUrl, base.origin);
  if (
@@ -392,20 +459,37 @@ export async function fetchRecordedBlueprintRrd(
    !RECORDED_BLUEPRINT_PATH.test(endpoint.pathname) ||
    !Number.isFinite(settings.accumulationSeconds) ||
    settings.accumulationSeconds < 0 ||
-    settings.accumulationSeconds > 3600 ||
    !Number.isFinite(settings.pointSize) ||
    settings.pointSize < 0.1 ||
-    settings.pointSize > 32 ||
    !["intensity", "height", "distance", "rgb", "class"].includes(settings.colorMode) ||
    !["turbo", "viridis", "plasma", "grayscale", "custom"].includes(settings.palette) ||
    !/^#[0-9A-Fa-f]{6}$/.test(settings.customColor) ||
    !["spatial", "perception", "perception3d", "metrics"].includes(activeView) ||
    ![0, 1].includes(viewResetGeneration) ||
+    (semanticLayer !== undefined && !["city", "vegetation"].includes(semanticLayer)) ||
+    typeof resolvedUnifiedPerception !== "boolean" ||
+    !Number.isFinite(unifiedCameraShare) ||
+    unifiedCameraShare < 0.1 ||
+    unifiedCameraShare > 0.9 ||
+    typeof planView !== "boolean" ||
+    typeof eyeRelativeToTracking !== "boolean" ||
+    typeof reactivateUpdates !== "boolean" ||
+    (eyeRelativeToTracking && (cameraEye === undefined || currentTimeNs == null)) ||
+    (cameraEye !== undefined && [
+      ...cameraEye.position,
+      ...cameraEye.lookTarget,
+      ...cameraEye.eyeUp,
+    ].some((value) => !Number.isFinite(value))) ||
+    (currentTimeNs !== undefined && currentTimeNs !== null && (
+      !Number.isSafeInteger(currentTimeNs) || currentTimeNs < 0
+    )) ||
    [
      perceptionLayers.enabled,
+      perceptionLayers.cameraImage ?? true,
      perceptionLayers.detections2d,
      perceptionLayers.segmentation,
      perceptionLayers.cuboids3d,
+      perceptionLayers.costmap ?? false,
    ].some((value) => typeof value !== "boolean") ||
    identity.applicationId !== "nodedc_mission_core_recorded" ||
    !/^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/.test(identity.recordingId) ||
@@ -435,11 +519,28 @@ export async function fetchRecordedBlueprintRrd(
      active_view: activeView,
      view_reset_generation: viewResetGeneration,
      follow_trajectory: followTrajectory,
-      unified_perception:
-        perceptionLayers.detections2d || perceptionLayers.segmentation,
+      unified_perception: resolvedUnifiedPerception,
+      unified_camera_share: unifiedCameraShare,
+      semantic_layer: semanticLayer ?? null,
+      plan_view: planView,
+      eye_position: cameraEye?.position ?? null,
+      eye_look_target: cameraEye?.lookTarget ?? null,
+      eye_up: cameraEye?.eyeUp ?? null,
+      ...(eyeRelativeToTracking ? { eye_relative_to_tracking: true } : {}),
+      ...(currentTimeNs === undefined || currentTimeNs === null ? {} : {
+        current_time_ns: currentTimeNs,
+      }),
      show_detections_2d: perceptionLayers.detections2d,
+      show_camera_image: perceptionLayers.cameraImage ?? true,
      show_segmentation: perceptionLayers.segmentation,
      show_cuboids_3d: perceptionLayers.cuboids3d,
+      ...(perceptionLayers.costmap === undefined ? {} : {
+        show_costmap: perceptionLayers.costmap,
+        reactivate_updates: true,
+      }),
+      ...(reactivateUpdates && perceptionLayers.costmap === undefined
+        ? { reactivate_updates: true }
+        : {}),
    }),
    signal,
  });
@@ -463,9 +564,34 @@ export async function fetchRecordedBlueprintRrd(
  ) {
    throw new Error("Invalid recorded blueprint RRD");
  }
+  const maxOrbitalRadius = Number(
+    response.headers.get("X-MissionCore-Camera-Max-Orbital-Radius"),
+  );
+  if (Number.isFinite(maxOrbitalRadius) && maxOrbitalRadius >= 0.02) {
+    onCameraMaxOrbitalRadius?.(maxOrbitalRadius);
+  }
  return payload;
 }

+export function recordedCameraJournalContract(
+  {
+    activeView,
+    viewResetGeneration,
+    planView,
+  }: {
+    activeView: RecordedRerunView;
+    viewResetGeneration: 0 | 1;
+    planView: boolean;
+    followTrajectory: boolean;
+  },
+): string {
+  // Following is a tracking property of the current native eye. It must never
+  // initialize the browser journal again: doing so replaces the operator's
+  // current pose with the startup preset immediately before the blueprint is
+  // sent. Plan/3D and explicit reset are the only preset transitions.
+  return [activeView, viewResetGeneration, planView].join(":");
+}
+
 export async function fetchRecordedPerceptionRrd(
  endpointUrl: string,
  identity: RecordedRerunIdentity,
@@ -487,7 +613,8 @@ export async function fetchRecordedPerceptionRrd(
    endpoint.origin !== base.origin ||
    endpoint.search ||
    endpoint.hash ||
-    !RECORDED_PERCEPTION_PATH.test(endpoint.pathname) ||
+    !(RECORDED_PERCEPTION_PATH.test(endpoint.pathname) ||
+      LAB_RECORDED_PERCEPTION_PATH.test(endpoint.pathname)) ||
    identity.applicationId !== "nodedc_mission_core_recorded" ||
    !/^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/.test(identity.recordingId)
  ) {
@@ -554,6 +681,87 @@ export async function fetchRecordedPerceptionRrd(
  return payload;
 }

+/** Bind a LAB sidecar to the exact immutable base recording generation. */
+export function resolveRecordedPerceptionViewerSourceUrl(
+  endpointUrl: string,
+  identity: RecordedRerunIdentity,
+  baseGenerationSha256: string,
+  origin: string,
+): string {
+  const base = new URL(origin);
+  const endpoint = new URL(endpointUrl, base.origin);
+  if (
+    endpoint.origin !== base.origin ||
+    endpoint.search ||
+    endpoint.hash ||
+    !LAB_RECORDED_PERCEPTION_PATH.test(endpoint.pathname) ||
+    identity.applicationId !== "nodedc_mission_core_recorded" ||
+    !/^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/.test(identity.recordingId) ||
+    !/^[a-f0-9]{64}$/.test(baseGenerationSha256)
+  ) {
+    throw new Error("Unsafe recorded perception viewer source");
+  }
+  endpoint.searchParams.set("application_id", identity.applicationId);
+  endpoint.searchParams.set("recording_id", identity.recordingId);
+  endpoint.searchParams.set("generation", baseGenerationSha256);
+  return endpoint.href;
+}
+
+/** Resolve the immutable overlay generation before Rerun opens its native URL. */
+export async function probeRecordedPerceptionViewerSource(
+  sourceUrl: string,
+  {
+    origin,
+    signal,
+    fetcher = globalThis.fetch,
+  }: {
+    origin: string;
+    signal?: AbortSignal;
+    fetcher?: typeof globalThis.fetch;
+  },
+): Promise<{ sourceUrl: string; byteLength: number }> {
+  const base = new URL(origin);
+  const endpoint = new URL(sourceUrl, base.origin);
+  const allowedParameters = ["application_id", "generation", "recording_id"];
+  if (
+    endpoint.origin !== base.origin ||
+    endpoint.hash ||
+    !LAB_RECORDED_PERCEPTION_PATH.test(endpoint.pathname) ||
+    [...endpoint.searchParams.keys()].sort().join("\0") !== allowedParameters.join("\0") ||
+    endpoint.searchParams.get("application_id") !== "nodedc_mission_core_recorded" ||
+    !/^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/.test(
+      endpoint.searchParams.get("recording_id") ?? "",
+    ) ||
+    !/^[a-f0-9]{64}$/.test(endpoint.searchParams.get("generation") ?? "")
+  ) {
+    throw new Error("Unsafe recorded perception viewer source");
+  }
+  const response = await fetcher(endpoint.href, {
+    method: "HEAD",
+    credentials: "same-origin",
+    headers: {
+      Accept: "application/vnd.rerun.rrd",
+    },
+    signal,
+  });
+  const contentType = response.headers.get("Content-Type")?.split(";", 1)[0].trim();
+  const declaredLength = Number(response.headers.get("Content-Length"));
+  const etag = response.headers.get("ETag")?.match(/^"([a-f0-9]{64})"$/)?.[1];
+  if (
+    response.status !== 200 ||
+    contentType !== "application/vnd.rerun.rrd" ||
+    response.headers.get("X-Rerun-Format") !== "RRF2" ||
+    !etag ||
+    !Number.isSafeInteger(declaredLength) ||
+    declaredLength < 4 ||
+    declaredLength > MAX_PERCEPTION_BYTES
+  ) {
+    throw new Error("Invalid recorded perception viewer response");
+  }
+  endpoint.searchParams.set("overlay_generation", etag);
+  return { sourceUrl: endpoint.href, byteLength: declaredLength };
+}
+
 export function RerunViewport({
  profile,
  onStatusChange,
@@ -588,6 +796,12 @@ export function RerunViewport({
    segmentation: false,
    cuboids3d: false,
  };
+  const recordedBlueprintSourceUrl = recordedProfile?.blueprintSourceUrl;
+  const recordedPerceptionSourceUrl = recordedProfile?.perceptionSourceUrl;
+  const recordedSemanticLayer = recordedProfile?.semanticLayer;
+  const recordedUnifiedPerception = recordedProfile?.unifiedPerception ?? false;
+  const recordedUnifiedCameraShare = recordedProfile?.unifiedCameraShare ?? 0.46;
+  const recordedPlanView = recordedProfile?.planView ?? false;
  const recordedPerceptionRetryGeneration =
    recordedProfile?.perceptionRetryGeneration ?? 0;
  const lockPerceptionCameraInteraction =
@@ -610,7 +824,9 @@ export function RerunViewport({
  const uiBuildStaleRef = useRef(false);
  const blueprintChannelRef = useRef<RerunBlueprintChannel | null>(null);
  const perceptionChannelRef = useRef<RerunBlueprintChannel | null>(null);
+  const perceptionReceiverRef = useRef<RerunNativeReceiver | null>(null);
  const loadedPerceptionChannelRef = useRef<RerunBlueprintChannel | null>(null);
+  const loadedNativePerceptionSourceRef = useRef<LoadedNativePerceptionSource | null>(null);
  const appliedPointColorKeyRef = useRef<string | null>(null);
  const recordedIdentityRef = useRef<RecordedRerunIdentity | null>(null);
  const blueprintSessionIdRef = useRef(crypto.randomUUID().replaceAll("-", ""));
@@ -619,14 +835,20 @@ export function RerunViewport({
  const [blueprintChannelRevision, setBlueprintChannelRevision] = useState(0);
  const [perceptionChannelRevision, setPerceptionChannelRevision] = useState(0);
  const recordedBlueprintUrl = sourceUrl
-    ? resolveRecordedBlueprintUrl(sourceUrl, window.location.origin)
-    : null;
-  const recordedPerceptionUrl = sourceUrl
-    ? resolveRecordedPerceptionUrl(sourceUrl, window.location.origin)
-    : null;
-  const recordedPointColorsUrl = sourceUrl
-    ? resolveRecordedPointColorsUrl(sourceUrl, window.location.origin)
+    ? resolveRecordedBlueprintUrl(
+      sourceUrl,
+      window.location.origin,
+      recordedBlueprintSourceUrl,
+    )
    : null;
+  const recordedPerceptionUrl = recordedPerceptionSourceUrl
+    ? resolveRerunSourceUrl(recordedPerceptionSourceUrl, window.location.origin)
+    : sourceUrl
+      ? resolveRecordedPerceptionUrl(sourceUrl, window.location.origin)
+      : null;
+  const recordedPointColorsUrl = recordedBlueprintUrl
+    ? recordedBlueprintUrl.replace(/\/blueprint\.rrd$/, "/point-colors.rrd")
+    : sourceUrl ? resolveRecordedPointColorsUrl(sourceUrl, window.location.origin) : null;
  const presentationStatus = rerunPresentationStatus(
    status,
    presentationGate,
@@ -663,7 +885,7 @@ export function RerunViewport({
      return;
    }

-    const isRecordedSource = RECORDED_RRD_PATH.test(normalizedSource);
+    const isRecordedSource = isRecordedRrdSource(normalizedSource);
    let resolvedSource: string;
    try {
      if (isRecordedSource) {
@@ -698,6 +920,9 @@ export function RerunViewport({
    diagnosticLifecycle.verifyBuild();

    let disposed = false;
+    const blueprintOwnerId = crypto.randomUUID().replaceAll("-", "");
+    blueprintSessionIdRef.current = blueprintOwnerId;
+    let releaseBlueprintSession = () => {};
    let disposeViewer: (() => void) | undefined;
    let recordedOpenWatchdog: {
      arm: () => void;
@@ -722,8 +947,10 @@ export function RerunViewport({
    let publishPlaybackBufferState: (() => void) | null = null;
    let playbackState: RerunPlaybackState | null = null;
    const recordedAutoplay = createRecordedAutoplayGate();
+    const recordedInitialSeek = createRecordedInitialSeekGate();
    let blueprintChannel: RerunBlueprintChannel | null = null;
    let perceptionChannel: RerunBlueprintChannel | null = null;
+    let perceptionReceiver: RerunNativeReceiver | null = null;
    const unsubscribers: Array<() => void> = [];
    const unsubscribeAll = () => {
      while (unsubscribers.length > 0) {
@@ -942,6 +1169,11 @@ export function RerunViewport({
      );
    }
    activeViewerLifecycleRef.current = disposeActiveViewerLifecycle;
+    const restoreAfterPageCache = (event: PageTransitionEvent) => {
+      if (event.persisted) setRetryNonce((nonce) => nonce + 1);
+    };
+    window.addEventListener("pagehide", disposeActiveViewerLifecycle);
+    window.addEventListener("pageshow", restoreAfterPageCache);

    host.replaceChildren();
    appliedPointColorKeyRef.current = null;
@@ -949,15 +1181,22 @@ export function RerunViewport({
    setRecordingBufferProgress(null);
    onStatusChange?.("loading");

-    void import("@rerun-io/web-viewer")
-      .then(async ({ WebViewer }) => {
+    const isolatedHost = isRecordedSource ? createIsolatedRerunHost(host) : null;
+    disposeViewer = () => isolatedHost?.dispose();
+    const nativeViewer = isolatedHost?.ready ?? import("@rerun-io/web-viewer")
+      .then(({ WebViewer }) => ({ viewer: new WebViewer(), mount: host }));
+    void nativeViewer
+      .then(async ({ viewer, mount }) => {
        // React StrictMode intentionally disposes the first effect while the
        // dynamic import is still pending. Never start that stale viewer (the
        // vendor API treats a missing host as document.body).
-        if (disposed) return;
-
-        const viewer = new WebViewer();
+        if (disposed) {
+          viewer.stop();
+          isolatedHost?.dispose();
+          return;
+        }
        disposeViewer = createReentrantViewerDisposer(() => {
+          releaseBlueprintSession();
          clearRecordingTimers();
          clearPlaybackRangeTimer();
          playbackTimeUpdates.cancel();
@@ -980,6 +1219,9 @@ export function RerunViewport({
          if (perceptionChannelRef.current === perceptionChannel) {
            perceptionChannelRef.current = null;
          }
+          if (perceptionReceiverRef.current === perceptionReceiver) {
+            perceptionReceiverRef.current = null;
+          }
          recordedIdentityRef.current = null;
          try {
            blueprintChannel?.channel.close();
@@ -991,6 +1233,15 @@ export function RerunViewport({
          } catch {
            // The viewer may already have closed all auxiliary channels.
          }
+          const loadedNativeSource = loadedNativePerceptionSourceRef.current;
+          if (loadedNativeSource?.receiver === perceptionReceiver) {
+            loadedNativePerceptionSourceRef.current = null;
+            try {
+              perceptionReceiver?.close(loadedNativeSource.sourceUrl);
+            } catch {
+              // The viewer may already have closed all native receivers.
+            }
+          }
        }, () => {
          try {
            if (viewer.ready) viewer.close(resolvedSource);
@@ -1003,6 +1254,7 @@ export function RerunViewport({
            // A partially initialized WASM handle can already be gone after a
            // startup failure.
          }
+          isolatedHost?.dispose();
          host.replaceChildren();
        });
        if (isRecordedSource && recordedArtifact) {
@@ -1025,9 +1277,9 @@ export function RerunViewport({
        }) => {
            if (
              disposed ||
-              recordingOpened ||
              (isRecordedSource && event.application_id !== "nodedc_mission_core_recorded")
            ) return;
+            if (recordingOpened) return;
            recordingOpened = true;
            if (!isRecordedSource) {
              // Store discovery only establishes a candidate. Admission is
@@ -1039,6 +1291,13 @@ export function RerunViewport({
              event.application_id === "nodedc_mission_core_recorded" &&
              /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/.test(event.recording_id)
            ) {
+              releaseBlueprintSession = keepRecordedBlueprintSession({
+                endpointUrl: recordedBlueprintUrl,
+                origin: window.location.origin,
+                applicationId: event.application_id,
+                recordingId: event.recording_id,
+                ownerId: blueprintOwnerId,
+              });
              const current = recordedIdentityRef.current;
              if (
                current?.applicationId !== event.application_id ||
@@ -1195,6 +1454,23 @@ export function RerunViewport({
                  playing = true;
                }
              }
+              if (!autoplayWhenReady && !followLive && readyToRender) {
+                recordedInitialSeek.attempt(
+                  viewerStartResolved,
+                  recordedBuffer.fullyBuffered,
+                  presentationReady,
+                  rangeNs,
+                  (initialStartNs) => {
+                    viewer.set_current_time(event.recording_id, timeline, initialStartNs);
+                    currentNs = initialStartNs;
+                  },
+                  initialPlaybackStartSeconds === undefined
+                    ? expectedTimelineStartSeconds === undefined
+                      ? undefined
+                      : expectedTimelineStartSeconds * 1_000_000_000
+                    : initialPlaybackStartSeconds * 1_000_000_000,
+                );
+              }
              emitPlayback({
                rangeNs: followLive
                  ? rangeNs
@@ -1264,7 +1540,7 @@ export function RerunViewport({
          try {
            const recordingId = viewer.get_active_recording_id();
            if (!recordingId) return;
-            // Rerun 0.34.1 may ingest an SDK gRPC store without forwarding its
+            // A live SDK receiver may ingest a store without forwarding its
            // recording_open event to the JavaScript wrapper. The active store
            // is the authoritative fallback and avoids hiding a ready canvas.
            admitRecording({
@@ -1311,11 +1587,8 @@ export function RerunViewport({
        );

        try {
-          // `panel_state_overrides` is part of Rerun's runtime AppOptions but
-          // omitted from the public WebViewerOptions declaration in 0.34.1.
-          // Its generated TypeScript declaration says `hidden`, while the
-          // WASM constructor actually deserializes the Rust enum `Hidden`.
-          // Keep the post-start overrides below as a compatibility fallback.
+          // Keep all application chrome in the Mission Core shell. Rerun owns
+          // the synchronized canvas, data store and clock, not another window.
          const viewerOptions = {
            width: "100%",
            height: "100%",
@@ -1334,9 +1607,8 @@ export function RerunViewport({
          };
          await viewer.start(
            rerunViewerInitialSource(resolvedSource),
-            host,
+            mount,
            viewerOptions,
-            rerunViewerOpenOptions(followLive),
          );
          if (disposed) {
            disposeViewer();
@@ -1353,14 +1625,53 @@ export function RerunViewport({

          if (recordedBlueprintUrl) {
            const channel = viewer.open_channel("missioncore/recorded-blueprint");
-            blueprintChannel = { endpointUrl: recordedBlueprintUrl, channel };
+            blueprintChannel = {
+              endpointUrl: recordedBlueprintUrl,
+              cameraContract: null,
+              appliedFollowTrajectory: null,
+              pendingFollowCameraEye: null,
+              configureCameraJournal: (eye, spatialViewportStart) => {
+                if ("configure_camera_journal" in viewer) {
+                  viewer.configure_camera_journal(eye, spatialViewportStart);
+                }
+              },
+              getCameraEye: () => "get_camera_eye" in viewer
+                ? viewer.get_camera_eye()
+                : RECORDED_RERUN_ORBITAL_EYE,
+              setCameraViewportStart: (spatialViewportStart) => {
+                if ("set_camera_viewport_start" in viewer) {
+                  viewer.set_camera_viewport_start(spatialViewportStart);
+                }
+              },
+              getCurrentTimeNs: () => {
+                const currentIdentity = recordedIdentityRef.current;
+                if (!currentIdentity) return null;
+                return viewer.get_current_time(currentIdentity.recordingId, "session_time");
+              },
+              setCameraMaxOrbitalRadius: (maxOrbitalRadius) => {
+                if ("set_camera_max_orbital_radius" in viewer) {
+                  viewer.set_camera_max_orbital_radius(maxOrbitalRadius);
+                }
+              },
+              channel,
+            };
            blueprintChannelRef.current = blueprintChannel;
            setBlueprintChannelRevision((revision) => revision + 1);
          }
          if (recordedPerceptionUrl) {
-            const channel = viewer.open_channel("missioncore/recorded-perception");
-            perceptionChannel = { endpointUrl: recordedPerceptionUrl, channel };
-            perceptionChannelRef.current = perceptionChannel;
+            if (LAB_RECORDED_PERCEPTION_PATH.test(new URL(recordedPerceptionUrl).pathname)) {
+              perceptionReceiver = {
+                endpointUrl: recordedPerceptionUrl,
+                ready: () => viewer.ready,
+                open: (source) => viewer.open(source),
+                close: (source) => viewer.close(source),
+              };
+              perceptionReceiverRef.current = perceptionReceiver;
+            } else {
+              const channel = viewer.open_channel("missioncore/recorded-perception");
+              perceptionChannel = { endpointUrl: recordedPerceptionUrl, channel };
+              perceptionChannelRef.current = perceptionChannel;
+            }
            setPerceptionChannelRevision((revision) => revision + 1);
          }

@@ -1403,6 +1714,8 @@ export function RerunViewport({
      });

    return () => {
+      window.removeEventListener("pagehide", disposeActiveViewerLifecycle);
+      window.removeEventListener("pageshow", restoreAfterPageCache);
      if (activeViewerLifecycleRef.current === disposeActiveViewerLifecycle) {
        activeViewerLifecycleRef.current = null;
      }
@@ -1429,11 +1742,13 @@ export function RerunViewport({
    recordedArtifact?.sha256,
    recordedArtifact?.sourceUrl,
    recordedArtifact?.viewerSourceUrl,
+    recordedPerceptionUrl,
    retryNonce,
  ]);

  useEffect(() => {
    loadedPerceptionChannelRef.current = null;
+    loadedNativePerceptionSourceRef.current = null;
  }, [recordedPerceptionUrl]);

  useEffect(() => {
@@ -1453,11 +1768,92 @@ export function RerunViewport({
      }
      return;
    }
-    const active = perceptionChannelRef.current;
    const identity = recordedIdentityRef.current;
+    if (!identity) return;
+    if (LAB_RECORDED_PERCEPTION_PATH.test(new URL(recordedPerceptionUrl).pathname)) {
+      const receiver = perceptionReceiverRef.current;
+      if (
+        !receiver ||
+        receiver.endpointUrl !== recordedPerceptionUrl ||
+        !receiver.ready() ||
+        !recordedArtifact
+      ) return;
+      let sourceUrl: string;
+      try {
+        sourceUrl = resolveRecordedPerceptionViewerSourceUrl(
+          recordedPerceptionUrl,
+          identity,
+          recordedArtifact.sha256,
+          window.location.origin,
+        );
+      } catch {
+        onPerceptionLoadChange?.({
+          phase: "error",
+          receivedBytes: 0,
+          totalBytes: null,
+          progress: null,
+          message: "AI-слои не привязаны к поколению записи.",
+        });
+        return;
+      }
+      const loaded = loadedNativePerceptionSourceRef.current;
+      if (loaded?.receiver === receiver && loaded.descriptorUrl === sourceUrl) {
+        onPerceptionLoadChange?.({
+          phase: "ready",
+          receivedBytes: loaded.byteLength,
+          totalBytes: loaded.byteLength,
+          progress: 1,
+          message: "AI-слои подключены к Rerun.",
+        });
+        return;
+      }
+      const abort = new AbortController();
+      onPerceptionLoadChange?.({
+        phase: "loading",
+        receivedBytes: 0,
+        totalBytes: null,
+        progress: null,
+        message: "Подключаем AI-слои к Rerun.",
+      });
+      void probeRecordedPerceptionViewerSource(sourceUrl, {
+        origin: window.location.origin,
+        signal: abort.signal,
+      }).then(({ sourceUrl: immutableSourceUrl, byteLength }) => {
+        if (
+          abort.signal.aborted ||
+          perceptionReceiverRef.current !== receiver ||
+          recordedIdentityRef.current !== identity ||
+          !receiver.ready()
+        ) return;
+        receiver.open(immutableSourceUrl);
+        loadedNativePerceptionSourceRef.current = {
+          receiver,
+          descriptorUrl: sourceUrl,
+          sourceUrl: immutableSourceUrl,
+          byteLength,
+        };
+        onPerceptionLoadChange?.({
+          phase: "ready",
+          receivedBytes: byteLength,
+          totalBytes: byteLength,
+          progress: 1,
+          message: "AI-слои подключены к Rerun.",
+        });
+      }).catch(() => {
+        if (abort.signal.aborted) return;
+        onPerceptionLoadChange?.({
+          phase: "error",
+          receivedBytes: 0,
+          totalBytes: null,
+          progress: null,
+          message: "AI-слои не загрузились. Можно повторить.",
+        });
+      });
+      return () => abort.abort();
+    }
+    const active = perceptionChannelRef.current;
    if (
      !active ||
-      !identity ||
      active.endpointUrl !== recordedPerceptionUrl ||
      !active.channel.ready
    ) return;
@@ -1484,6 +1880,7 @@ export function RerunViewport({
      message: "Сервер готовит AI-слои.",
    });
    const pollPreparationStatus = () => {
+      if (!RECORDED_PERCEPTION_PATH.test(new URL(recordedPerceptionUrl).pathname)) return;
      void fetchPerceptionPreparationStatus(
        recordedPerceptionUrl,
        identity.recordingId,
@@ -1597,6 +1994,7 @@ export function RerunViewport({
  }, [
    onPerceptionLoadChange,
    perceptionChannelRevision,
+    recordedArtifact?.sha256,
    recordedPerceptionLayers.enabled,
    recordedPerceptionRetryGeneration,
    recordedPerceptionUrl,
@@ -1687,6 +2085,9 @@ export function RerunViewport({

  useEffect(() => {
    if (!recordedBlueprintUrl || !sceneSettings) return;
+    // Initialize the portable following-eye blueprint after native admission
+    // and its initial seek, not while the base RRD is still arriving.
+    if (recordedPerceptionLayers.costmap !== undefined && status !== "ready") return;
    const active = blueprintChannelRef.current;
    const identity = recordedIdentityRef.current;
    if (
@@ -1695,26 +2096,116 @@ export function RerunViewport({
      active.endpointUrl !== recordedBlueprintUrl ||
      !active.channel.ready
    ) return;
+    const cameraContract = recordedCameraJournalContract(
+      {
+        activeView: recordedView,
+        viewResetGeneration: recordedViewResetGeneration,
+        planView: recordedPlanView,
+        followTrajectory: recordedFollowTrajectory,
+      },
+    );
+    const cameraContractChanged = active.cameraContract !== cameraContract;
+    if (cameraContractChanged) {
+      active.configureCameraJournal?.(
+        recordedPlanView ? RECORDED_RERUN_PLAN_EYE : RECORDED_RERUN_ORBITAL_EYE,
+        recordedUnifiedPerception ? recordedUnifiedCameraShare : 0,
+      );
+    }
    const abort = new AbortController();
-    void fetchRecordedBlueprintRrd(recordedBlueprintUrl, sceneSettings, identity, {
-      origin: window.location.origin,
-      blueprintSessionId: blueprintSessionIdRef.current,
-      signal: abort.signal,
-      activeView: recordedView,
-      viewResetGeneration: recordedViewResetGeneration,
-      followTrajectory: recordedFollowTrajectory,
-      perceptionLayers: recordedPerceptionLayers,
-    }).then((payload) => {
-      if (
-        abort.signal.aborted ||
-        blueprintChannelRef.current !== active ||
-        recordedIdentityRef.current !== identity ||
-        !active.channel.ready
-      ) {
+    const previousFollow = active.appliedFollowTrajectory ?? false;
+    const enablingFollow = recordedFollowTrajectory && !previousFollow;
+    const disablingFollow = !recordedFollowTrajectory && previousFollow;
+    const transitionEye = (enablingFollow || disablingFollow)
+      ? active.getCameraEye?.()
+      : null;
+    if (enablingFollow && transitionEye) {
+      active.pendingFollowCameraEye = transitionEye;
+    } else if (disablingFollow) {
+      active.pendingFollowCameraEye = null;
+    }
+    const pendingFollowEye = recordedFollowTrajectory
+      ? active.pendingFollowCameraEye ?? null
+      : null;
+    const requestBlueprint = async (
+      cameraEye?: RecordedRerunCameraEye,
+      eyeRelativeToTracking = false,
+      reactivateUpdates = false,
+    ) => {
+      const currentTimeNs = active.getCurrentTimeNs?.();
+      if (eyeRelativeToTracking && currentTimeNs == null) {
+        throw new Error("Recorded tracking cursor is unavailable");
+      }
+      return fetchRecordedBlueprintRrd(recordedBlueprintUrl, sceneSettings, identity, {
+        origin: window.location.origin,
+        blueprintSessionId: blueprintSessionIdRef.current,
+        signal: abort.signal,
+        activeView: recordedView,
+        viewResetGeneration: recordedViewResetGeneration,
+        followTrajectory: recordedFollowTrajectory,
+        perceptionLayers: recordedPerceptionLayers,
+        semanticLayer: recordedSemanticLayer,
+        unifiedPerception: recordedUnifiedPerception,
+        unifiedCameraShare: recordedUnifiedCameraShare,
+        planView: recordedPlanView,
+        cameraEye,
+        eyeRelativeToTracking,
+        currentTimeNs,
+        reactivateUpdates,
+        onCameraMaxOrbitalRadius: (maxOrbitalRadius) => {
+          if (blueprintChannelRef.current === active) {
+            active.setCameraMaxOrbitalRadius?.(maxOrbitalRadius);
+          }
+        },
+      });
+    };
+    const canApply = () => (
+      !abort.signal.aborted &&
+      blueprintChannelRef.current === active &&
+      recordedIdentityRef.current === identity &&
+      active.channel.ready
+    );
+    const applyPayload = (payload: Uint8Array) => {
+      if (!canApply()) return false;
+      active.channel.send_rrd(payload);
+      active.setCameraViewportStart?.(
+        recordedUnifiedPerception ? recordedUnifiedCameraShare : 0,
+      );
+      return true;
+    };
+    void (async () => {
+      const firstEye = disablingFollow
+        ? transitionEye ?? undefined
+        : !enablingFollow && (cameraContractChanged || pendingFollowEye)
+          ? pendingFollowEye ?? active.getCameraEye?.()
+          : undefined;
+      const firstEyeIsTrackingRelative = Boolean(firstEye) && (
+        disablingFollow || recordedFollowTrajectory
+      );
+      const firstPayload = await requestBlueprint(
+        firstEye,
+        firstEyeIsTrackingRelative,
+        enablingFollow || disablingFollow || Boolean(pendingFollowEye),
+      );
+      if (!applyPayload(firstPayload)) return;
+      active.cameraContract = cameraContract;
+      active.appliedFollowTrajectory = recordedFollowTrajectory;
+      if (!enablingFollow || !transitionEye) {
+        if (pendingFollowEye && firstEye === pendingFollowEye) {
+          active.pendingFollowCameraEye = null;
+        }
        return;
      }
-      active.channel.send_rrd(payload);
-    }).catch(() => {
+
+      // Rerun 0.36.3 intentionally fits a newly tracked transform to its
+      // bounding box. Apply the operator's relative eye on the next native
+      // frame, after tracking is established, to retain direction and zoom.
+      await new Promise<void>((resolve) => window.requestAnimationFrame(() => resolve()));
+      await new Promise<void>((resolve) => window.requestAnimationFrame(() => resolve()));
+      if (!canApply()) return;
+      const stabilizedPayload = await requestBlueprint(transitionEye, true, true);
+      if (!applyPayload(stabilizedPayload)) return;
+      active.pendingFollowCameraEye = null;
+    })().catch(() => {
      // The recording remains usable with its embedded default blueprint.
      // A later settings change retries through the same small channel.
    });
@@ -1725,10 +2216,17 @@ export function RerunViewport({
    recordedView,
    recordedViewResetGeneration,
    recordedFollowTrajectory,
+    recordedSemanticLayer,
+    recordedUnifiedPerception,
+    recordedUnifiedCameraShare,
+    recordedPlanView,
    recordedPerceptionLayers.enabled,
+    recordedPerceptionLayers.cameraImage,
    recordedPerceptionLayers.detections2d,
    recordedPerceptionLayers.segmentation,
    recordedPerceptionLayers.cuboids3d,
+    recordedPerceptionLayers.costmap,
+    status,
    sceneSettings?.accumulationSeconds,
    sceneSettings?.customColor,
    sceneSettings?.colorMode,
@@ -0,0 +1,33 @@
+import { CanonicalResultRerunReplay } from "./CanonicalResultRerunReplay";
+import { resolveAICompositionReplay } from "../../core/laboratory/canonicalLabReplay";
+import type { ObservationSessionReplayLaunch } from "../../core/observation/sessionArchive";
+import type { AICompositionRun } from "../../core/observatory/aiComposition";
+
+function resolveComposition(
+  runId: string,
+  launch: ObservationSessionReplayLaunch,
+  options: { signal: AbortSignal },
+) {
+  return resolveAICompositionReplay(runId, launch, options);
+}
+
+export function AICompositionReplay({ run }: { run: AICompositionRun }) {
+  const semantics = run.moduleIds.includes("ddrnet") || run.moduleIds.includes("eomt");
+  const detections = run.moduleIds.includes("rf-detr")
+    || run.moduleIds.includes("object-distance");
+  const costmap = run.moduleIds.includes("tgs");
+  return (
+    <CanonicalResultRerunReplay
+      key={run.runId}
+      resultId={run.runId}
+      sessionId={run.sourceSessionId}
+      resolveReplay={resolveComposition}
+      semantics={semantics}
+      detections={detections}
+      costmap={costmap}
+      moduleIds={run.moduleIds}
+      viewerLayers={run.presentation.viewerLayers}
+      label={run.configurationLabel}
+    />
+  );
+}
@@ -9,6 +9,7 @@ export const CANONICAL_RECORDED_LAB_REPLAY_CONTRACT =
 export interface CanonicalRecordedLabMode<T extends string> {
  value: T;
  label: string;
+  disabled?: boolean;
 }

 /**
@@ -87,9 +88,13 @@ export function CanonicalRecordedLabReplay<
  mediaLayerControls,
  spatialLayerControls,
  spatialLeadingControl,
+  spatialTrailingControl,
+  mediaModeControlsVisible = true,
+  paneToolbarsAlwaysVisible = false,
  mediaMultiLayer = false,
  mediaContent,
  spatialContent,
+  unifiedContent,
  emptyMessage,
  deckOverlays,
  actions,
@@ -114,9 +119,15 @@ export function CanonicalRecordedLabReplay<
  mediaLayerControls?: ReactNode;
  spatialLayerControls?: ReactNode;
  spatialLeadingControl?: ReactNode;
+  spatialTrailingControl?: ReactNode;
+  mediaModeControlsVisible?: boolean;
+  /** Keeps renderer-local controls inside their viewport when only one pane is present. */
+  paneToolbarsAlwaysVisible?: boolean;
  mediaMultiLayer?: boolean;
-  mediaContent: ReactNode;
-  spatialContent: ReactNode;
+  mediaContent?: ReactNode;
+  spatialContent?: ReactNode;
+  /** One upstream Rerun viewer owns both panes; this controlled split owns their shared geometry. */
+  unifiedContent?: ReactNode;
  emptyMessage: string;
  deckOverlays?: ReactNode;
  actions?: ReactNode;
@@ -135,6 +146,7 @@ export function CanonicalRecordedLabReplay<
        value={mediaMode}
        items={[...mediaModes]}
        label="Видео и камера"
+        size="dense"
        onChange={onMediaModeChange}
      />
    </div>
@@ -145,6 +157,7 @@ export function CanonicalRecordedLabReplay<
        value={spatialMode}
        items={[...spatialModes]}
        label="3D и план"
+        size="dense"
        onChange={onSpatialModeChange}
      />
    </div>
@@ -156,14 +169,14 @@ export function CanonicalRecordedLabReplay<
      aria-label={mediaAriaLabel}
      hidden={mediaMode === "none"}
    >
-      {splitView ? (
+      {splitView || paneToolbarsAlwaysVisible ? (
        <div
          className="m4-replay-threat-visual__pane-toolbar"
          data-pane-toolbar="media"
          data-multi-semantic={mediaMultiLayer ? "true" : undefined}
        >
          {mediaLayerControls}
-          {mediaModeControls}
+          {mediaModeControlsVisible ? mediaModeControls : null}
        </div>
      ) : null}
      {mediaContent}
@@ -175,7 +188,7 @@ export function CanonicalRecordedLabReplay<
      data-pane="spatial"
      aria-label={spatialAriaLabel}
    >
-      {splitView ? (
+      {splitView || paneToolbarsAlwaysVisible ? (
        <div
          className="m4-replay-threat-visual__pane-toolbar"
          data-pane-toolbar="spatial"
@@ -184,6 +197,7 @@ export function CanonicalRecordedLabReplay<
          <div className="m4-replay-threat-visual__spatial-toolbar-end">
            {spatialLayerControls}
            {spatialModeControls}
+            {spatialTrailingControl}
          </div>
        </div>
      ) : null}
@@ -210,7 +224,7 @@ export function CanonicalRecordedLabReplay<
        expanded={expanded}
        onModeChange={onMediaModeChange}
        onExpandedChange={onExpandedChange}
-        modeControlsVisible={!splitView}
+        modeControlsVisible={!splitView && !paneToolbarsAlwaysVisible}
        actions={actions}
        overlay={overlay}
        transport={transport}
@@ -220,7 +234,13 @@ export function CanonicalRecordedLabReplay<
          className="m4-replay-threat-visual__deck"
          data-split={splitView ? "true" : undefined}
          data-empty={mediaMode === "none" && spatialMode === "none" ? "true" : undefined}
+          data-native-rerun={unifiedContent ? "true" : undefined}
        >
+          {unifiedContent ? (
+            <div className="m4-replay-threat-visual__unified-content">
+              {unifiedContent}
+            </div>
+          ) : null}
          <SplitPane
            primary={mediaPane}
            secondary={spatialPane ?? <div />}
@@ -230,7 +250,7 @@ export function CanonicalRecordedLabReplay<
            minPrimarySize={splitView ? 24 : 0}
            minSecondarySize={splitView ? 24 : 0}
            resizable={splitView}
-            separatorLabel="Изменить размер VIDEO/CAMERA и 3D/PLAN"
+            separatorLabel="Изменить размер видео/камеры и 3D/плана"
          />
          {mediaMode === "none" && spatialMode === "none" ? (
            <div className="l3-visual-audit__state" role="status">
@@ -0,0 +1,524 @@
+import {
+  useCallback,
+  useEffect,
+  useMemo,
+  useRef,
+  useState,
+} from "react";
+import {
+  ActivityIndicator,
+  Button,
+  Checker,
+  ControlRow,
+  Icon,
+  IconButton,
+  Inspector,
+  InspectorSelectField,
+  RangeControl,
+  ToastStack,
+  Window,
+  type ToastItem,
+} from "@nodedc/ui-react";
+
+import { ObservationTimeline } from "../ObservationTimeline";
+import {
+  RerunViewport,
+  isRecordedPlaybackPresentationReady,
+  type RerunPlaybackController,
+  type RerunPlaybackState,
+  type RerunViewportStatus,
+} from "../RerunViewport";
+import {
+  CanonicalRecordedLabReplay,
+  useCanonicalRecordedLabReplayState,
+} from "../laboratory/CanonicalRecordedLabReplay";
+import type { CanonicalLabReplayDescriptor } from "../../core/laboratory/canonicalLabReplay";
+import type { ObservationSessionReplayLaunch } from "../../core/observation/sessionArchive";
+import { recordedSessionRerunProfile } from "../../core/observation/viewerProfile";
+import { resolveObservationSessionReplay } from "../../core/observation/useObservationSessions";
+import type { AIViewerLayer } from "../../core/observatory/aiComposition";
+import {
+  fetchLabViewProfile,
+  saveLabViewProfile,
+} from "../../core/observatory/labViewProfile";
+import {
+  defaultSceneSettings,
+  type PointColorMode,
+  type PointPalette,
+  type SceneSettings,
+} from "../../sceneSettings";
+
+type MediaMode = "camera";
+type SpatialMode = "3d" | "plan";
+
+interface CanonicalReplayLaunch {
+  base: ObservationSessionReplayLaunch;
+  replay: CanonicalLabReplayDescriptor;
+}
+
+const RERUN_UNIFIED_CAMERA_SHARE_PERCENT = 46;
+const LAB_SCENE_SETTINGS_STORAGE_PREFIX = "missioncore.observatory.lab-scene-settings.v1:";
+const LAB_VIEW_PROFILE_ERROR_TOAST = "observatory-lab-view-profile-error";
+
+const COLOR_OPTIONS: readonly { value: PointColorMode; label: string }[] = [
+  { value: "intensity", label: "Интенсивность" },
+  { value: "height", label: "Высота Z" },
+  { value: "distance", label: "Дистанция" },
+  { value: "rgb", label: "RGB" },
+  { value: "class", label: "Класс" },
+];
+
+const PALETTE_OPTIONS: readonly { value: PointPalette; label: string }[] = [
+  { value: "turbo", label: "Turbo" },
+  { value: "viridis", label: "Viridis" },
+  { value: "plasma", label: "Plasma" },
+  { value: "grayscale", label: "Серый" },
+];
+
+const LAB_SCENE_DEFAULTS: SceneSettings = {
+  ...defaultSceneSettings,
+  pointSize: 3.8,
+  accumulationSeconds: 5,
+};
+
+export function normalizeLabSceneSettings(settings: SceneSettings): SceneSettings {
+  const pointSize = Number.isFinite(settings.pointSize) ? settings.pointSize : LAB_SCENE_DEFAULTS.pointSize;
+  const accumulationSeconds = Number.isFinite(settings.accumulationSeconds)
+    ? settings.accumulationSeconds : LAB_SCENE_DEFAULTS.accumulationSeconds;
+  return {
+    ...settings,
+    pointSize: Math.round(Math.max(0.1, pointSize) * 10) / 10,
+    accumulationSeconds: Math.round(Math.max(0, accumulationSeconds)),
+  };
+}
+
+function loadLabSceneSettings(resultId: string): SceneSettings {
+  if (typeof window === "undefined") return LAB_SCENE_DEFAULTS;
+  try {
+    const raw = window.localStorage.getItem(`${LAB_SCENE_SETTINGS_STORAGE_PREFIX}${resultId}`);
+    if (raw === null) return LAB_SCENE_DEFAULTS;
+    const value: unknown = JSON.parse(raw);
+    if (typeof value !== "object" || value === null || Array.isArray(value)) return LAB_SCENE_DEFAULTS;
+    const row = value as Record<string, unknown>;
+    const pointSize = row.pointSize;
+    const accumulationSeconds = row.accumulationSeconds;
+    const colorMode = row.colorMode;
+    const palette = row.palette;
+    const showGrid = row.showGrid;
+    const showLabels = row.showLabels;
+    const showCameraFrustums = row.showCameraFrustums;
+    if (
+      typeof pointSize !== "number" || !Number.isFinite(pointSize) || pointSize < 0.1
+      || typeof accumulationSeconds !== "number" || !Number.isFinite(accumulationSeconds)
+      || accumulationSeconds < 0
+      || !COLOR_OPTIONS.some((option) => option.value === colorMode)
+      || !PALETTE_OPTIONS.some((option) => option.value === palette)
+      || typeof showGrid !== "boolean"
+      || typeof showLabels !== "boolean"
+      || typeof showCameraFrustums !== "boolean"
+    ) return LAB_SCENE_DEFAULTS;
+    return {
+      ...LAB_SCENE_DEFAULTS,
+      pointSize,
+      accumulationSeconds,
+      colorMode: colorMode as PointColorMode,
+      palette: palette as PointPalette,
+      showGrid,
+      showLabels,
+      showCameraFrustums,
+    };
+  } catch {
+    return LAB_SCENE_DEFAULTS;
+  }
+}
+
+export function CanonicalResultRerunReplay({
+  resultId,
+  sessionId,
+  initialPlaybackStartSeconds,
+  resolveReplay,
+  semantics = false,
+  detections = false,
+  costmap = false,
+  moduleIds = [],
+  viewerLayers = [],
+  label = "Сохранённый результат",
+}: {
+  resultId: string;
+  sessionId: string;
+  initialPlaybackStartSeconds?: number;
+  resolveReplay: (resultId: string, launch: ObservationSessionReplayLaunch, options: { signal: AbortSignal }) => Promise<CanonicalLabReplayDescriptor>;
+  semantics?: boolean;
+  detections?: boolean;
+  costmap?: boolean;
+  portable?: boolean;
+  moduleIds?: readonly string[];
+  viewerLayers?: readonly AIViewerLayer[];
+  label?: string;
+}) {
+  const {
+    mediaMode,
+    spatialMode,
+    splitPrimarySize,
+    splitOrientation,
+    expanded,
+    onMediaModeChange,
+    onSpatialModeChange,
+    onSplitPrimarySizeChange,
+    onExpandedChange,
+  } = useCanonicalRecordedLabReplayState<MediaMode, SpatialMode>({
+    initialMediaMode: "camera",
+    initialSpatialMode: "3d",
+  });
+  const layerIds = useMemo(
+    () => new Set(viewerLayers.map((layer) => layer.layerId)),
+    [viewerLayers],
+  );
+  const hasProjectedLayers = viewerLayers.length > 0;
+  const hasDDRNet = layerIds.has("camera.ddrnet")
+    || (!hasProjectedLayers && semantics && moduleIds.includes("ddrnet"));
+  const hasEoMT = layerIds.has("camera.eomt")
+    || (!hasProjectedLayers && semantics && moduleIds.includes("eomt"));
+  const hasFallbackSemantics = semantics && !hasDDRNet && !hasEoMT;
+  const hasDetections = layerIds.has("camera.detections") || (!hasProjectedLayers && detections);
+  const hasTgs = layerIds.has("spatial.tgs") || (!hasProjectedLayers && costmap);
+  const legacyUnclassified = !hasProjectedLayers
+    && moduleIds.length === 0
+    && !semantics
+    && !detections
+    && !costmap;
+  const hasCameraPane = layerIds.has("camera.source")
+    || (!hasProjectedLayers && (legacyUnclassified || semantics || detections));
+  const hasSourcePoints = layerIds.has("spatial.source-points")
+    || (!hasProjectedLayers && (legacyUnclassified || costmap || moduleIds.includes("object-distance")));
+  const hasLocalSlam = layerIds.has("spatial.local-slam")
+    || (!hasProjectedLayers && (legacyUnclassified || costmap || moduleIds.includes("object-distance")));
+  const hasSpatialPane = hasSourcePoints || hasLocalSlam || hasTgs;
+  const splitView = hasCameraPane && hasSpatialPane;
+
+  const [showCamera, setShowCamera] = useState(true);
+  const [showDDRNet, setShowDDRNet] = useState(hasDDRNet || hasFallbackSemantics);
+  const [showEoMT, setShowEoMT] = useState(hasEoMT);
+  const [showDetections, setShowDetections] = useState(hasDetections);
+  const [showSourcePoints, setShowSourcePoints] = useState(hasSourcePoints);
+  const [showLocalSlam, setShowLocalSlam] = useState(hasLocalSlam);
+  const [showTgs, setShowTgs] = useState(hasTgs);
+  const [followTarget, setFollowTarget] = useState(false);
+  const [settingsOpen, setSettingsOpen] = useState(false);
+  const [sceneDraft, setSceneDraft] = useState<SceneSettings>(() => loadLabSceneSettings(resultId));
+  const [blueprintSplitPrimarySize, setBlueprintSplitPrimarySize] = useState(
+    RERUN_UNIFIED_CAMERA_SHARE_PERCENT,
+  );
+  const [toasts, setToasts] = useState<ToastItem[]>([]);
+  const [viewResetGeneration, setViewResetGeneration] = useState<0 | 1>(hasTgs ? 1 : 0);
+  const [playback, setPlayback] = useState<RerunPlaybackState | null>(null);
+  const [playbackController, setPlaybackController] = useState<RerunPlaybackController | null>(null);
+  const [viewerStatus, setViewerStatus] = useState<RerunViewportStatus>("idle");
+  const [launch, setLaunch] = useState<CanonicalReplayLaunch | null>(null);
+  const [launchError, setLaunchError] = useState<string | null>(null);
+  const sceneDraftRef = useRef(sceneDraft);
+  const previousSplitViewRef = useRef(splitView);
+  const trackedLaunchSha256Ref = useRef<string | null>(null);
+
+  useEffect(() => {
+    const launchSha256 = launch?.replay.sha256 ?? null;
+    if (trackedLaunchSha256Ref.current !== launchSha256 || (splitView && !previousSplitViewRef.current)) {
+      onSplitPrimarySizeChange(RERUN_UNIFIED_CAMERA_SHARE_PERCENT);
+      setBlueprintSplitPrimarySize(RERUN_UNIFIED_CAMERA_SHARE_PERCENT);
+    }
+    trackedLaunchSha256Ref.current = launchSha256;
+    previousSplitViewRef.current = splitView;
+  }, [launch?.replay.sha256, onSplitPrimarySizeChange, splitView]);
+
+  useEffect(() => {
+    if (!splitView) return;
+    const timer = window.setTimeout(() => setBlueprintSplitPrimarySize(splitPrimarySize), 75);
+    return () => window.clearTimeout(timer);
+  }, [splitPrimarySize, splitView]);
+
+  useEffect(() => {
+    try {
+      window.localStorage.setItem(
+        `${LAB_SCENE_SETTINGS_STORAGE_PREFIX}${resultId}`,
+        JSON.stringify({
+          pointSize: sceneDraft.pointSize,
+          accumulationSeconds: sceneDraft.accumulationSeconds,
+          colorMode: sceneDraft.colorMode,
+          palette: sceneDraft.palette,
+          showGrid: sceneDraft.showGrid,
+          showLabels: sceneDraft.showLabels,
+          showCameraFrustums: sceneDraft.showCameraFrustums,
+        }),
+      );
+    } catch {
+      // The visual remains usable when the browser refuses local persistence.
+    }
+  }, [resultId, sceneDraft]);
+
+  useEffect(() => {
+    const controller = new AbortController();
+    void fetchLabViewProfile(resultId, controller.signal).then((settings) => {
+      if (!controller.signal.aborted && settings) {
+        sceneDraftRef.current = settings;
+        setSceneDraft(settings);
+      }
+    }).catch(() => {
+      // The per-browser copy remains a usable fallback while the local service recovers.
+    });
+    return () => controller.abort();
+  }, [resultId]);
+
+  useEffect(() => {
+    const controller = new AbortController();
+    setLaunch(null);
+    setLaunchError(null);
+    setPlayback(null);
+    setPlaybackController(null);
+    setViewerStatus("idle");
+    void resolveObservationSessionReplay(sessionId, {
+      signal: controller.signal,
+      maximumWaitMs: 30 * 60 * 1000,
+      onUpdate: () => undefined,
+    }).then(async (value) => ({
+      base: value,
+      replay: await resolveReplay(resultId, value, { signal: controller.signal }),
+    })).then((value) => {
+      if (!controller.signal.aborted) setLaunch(value);
+    }).catch((caught: unknown) => {
+      if (!controller.signal.aborted) {
+        setLaunchError(caught instanceof Error ? caught.message : "Сохранённая запись недоступна.");
+      }
+    });
+    return () => controller.abort();
+  }, [resultId, sessionId, resolveReplay]);
+
+  const presentationReady = playbackController !== null
+    && isRecordedPlaybackPresentationReady(viewerStatus, playback);
+  const presentationState = launchError || viewerStatus === "error"
+    ? "error"
+    : presentationReady ? "ready" : "loading";
+  const sceneSettings = useMemo<SceneSettings>(() => ({
+    ...sceneDraft,
+    projection: spatialMode === "plan" ? "2d" : "3d",
+    showPoints: spatialMode !== null && (showSourcePoints || showLocalSlam),
+    showTrajectory: spatialMode !== null && showLocalSlam,
+    accumulationSeconds: showLocalSlam ? sceneDraft.accumulationSeconds : 0,
+  }), [sceneDraft, showLocalSlam, showSourcePoints, spatialMode]);
+  const semanticVisible = showDDRNet || showEoMT;
+  const profile = launch ? recordedSessionRerunProfile({
+    sourceUrl: launch.replay.sourceUrl,
+    artifact: {
+      sourceUrl: launch.replay.sourceUrl,
+      viewerSourceUrl: launch.replay.viewerSourceUrl,
+      byteLength: launch.replay.byteLength,
+      sha256: launch.replay.sha256,
+    },
+    blueprintSourceUrl: launch.replay.blueprintSourceUrl,
+    autoplayWhenReady: false,
+    presentationGate: "ready",
+    expectedTimelineStartSeconds: launch.base.timelineStartSeconds,
+    expectedTimelineEndSeconds: launch.base.timelineEndSeconds,
+    initialPlaybackStartSeconds: initialPlaybackStartSeconds
+      ?? ((launch.base.mediaSources[0]?.timelineStartSeconds ?? launch.base.timelineStartSeconds)
+        + (hasTgs ? 0.000001 : 0)),
+    view: hasCameraPane && !hasSpatialPane ? "perception" : "spatial",
+    viewResetGeneration,
+    followTrajectory: followTarget,
+    semanticLayer: showEoMT ? "city" : "vegetation",
+    unifiedPerception: splitView,
+    unifiedCameraShare: blueprintSplitPrimarySize / 100,
+    planView: spatialMode === "plan",
+    perceptionLayers: {
+      enabled: true,
+      cameraImage: showCamera,
+      detections2d: hasDetections && showDetections,
+      segmentation: semantics && semanticVisible,
+      cuboids3d: false,
+      costmap: hasTgs && showTgs,
+    },
+    perceptionRetryGeneration: 0,
+    lockPerceptionCameraInteraction: false,
+  }) : null;
+
+  const toggle = (caption: string, active: boolean, onClick: () => void) => (
+    <Button key={caption} size="dense" shape="pill" variant={active ? "primary" : "secondary"}
+      aria-pressed={active} onClick={onClick}>
+      {caption}
+    </Button>
+  );
+  const openSlamSettings = useCallback(() => {
+    if (expanded) onExpandedChange(false);
+    setSettingsOpen(true);
+  }, [expanded, onExpandedChange]);
+  const patchSceneDraft = useCallback((patch: Partial<SceneSettings>) => {
+    const next = { ...sceneDraftRef.current, ...patch };
+    sceneDraftRef.current = next;
+    setSceneDraft(next);
+  }, []);
+  const closeSlamSettings = useCallback(() => {
+    const next = normalizeLabSceneSettings(sceneDraftRef.current);
+    sceneDraftRef.current = next;
+    setSceneDraft(next);
+    setSettingsOpen(false);
+    void saveLabViewProfile(resultId, next).then((settings) => {
+      sceneDraftRef.current = settings;
+      setSceneDraft(settings);
+      setToasts((current) => current.filter(({ id }) => id !== LAB_VIEW_PROFILE_ERROR_TOAST));
+    }).catch(() => {
+      setToasts((current) => [
+        ...current.filter(({ id }) => id !== LAB_VIEW_PROFILE_ERROR_TOAST),
+        {
+          id: LAB_VIEW_PROFILE_ERROR_TOAST,
+          tone: "error",
+          title: "Настройки LAB не сохранились",
+          description: "Изменения остались в текущем просмотре. Откройте настройки и повторите.",
+        },
+      ]);
+    });
+  }, [resultId]);
+  const mediaLayerControls = (
+    <div className="m4-replay-threat-visual__pane-layer-controls" role="group" aria-label="Слои камеры">
+      {toggle("КАМЕРА", showCamera, () => setShowCamera((value) => !value))}
+      {hasEoMT ? toggle("EOMT", showEoMT, () => setShowEoMT((value) => !value)) : null}
+      {hasDDRNet || hasFallbackSemantics
+        ? toggle("DDRNET", showDDRNet, () => setShowDDRNet((value) => !value)) : null}
+      {hasDetections
+        ? toggle("РАМКИ", showDetections, () => setShowDetections((value) => !value)) : null}
+    </div>
+  );
+  const spatialLayerControls = (
+    <div className="m4-replay-threat-visual__pane-layer-controls" role="group" aria-label="Слои облака точек">
+      {hasSourcePoints
+        ? toggle("ИСХ. ТОЧКИ", showSourcePoints, () => setShowSourcePoints((value) => !value)) : null}
+      {hasLocalSlam ? (
+        <div className="m4-replay-threat-visual__layer-with-settings">
+          {toggle("ЛОК. SLAM", showLocalSlam, () => setShowLocalSlam((value) => !value))}
+          <IconButton label="Настройки облака SLAM" onClick={openSlamSettings}>
+            <Icon name="settings" size={14} />
+          </IconButton>
+        </div>
+      ) : null}
+      {hasTgs ? toggle("TGS", showTgs, () => setShowTgs((value) => !value)) : null}
+    </div>
+  );
+  const followTargetControl = toggle(
+    "СЛЕДОВАТЬ",
+    followTarget,
+    () => setFollowTarget((value) => !value),
+  );
+  const resetSpatialView = (
+    <IconButton label="Сбросить положение видов"
+      onClick={() => setViewResetGeneration((value) => value === 0 ? 1 : 0)}>
+      <Icon name="refresh" size={16} />
+    </IconButton>
+  );
+
+  const transport = presentationReady && playback && playbackController ? (
+    <ObservationTimeline
+      className="m4-replay-threat-visual__timeline canonical-vegetation-rerun-replay__timeline"
+      active
+      sourceCount={3}
+      mode="recorded"
+      seekable
+      synchronization="shared-clock"
+      rangeNs={playback.rangeNs}
+      currentNs={playback.currentNs}
+      playing={playback.playing}
+      onSeek={playbackController.seek}
+      onPlayingChange={playbackController.setPlaying}
+      showJumpToEnd={false}
+    />
+  ) : undefined;
+
+  return (
+    <div className="canonical-vegetation-rerun-replay" data-presentation-state={presentationState}
+      aria-busy={presentationState === "loading"}>
+      <CanonicalRecordedLabReplay
+        label={label}
+        mediaMode={hasCameraPane ? mediaMode ?? "camera" : "none"}
+        mediaModes={[{ value: "camera", label: "КАМЕРА" }]}
+        spatialMode={hasSpatialPane ? spatialMode ?? "3d" : "none"}
+        spatialModes={[{ value: "3d", label: "3D" }, { value: "plan", label: "ПЛАН" }]}
+        expanded={expanded}
+        splitPrimarySize={splitPrimarySize}
+        splitOrientation={splitView ? "vertical" : splitOrientation}
+        mediaAriaLabel="Камера и рассчитанные слои"
+        spatialAriaLabel={spatialMode === "plan" ? "Вид сверху" : "Трёхмерная сцена"}
+        mediaLayerControls={mediaLayerControls}
+        spatialLayerControls={spatialLayerControls}
+        spatialTrailingControl={followTargetControl}
+        mediaModeControlsVisible={false}
+        paneToolbarsAlwaysVisible
+        mediaMultiLayer
+        actions={resetSpatialView}
+        unifiedContent={profile ? (
+          <div className="canonical-vegetation-rerun-replay__viewport-lock"
+            data-split-view={splitView ? "true" : undefined}>
+            <RerunViewport profile={profile} sceneSettings={sceneSettings}
+              onStatusChange={setViewerStatus} onPlaybackChange={setPlayback}
+              onPlaybackControllerChange={setPlaybackController} />
+          </div>
+        ) : launchError ? (
+          <div className="l3-visual-audit__state" role="alert">{launchError}</div>
+        ) : <div aria-hidden="true" />}
+        emptyMessage="Слои результата недоступны."
+        deckOverlays={presentationState === "loading" ? (
+          <div className="canonical-vegetation-rerun-replay__loading">
+            <ActivityIndicator label="Загружаем синхронизированную запись" />
+          </div>
+        ) : undefined}
+        transport={transport}
+        onMediaModeChange={onMediaModeChange}
+        onSpatialModeChange={onSpatialModeChange}
+        onExpandedChange={onExpandedChange}
+        onSplitPrimarySizeChange={onSplitPrimarySizeChange}
+      />
+      <Window open={settingsOpen} title="Отображение" subtitle="Параметры облака SLAM"
+        placement="end" size="sm" onClose={closeSlamSettings}>
+        <Inspector defaultOpen={["points"]} sections={[
+          {
+            id: "points",
+            label: "Облако точек",
+            description: "Размер и способ окрашивания",
+            content: <>
+              <RangeControl label="Размер точки" min={0.1} max={10} step={0.1}
+                exactValueBounds={{ min: 0.1 }}
+                value={sceneDraft.pointSize} formatValue={(value) => `${value.toFixed(1)} пкс`}
+                onChange={(pointSize) => patchSceneDraft({ pointSize })} />
+              <InspectorSelectField label="Атрибут цвета" value={sceneDraft.colorMode}
+                options={[...COLOR_OPTIONS]}
+                onChange={(colorMode) => patchSceneDraft({ colorMode })} />
+              <InspectorSelectField label="Палитра" value={sceneDraft.palette}
+                options={[...PALETTE_OPTIONS]}
+                onChange={(palette) => patchSceneDraft({ palette })} />
+            </>,
+          },
+          {
+            id: "history",
+            label: "Накопление и время",
+            description: "История облака и траектория",
+            content: <RangeControl label="Накопление" min={0} max={500} step={1}
+              exactValueBounds={{ min: 0 }}
+              value={sceneDraft.accumulationSeconds} formatValue={(value) => `${value} с`}
+              onChange={(accumulationSeconds) => patchSceneDraft({ accumulationSeconds })} />,
+          },
+          {
+            id: "environment",
+            label: "Окружение сцены",
+            description: "Сетка, подписи и камеры",
+            content: <>
+              <ControlRow label="Сетка"><Checker checked={sceneDraft.showGrid} label="Показывать"
+                onChange={(showGrid) => patchSceneDraft({ showGrid })} /></ControlRow>
+              <ControlRow label="Подписи"><Checker checked={sceneDraft.showLabels} label="Показывать"
+                onChange={(showLabels) => patchSceneDraft({ showLabels })} /></ControlRow>
+              <ControlRow label="Камеры"><Checker checked={sceneDraft.showCameraFrustums} label="Показывать"
+                onChange={(showCameraFrustums) => patchSceneDraft({ showCameraFrustums })} /></ControlRow>
+            </>,
+          },
+        ]} />
+      </Window>
+      <ToastStack items={toasts}
+        onDismiss={(id) => setToasts((current) => current.filter((item) => item.id !== id))} />
+    </div>
+  );
+}
@@ -0,0 +1,12 @@
+import { CanonicalResultRerunReplay } from "./CanonicalResultRerunReplay";
+import { resolveCanonicalLabReplay } from "../../core/laboratory/canonicalLabReplay";
+import type { VegetationFullRouteReview } from "../../core/laboratory/vegetationShadow";
+
+export function CanonicalVegetationRerunReplay({ resultId, review }: {
+  resultId: string;
+  review: VegetationFullRouteReview;
+}) {
+  return <CanonicalResultRerunReplay resultId={resultId} sessionId={review.sessionId}
+    initialPlaybackStartSeconds={review.timelineStartSeconds} semantics
+    resolveReplay={resolveCanonicalLabReplay} label="RAVNOVES004TREE · канонический повтор Rerun" />;
+}
@@ -0,0 +1,51 @@
+import { GlassSurface } from "@nodedc/ui-react";
+import { CanonicalResultRerunReplay } from "./CanonicalResultRerunReplay";
+import { resolveCanonicalLabReplay } from "../../core/laboratory/canonicalLabReplay";
+import type { ObservatoryPortableResultReview } from "../../core/observatory/recordedRun";
+import type { ObservationSessionReplayLaunch } from "../../core/observation/sessionArchive";
+
+function resolvePortableTgsReplay(resultId: string, launch: ObservationSessionReplayLaunch,
+  options: { signal: AbortSignal }) {
+  return resolveCanonicalLabReplay(resultId, launch, { ...options, sourceKind: "portable-tgs" });
+}
+
+function resolvePortableSemanticReplay(resultId: string, launch: ObservationSessionReplayLaunch,
+  options: { signal: AbortSignal }) {
+  return resolveCanonicalLabReplay(resultId, launch, { ...options, sourceKind: "portable-semantic" });
+}
+
+function resolvePortableObjectReplay(resultId: string, launch: ObservationSessionReplayLaunch,
+  options: { signal: AbortSignal }) {
+  return resolveCanonicalLabReplay(resultId, launch, { ...options, sourceKind: "portable-objects" });
+}
+
+export function PortableResultReplay({
+  review,
+  label,
+}: {
+  review: ObservatoryPortableResultReview;
+  label?: string;
+}) {
+  const schema = review.resultDocument.schema_version;
+  const tgs = schema === "missioncore.recorded-tgs-costmap-review/v2";
+  const module = review.resultDocument.module;
+  const moduleId = module && typeof module === "object" && "module_id" in module
+    ? module.module_id : undefined;
+  const semantics = schema === "missioncore.recorded-eomt-ddrnet-review/v2"
+    || (schema === "missioncore.recorded-ai-layer-review/v1"
+      && (moduleId === "ddrnet" || moduleId === "eomt"));
+  const objects = schema === "missioncore.recorded-ai-layer-review/v1"
+    && (moduleId === "rf-detr" || moduleId === "object-distance");
+  if (!tgs && !semantics && !objects) return (
+    <GlassSurface className="observatory-replay-state" padding="lg">
+      <p role="alert">Сохранённый результат этого профиля пока не поддерживает визуальный разбор.</p>
+    </GlassSurface>
+  );
+  return <CanonicalResultRerunReplay key={review.resultId} resultId={review.resultId}
+      sessionId={review.sourceSessionId} portable costmap={tgs} semantics={semantics}
+      detections={objects}
+      moduleIds={typeof moduleId === "string" ? [moduleId] : []}
+      label={label}
+      resolveReplay={tgs ? resolvePortableTgsReplay
+        : objects ? resolvePortableObjectReplay : resolvePortableSemanticReplay} />;
+}
@@ -0,0 +1,261 @@
+import { useEffect, useMemo, useState } from "react";
+import {
+  ActivityIndicator,
+  Button,
+  FieldFrame,
+  Select,
+  StatusBadge,
+  Window,
+  WindowFooterActions,
+} from "@nodedc/ui-react";
+
+import {
+  aiModuleIdForSetup,
+  fetchAIModuleCatalog,
+  fetchAICompositionRuns,
+  fetchAICompositionJobs,
+  saveAIComposition,
+  type AICompositionReceipt,
+  type AICompositionRun,
+  type AIGroupId,
+  type AIModuleCatalog,
+} from "../../core/observatory/aiComposition";
+import type { ObservatoryRecordedJob } from "../../core/observatory/recordedJobs";
+
+const groups: readonly { id: AIGroupId; label: string; description: string }[] = [
+  { id: "segmentation", label: "Сегментация", description: "Пиксельные маски сцены" },
+  { id: "detection", label: "Объекты", description: "Рамки и классы объектов" },
+  { id: "geometry", label: "Облако точек / TGS", description: "Опорная поверхность и карта проходимости" },
+  { id: "range", label: "Дистанция", description: "Расстояния до объектов" },
+  { id: "motion", label: "Движение", description: "Треки и динамика объектов" },
+  { id: "policy", label: "Политика", description: "Теневые правила интерпретации" },
+];
+
+export function AIConfigurationWindow({
+  open, sourceSessionId, sourceLabel, onClose, onCalculated,
+}: {
+  readonly open: boolean;
+  readonly sourceSessionId: string;
+  readonly sourceLabel: string;
+  readonly onClose: () => void;
+  readonly onCalculated: (receipt: AICompositionReceipt) => void;
+}) {
+  const [catalog, setCatalog] = useState<AIModuleCatalog | null>(null);
+  const [existingJobs, setExistingJobs] = useState<readonly ObservatoryRecordedJob[]>([]);
+  const [existingRuns, setExistingRuns] = useState<readonly AICompositionRun[]>([]);
+  const [selected, setSelected] = useState<Partial<Record<AIGroupId, string>>>({});
+  const [state, setState] = useState<"idle" | "loading" | "ready" | "saving" | "error">("idle");
+  const [message, setMessage] = useState<string | null>(null);
+
+  useEffect(() => {
+    if (!open) return;
+    const request = new AbortController();
+    setState("loading");
+    setMessage(null);
+    void Promise.all([
+      fetchAIModuleCatalog(request.signal),
+      fetchAICompositionJobs(sourceSessionId, request.signal),
+      fetchAICompositionRuns(sourceSessionId, request.signal),
+    ]).then(([value, jobs, runs]) => {
+      if (request.signal.aborted) return;
+      setCatalog(value);
+      setExistingJobs(jobs);
+      setExistingRuns(runs);
+      setSelected({});
+      setState("ready");
+    }).catch((error: unknown) => {
+      if (request.signal.aborted) return;
+      setMessage(error instanceof Error ? error.message : "Каталог AI-модулей недоступен.");
+      setState("error");
+    });
+    return () => request.abort();
+  }, [open, sourceSessionId]);
+
+  const existingByModule = useMemo(() => {
+    const result = new Map<string, ObservatoryRecordedJob>();
+    for (const job of existingJobs) {
+      if (job.state === "failed" || job.publication.state === "failed") continue;
+      const moduleId = aiModuleIdForSetup(job.setupId);
+      if (moduleId && !result.has(moduleId)) result.set(moduleId, job);
+    }
+    return result;
+  }, [existingJobs]);
+
+  const selections = useMemo(() => groups.flatMap(({ id }) => {
+    const moduleId = selected[id];
+    const module = catalog?.groups.find((item) => item.group === id)?.modules.find(
+      (item) => item.moduleId === moduleId,
+    );
+    return module ? [{ group: id, module }] : [];
+  }), [catalog, selected]);
+
+  const selectedModuleIds = useMemo(
+    () => selections.map(({ module }) => module.moduleId).sort(),
+    [selections],
+  );
+  const matchingRun = useMemo(() => existingRuns.find((run) => (
+    run.state !== "failed"
+    && [...run.moduleIds].sort().join("\0") === selectedModuleIds.join("\0")
+  )), [existingRuns, selectedModuleIds]);
+  const configurationAlreadyExists = selections.length > 0 && matchingRun !== undefined;
+  const configurationIsRunning = matchingRun?.state === "running";
+
+  function selectModule(group: AIGroupId, moduleId: string): void {
+    if (!catalog) return;
+    setSelected((current) => {
+      const next = { ...current, [group]: moduleId === "none" ? undefined : moduleId };
+      const modules = catalog.groups.flatMap((item) => item.modules);
+      const selectedIds = new Set(Object.values(next).filter((value): value is string => Boolean(value)));
+      if (moduleId !== "none") {
+        const module = modules.find((item) => item.moduleId === moduleId);
+        for (const requirement of module?.requires ?? []) {
+          if (requirement.startsWith("source.")) continue;
+          if (modules.some((item) => selectedIds.has(item.moduleId) && item.provides.includes(requirement))) {
+            continue;
+          }
+          const providers = modules.filter((item) => item.provides.includes(requirement));
+          if (providers.length === 1) {
+            const providerGroup = catalog.groups.find((item) => item.modules.some(
+              (candidate) => candidate.moduleId === providers[0]?.moduleId,
+            ))?.group;
+            if (providerGroup) {
+              next[providerGroup] = providers[0]?.moduleId;
+              selectedIds.add(providers[0]?.moduleId ?? "");
+            }
+          }
+        }
+      } else {
+        let changed = true;
+        while (changed) {
+          changed = false;
+          const capabilities = new Set(modules.filter((item) => Object.values(next).includes(item.moduleId))
+            .flatMap((item) => item.provides));
+          for (const item of modules.filter((candidate) => Object.values(next).includes(candidate.moduleId))) {
+            if (item.requires.some((requirement) => !requirement.startsWith("source.") && !capabilities.has(requirement))) {
+              const dependentGroup = catalog.groups.find((candidate) => candidate.modules.some(
+                (module) => module.moduleId === item.moduleId,
+              ))?.group;
+              if (dependentGroup) {
+                next[dependentGroup] = undefined;
+                changed = true;
+              }
+            }
+          }
+        }
+      }
+      return next;
+    });
+    setMessage(null);
+    if (state === "error") setState("ready");
+  }
+
+  async function calculate(): Promise<void> {
+    if (selections.length === 0 || state === "saving") return;
+    if (configurationAlreadyExists) {
+      setMessage("Эта конфигурация уже рассчитана. Выберите другую конфигурацию.");
+      return;
+    }
+    setState("saving");
+    setMessage(null);
+    try {
+      const receipt = await saveAIComposition(sourceSessionId, selections);
+      onCalculated(receipt);
+      onClose();
+    } catch (error) {
+      setMessage(error instanceof Error ? error.message : "Не удалось запустить расчёт.");
+      setState("error");
+    }
+  }
+
+  return <Window
+    open={open}
+    className="observatory-ai-config-window"
+    title="Сконфигурировать AI-слой"
+    subtitle={sourceLabel}
+    size="lg"
+    closeOnBackdrop={state !== "saving"}
+    closeOnEscape={state !== "saving"}
+    onClose={onClose}
+    footer={<WindowFooterActions>
+      {configurationAlreadyExists ? (
+        <span className="observatory-ai-config__duplicate" role="status">
+          {configurationIsRunning
+            ? "Текущая конфигурация уже рассчитывается."
+            : "Текущая конфигурация уже рассчитана."}
+        </span>
+      ) : null}
+      <Button
+        variant="primary"
+        className={state === "saving" ? "observatory-ai-config__calculate--saving" : undefined}
+        disabled={state !== "ready" || selections.length === 0 || configurationAlreadyExists}
+        aria-busy={state === "saving"}
+        onClick={() => void calculate()}
+      >
+        {state === "saving" ? "Отправляем на Worker…" : "Рассчитать"}
+      </Button>
+    </WindowFooterActions>}
+  >
+    <div className="observatory-ai-config" aria-busy={state === "loading" || state === "saving"}>
+      <p className="observatory-ai-config__lead">
+        Выберите модуль в каждом нужном слое. Зависимые блоки подключаются явно в этой конфигурации.
+      </p>
+      {state === "loading" ? <ActivityIndicator label="Загружаем AI-модули" /> : null}
+      {catalog ? groups.map(({ id, label, description }) => {
+        const modules = catalog.groups.find((item) => item.group === id)?.modules ?? [];
+        const selectedModule = modules.find((item) => item.moduleId === selected[id]);
+        const selectedExisting = selectedModule
+          ? existingByModule.get(selectedModule.moduleId)
+          : undefined;
+        const allCalculated = modules.length > 0 && modules.every(
+          (module) => existingByModule.has(module.moduleId),
+        );
+        return <section className="observatory-ai-module-group" key={id}>
+          <header>
+            <div>
+              <strong>{label}</strong>
+              <span>{description}</span>
+            </div>
+            <StatusBadge tone={selectedModule ? "accent" : "neutral"}>
+              {selectedExisting
+                ? selectedExisting.state === "succeeded" ? "Уже рассчитано" : "В расчёте"
+                : selectedModule?.label ?? (allCalculated
+                ? "Результат доступен"
+                : modules.length ? "Не используется" : "Не установлен")}
+            </StatusBadge>
+          </header>
+          <div className="observatory-ai-module-group__body">
+            <FieldFrame
+              label={`Модуль: ${label}`}
+              description={modules.length
+                ? allCalculated
+                  ? "Готовый результат можно включить в новую конфигурацию без повторного расчёта."
+                  : id === "segmentation"
+                  ? "DDRNet и EoMT — независимые альтернативы; выберите одну модель."
+                  : id === "range"
+                    ? "Дистанция использует рамки детектора и синхронное облако точек."
+                    : id === "geometry"
+                      ? "TGS обрабатывает LiDAR независимо от сегментации и детектора."
+                      : "Связи с другими блоками определяются входами выбранного модуля."
+                : "Для этого слоя на Worker 006 пока нет установленного модуля."}
+            >
+              <Select
+                label={`Выбрать модуль: ${label}`}
+                value={selected[id] ?? "none"}
+                options={[{ value: "none", label: "Не использовать" }, ...modules.map((module) => ({
+                  value: module.moduleId,
+                  label: module.label,
+                  description: existingByModule.has(module.moduleId)
+                    ? "Готовый результат будет использован без повторного расчёта"
+                    : module.dockerName,
+                }))]}
+                disabled={modules.length === 0 || state === "saving"}
+                onChange={(value) => selectModule(id, value)}
+              />
+            </FieldFrame>
+          </div>
+        </section>;
+      }) : null}
+      {message ? <p className="observatory-ai-config__error" role="alert">{message}</p> : null}
+    </div>
+  </Window>;
+}
@@ -0,0 +1,10 @@
+import { WebViewer } from "@rerun-io/web-viewer";
+
+import type { RerunFrameWindow } from "./recordedRerunProtocol";
+import { createRecordedRerunOwner } from "./recordedRerunOwner";
+
+// This entry is loaded only in the owned iframe. Upstream code is unmodified;
+// destroying the frame also ends its timers, WASM, video and WebGPU lifetime.
+const mount = document.getElementById("viewer");
+if (!mount) throw new Error("Recorded viewer mount is missing");
+(window as RerunFrameWindow).missionCoreRerun = createRecordedRerunOwner(() => new WebViewer(), mount);
@@ -0,0 +1,77 @@
+import { createRecordedRerunFacade, type RecordedRerunViewer } from "./recordedRerunFacade";
+import type { RerunFrameWindow } from "./recordedRerunProtocol";
+import { relayIsolatedRerunInput } from "./isolatedRerunInput";
+
+/** Own the complete recorded-viewer realm, not just its canvas or SDK handle. */
+export function createIsolatedRerunHost(host: HTMLElement) {
+  let frame: HTMLIFrameElement | null = host.ownerDocument.createElement("iframe");
+  frame.title = "Синхронизированная запись";
+  frame.className = "rerun-viewport__runtime";
+  frame.src = "/rerun-runtime.html";
+  let disposed = false;
+  let releaseFacade: (() => void) | null = null;
+  let releaseInput: (() => void) | null = null;
+  let frameWindow: RerunFrameWindow | null = null;
+  let rejectReady: ((reason: Error) => void) | null = null;
+  let timer: ReturnType<typeof setTimeout> | undefined;
+
+  const dispose = () => {
+    if (disposed) return;
+    disposed = true;
+    clearTimeout(timer);
+    frame!.onload = null;
+    frame!.onerror = null;
+    releaseInput?.();
+    releaseInput = null;
+    try {
+      releaseFacade?.();
+    } catch {
+      // Realm teardown is required even if a partial native start failed.
+    } finally {
+      releaseFacade = null;
+      frameWindow = null;
+      frame!.remove();
+      frame = null;
+      rejectReady?.(new Error("Recorded viewer was disposed"));
+      rejectReady = null;
+    }
+  };
+
+  const ready = new Promise<{ viewer: RecordedRerunViewer; mount: HTMLElement }>((resolve, reject) => {
+    rejectReady = reject;
+    frame!.onload = () => {
+      if (disposed) return;
+      try {
+        frameWindow = frame!.contentWindow as RerunFrameWindow | null;
+        const api = frameWindow?.missionCoreRerun;
+        if (!api || api.version !== 2) throw new Error("Recorded viewer host is unavailable");
+        const owner = createRecordedRerunFacade((request, bytes) => {
+          const current = frameWindow?.missionCoreRerun;
+          if (!current) throw new Error("Recorded viewer was disposed");
+          return current.invoke(request, bytes);
+        });
+        releaseFacade = owner.dispose;
+        api.connect(owner.notify);
+        releaseInput = relayIsolatedRerunInput(host, frameWindow, frame);
+        clearTimeout(timer);
+        rejectReady = null;
+        frame!.onload = null;
+        frame!.onerror = null;
+        resolve({ viewer: owner.facade, mount: host });
+      } catch (error) {
+        reject(new Error(String(error)));
+        dispose();
+      }
+    };
+    frame!.onerror = () => {
+      reject(new Error("Recorded viewer host failed to load"));
+      dispose();
+    };
+    timer = setTimeout(() => {
+      reject(new Error("Recorded viewer host timed out"));
+      dispose();
+    }, 30_000);
+  });
+  host.append(frame);
+  return { ready, dispose };
+}
@@ -0,0 +1,17 @@
+/** Relay Escape from the isolated viewer realm to the owning application. */
+export function relayIsolatedRerunInput(
+  host: HTMLElement,
+  frameWindow: Window | null,
+  _frame: HTMLIFrameElement | null,
+) {
+  const parent = host.ownerDocument.defaultView;
+  const escape = (event: KeyboardEvent) => {
+    if (event.key !== "Escape" || event.defaultPrevented || !parent) return;
+    host.dispatchEvent(new parent.KeyboardEvent("keydown", { key: "Escape", bubbles: true }));
+  };
+  frameWindow?.addEventListener("keydown", escape);
+  return () => {
+    frameWindow?.removeEventListener("keydown", escape);
+    frameWindow = null;
+  };
+}
@@ -0,0 +1,244 @@
+export type RecordedRerunCameraEye = {
+  readonly position: readonly [number, number, number];
+  readonly lookTarget: readonly [number, number, number];
+  readonly eyeUp: readonly [number, number, number];
+};
+
+type Vector3 = [number, number, number];
+type DragMode = "rotate" | "pan" | "roll";
+
+const ROTATION_RADIANS_PER_POINT = 0.004;
+const RERUN_WEB_LINE_SCROLL_POINTS = 8;
+const RERUN_ORBITAL_SCROLL_DIVISOR = 200;
+const RERUN_WEB_PINCH_SCROLL_DIVISOR = 100;
+const RERUN_MIN_ORBIT_DISTANCE = 0.02;
+const DOM_WHEEL_DELTA_LINE = 1;
+const DOM_WHEEL_DELTA_PAGE = 2;
+
+export const RECORDED_RERUN_ORBITAL_EYE: RecordedRerunCameraEye = {
+  position: [16, -16, 18],
+  lookTarget: [0, 0, 0],
+  eyeUp: [0, 0, 1],
+};
+
+export const RECORDED_RERUN_PLAN_EYE: RecordedRerunCameraEye = {
+  position: [0, 0, 30],
+  lookTarget: [0, 0, 0],
+  eyeUp: [0, 1, 0],
+};
+
+const vector = (value: readonly [number, number, number]): Vector3 => [...value];
+const add = (a: Vector3, b: Vector3): Vector3 => [a[0] + b[0], a[1] + b[1], a[2] + b[2]];
+const subtract = (a: Vector3, b: Vector3): Vector3 => [a[0] - b[0], a[1] - b[1], a[2] - b[2]];
+const scale = (value: Vector3, factor: number): Vector3 => [value[0] * factor, value[1] * factor, value[2] * factor];
+const dot = (a: Vector3, b: Vector3) => a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+const cross = (a: Vector3, b: Vector3): Vector3 => [
+  a[1] * b[2] - a[2] * b[1],
+  a[2] * b[0] - a[0] * b[2],
+  a[0] * b[1] - a[1] * b[0],
+];
+const length = (value: Vector3) => Math.hypot(...value);
+const normalize = (value: Vector3, fallback: Vector3): Vector3 => {
+  const magnitude = length(value);
+  return magnitude > Number.EPSILON ? scale(value, 1 / magnitude) : fallback;
+};
+const clamp = (value: number, minimum: number, maximum: number) => Math.max(minimum, Math.min(maximum, value));
+const rotateAroundAxis = (value: Vector3, rawAxis: Vector3, angle: number): Vector3 => {
+  const axis = normalize(rawAxis, [0, 0, 1]);
+  const cosine = Math.cos(angle);
+  const sine = Math.sin(angle);
+  return add(
+    add(scale(value, cosine), scale(cross(axis, value), sine)),
+    scale(axis, dot(axis, value) * (1 - cosine)),
+  );
+};
+
+function cloneEye(value: RecordedRerunCameraEye): {
+  position: Vector3;
+  lookTarget: Vector3;
+  eyeUp: Vector3;
+} {
+  return {
+    position: vector(value.position),
+    lookTarget: vector(value.lookTarget),
+    eyeUp: vector(value.eyeUp),
+  };
+}
+
+/**
+ * Mirrors Rerun 0.36.3's orbital eye math while the native viewer remains the
+ * renderer. Rerun writes operator navigation into its active blueprint clone;
+ * the WebViewer API cannot read that clone. Keeping the same three eye vectors
+ * here lets a later layer blueprint activate with the exact operator pose.
+ */
+export function createRecordedRerunCameraJournal(
+  canvas: HTMLCanvasElement,
+  scope: Window & typeof globalThis,
+) {
+  let eye = cloneEye(RECORDED_RERUN_ORBITAL_EYE);
+  let spatialViewportStart = 0;
+  let pointerId: number | null = null;
+  let dragMode: DragMode | null = null;
+  let previousPointer: readonly [number, number] | null = null;
+  let latestPointer: readonly [number, number] | null = null;
+  let maxOrbitalRadius = 1.0e17;
+
+  const isSpatialPoint = (event: MouseEvent) => {
+    const rect = canvas.getBoundingClientRect();
+    return rect.width > 0 && (event.clientX - rect.left) / rect.width >= spatialViewportStart;
+  };
+  const forward = () => normalize(subtract(eye.lookTarget, eye.position), [0, 1, 0]);
+  const usableUp = () => {
+    const fwd = forward();
+    const fallbackRight: Vector3 = Math.abs(dot(fwd, [0, 0, 1])) > 0.9999
+      ? [1, 0, 0]
+      : cross(fwd, [0, 0, 1]);
+    const fallback = normalize(cross(fwd, fallbackRight), [0, 0, 1]);
+    const candidate = normalize(eye.eyeUp, fallback);
+    return Math.abs(dot(candidate, fwd)) > 0.9999 ? fallback : candidate;
+  };
+  const orbitRadius = () => length(subtract(eye.position, eye.lookTarget));
+
+  const rotate = (deltaX: number, deltaY: number) => {
+    const radius = orbitRadius();
+    const up = usableUp();
+    let fwd = forward();
+    const oldPitch = Math.asin(clamp(dot(fwd, up), -1, 1));
+    fwd = normalize(
+      rotateAroundAxis(fwd, up, -ROTATION_RADIANS_PER_POINT * deltaX),
+      fwd,
+    );
+    const right = normalize(cross(fwd, up), [1, 0, 0]);
+    const maxPitch = 0.99 * Math.PI / 2;
+    const nextPitch = clamp(
+      oldPitch - ROTATION_RADIANS_PER_POINT * deltaY,
+      -maxPitch,
+      maxPitch,
+    );
+    fwd = normalize(rotateAroundAxis(fwd, right, nextPitch - oldPitch), fwd);
+    eye.position = subtract(eye.lookTarget, scale(fwd, radius));
+  };
+
+  const pan = (deltaX: number, deltaY: number) => {
+    const fwd = forward();
+    const right = normalize(cross(fwd, usableUp()), [1, 0, 0]);
+    const screenUp = normalize(cross(right, fwd), [0, 0, 1]);
+    const speed = 0.001 * orbitRadius();
+    const translation = add(scale(right, -deltaX * speed), scale(screenUp, deltaY * speed));
+    eye.position = add(eye.position, translation);
+    eye.lookTarget = add(eye.lookTarget, translation);
+  };
+
+  const roll = (event: PointerEvent, deltaX: number, deltaY: number) => {
+    const rect = canvas.getBoundingClientRect();
+    const left = rect.left + rect.width * spatialViewportStart;
+    const centerX = left + (rect.right - left) / 2;
+    const centerY = rect.top + rect.height / 2;
+    const relativeX = event.clientX - centerX;
+    const relativeY = event.clientY - centerY;
+    const divisor = relativeX * relativeX + relativeY * relativeY;
+    if (divisor <= Number.EPSILON) return;
+    const angle = (-deltaY * relativeX + deltaX * relativeY) / divisor;
+    eye.eyeUp = normalize(rotateAroundAxis(eye.eyeUp, scale(forward(), -1), angle), eye.eyeUp);
+  };
+
+  const pointerDown = (event: PointerEvent) => {
+    latestPointer = [event.clientX, event.clientY];
+    if (!isSpatialPoint(event)) return;
+    pointerId = event.pointerId;
+    previousPointer = [event.clientX, event.clientY];
+    dragMode = event.button === 2 ? "pan" : event.button === 1 || event.altKey ? "roll" : "rotate";
+  };
+  const pointerMove = (event: PointerEvent) => {
+    latestPointer = [event.clientX, event.clientY];
+    if (event.pointerId !== pointerId || !previousPointer || !dragMode) return;
+    const deltaX = event.clientX - previousPointer[0];
+    const deltaY = event.clientY - previousPointer[1];
+    previousPointer = [event.clientX, event.clientY];
+    if (dragMode === "rotate") rotate(deltaX, deltaY);
+    else if (dragMode === "pan") pan(deltaX, deltaY);
+    else roll(event, deltaX, deltaY);
+  };
+  const pointerEnd = (event: PointerEvent) => {
+    if (event.pointerId !== pointerId) return;
+    pointerMove(event);
+    pointerId = null;
+    previousPointer = null;
+    dragMode = null;
+  };
+  const wheel = (event: WheelEvent) => {
+    const rect = canvas.getBoundingClientRect();
+    const wheelX = event.clientX >= rect.left && event.clientX <= rect.right
+      ? event.clientX
+      : latestPointer?.[0];
+    if (wheelX === undefined || rect.width <= 0) return;
+    if ((wheelX - rect.left) / rect.width < spatialViewportStart) return;
+    const unitMultiplier = event.deltaMode === DOM_WHEEL_DELTA_LINE
+      ? RERUN_WEB_LINE_SCROLL_POINTS
+      : event.deltaMode === DOM_WHEEL_DELTA_PAGE
+        ? rect.height
+        : 1;
+    const scrollPoints = (event.deltaX + event.deltaY) * unitMultiplier;
+    // eframe negates the DOM delta before Rerun applies
+    // radius / exp(smooth_scroll_delta / 200). Over a smoothed gesture the
+    // exponent products collapse to the raw accumulated DOM delta below.
+    const divisor = event.ctrlKey
+      ? RERUN_WEB_PINCH_SCROLL_DIVISOR
+      : RERUN_ORBITAL_SCROLL_DIVISOR;
+    const radiusFactor = Math.exp(scrollPoints / divisor);
+    const offset = subtract(eye.position, eye.lookTarget);
+    const radius = length(offset);
+    // Keep the same orbital bounds as Rerun 0.36.3. An eye already outside
+    // the scene-derived cap is allowed to stay there and is never snapped in.
+    const nextRadius = clamp(
+      radius * radiusFactor,
+      RERUN_MIN_ORBIT_DISTANCE,
+      Math.max(radius, maxOrbitalRadius),
+    );
+    eye.position = add(
+      eye.lookTarget,
+      scale(offset, nextRadius / Math.max(radius, Number.EPSILON)),
+    );
+  };
+
+  canvas.addEventListener("pointerdown", pointerDown, true);
+  scope.addEventListener("pointermove", pointerMove, true);
+  scope.addEventListener("pointerup", pointerEnd, true);
+  scope.addEventListener("pointercancel", pointerEnd, true);
+  scope.addEventListener("wheel", wheel, { capture: true, passive: true });
+
+  return {
+    current(): RecordedRerunCameraEye {
+      return {
+        position: [...eye.position],
+        lookTarget: [...eye.lookTarget],
+        eyeUp: [...eye.eyeUp],
+      };
+    },
+    configure(nextEye: RecordedRerunCameraEye, nextSpatialViewportStart: number) {
+      eye = cloneEye(nextEye);
+      spatialViewportStart = clamp(nextSpatialViewportStart, 0, 0.9);
+      pointerId = null;
+      dragMode = null;
+      previousPointer = null;
+    },
+    setSpatialViewportStart(nextSpatialViewportStart: number) {
+      spatialViewportStart = clamp(nextSpatialViewportStart, 0, 0.9);
+    },
+    setMaxOrbitalRadius(nextMaxOrbitalRadius: number) {
+      if (
+        Number.isFinite(nextMaxOrbitalRadius) &&
+        nextMaxOrbitalRadius >= RERUN_MIN_ORBIT_DISTANCE
+      ) {
+        maxOrbitalRadius = nextMaxOrbitalRadius;
+      }
+    },
+    dispose() {
+      canvas.removeEventListener("pointerdown", pointerDown, true);
+      scope.removeEventListener("pointermove", pointerMove, true);
+      scope.removeEventListener("pointerup", pointerEnd, true);
+      scope.removeEventListener("pointercancel", pointerEnd, true);
+      scope.removeEventListener("wheel", wheel, true);
+    },
+  };
+}
@@ -0,0 +1,105 @@
+import type { WebViewer } from "@rerun-io/web-viewer";
+import type { RerunInvoke } from "./recordedRerunProtocol";
+import type { RecordedRerunCameraEye } from "./recordedRerunCameraJournal";
+
+type NativeChannel = ReturnType<WebViewer["open_channel"]>;
+type Channel = Pick<NativeChannel, "ready" | "send_rrd" | "close">;
+export type RecordedRerunViewer = Pick<WebViewer,
+  "start" | "stop" | "ready" | "on" | "open" | "close" | "override_panel_state" |
+  "get_active_recording_id" | "get_active_timeline" | "get_current_time" |
+  "get_playing" | "get_time_range" | "set_active_timeline" |
+  "set_current_time" | "set_playing"
+> & {
+  open_channel: (name?: string) => Channel;
+  configure_camera_journal: (eye: RecordedRerunCameraEye, spatialViewportStart: number) => void;
+  get_camera_eye: () => RecordedRerunCameraEye;
+  set_camera_viewport_start: (spatialViewportStart: number) => void;
+  set_camera_max_orbital_radius: (maxOrbitalRadius: number) => void;
+};
+
+/** Parent-owned values only. No SDK Promise or foreign prototype escapes. */
+export function createRecordedRerunFacade(invoke: RerunInvoke | null) {
+  let nextId = 0;
+  const callbacks = new Map<number, (...args: unknown[]) => void>();
+  const starts = new Map<number, { resolve: () => void; reject: (error: Error) => void }>();
+  const command = (method: string, args: unknown[] = [], id?: number, bytes?: Uint8Array) => {
+    if (!invoke) throw new Error("Recorded viewer was disposed");
+    const response = JSON.parse(invoke(JSON.stringify({ method, args, id }), bytes));
+    if (response.error) throw new Error(response.error);
+    return response.result;
+  };
+  const dispose = () => {
+    callbacks.clear();
+    for (const pending of starts.values()) pending.reject(new Error("Recorded viewer was disposed"));
+    starts.clear();
+    try { if (invoke) command("stop"); } finally { invoke = null; }
+  };
+  const notify = (message: string) => {
+    if (!invoke) return;
+    const event = JSON.parse(message);
+    if (event.type === "event") callbacks.get(event.id)?.(...event.values);
+    else {
+      const pending = starts.get(event.id);
+      starts.delete(event.id);
+      if (event.type === "started") pending?.resolve();
+      else pending?.reject(new Error(event.message));
+    }
+  };
+  const facade: RecordedRerunViewer = {
+    get ready() { return invoke ? command("ready") : false; },
+    start(source, _parent, options) {
+      return new Promise<void>((resolve, reject) => {
+        const id = ++nextId;
+        starts.set(id, { resolve, reject });
+        try { command("start", [source, options], id); }
+        catch (error) { starts.delete(id); reject(error); }
+      });
+    },
+    stop: dispose,
+    on: ((event: string, callback: (...args: unknown[]) => void) => {
+      const id = ++nextId;
+      callbacks.set(id, callback);
+      try { command("on", [event], id); }
+      catch (error) { callbacks.delete(id); throw error; }
+      return () => {
+        if (callbacks.delete(id) && invoke) command("off", [], id);
+      };
+    }) as WebViewer["on"],
+    open_channel(name) {
+      const id = ++nextId;
+      command("channel-open", name === undefined ? [] : [name], id);
+      let closed = false;
+      return {
+        get ready() { return !closed && invoke ? command("channel-ready", [], id) : false; },
+        send_rrd(bytes) { if (!closed && invoke) command("channel-send", [], id, bytes); },
+        close() {
+          if (closed) return;
+          closed = true;
+          if (invoke) command("channel-close", [], id);
+        },
+      };
+    },
+    open: (...args) => command("open", args),
+    close: (...args) => { if (invoke) command("close", args); },
+    override_panel_state: (...args) => command("override_panel_state", args),
+    get_active_recording_id: () => command("get_active_recording_id"),
+    get_active_timeline: (...args) => command("get_active_timeline", args),
+    get_current_time: (...args) => command("get_current_time", args),
+    get_playing: (...args) => command("get_playing", args),
+    get_time_range: (...args) => command("get_time_range", args),
+    set_active_timeline: (...args) => command("set_active_timeline", args),
+    set_current_time: (...args) => command("set_current_time", args),
+    set_playing: (...args) => command("set_playing", args),
+    configure_camera_journal: (eye, spatialViewportStart) => command(
+      "configure-camera-journal", [eye, spatialViewportStart],
+    ),
+    get_camera_eye: () => command("get-camera-eye"),
+    set_camera_viewport_start: (spatialViewportStart) => command(
+      "set-camera-viewport-start", [spatialViewportStart],
+    ),
+    set_camera_max_orbital_radius: (maxOrbitalRadius) => command(
+      "set-camera-max-orbital-radius", [maxOrbitalRadius],
+    ),
+  };
+  return { facade, dispose, notify };
+}
@@ -0,0 +1,115 @@
+import type { WebViewer } from "@rerun-io/web-viewer";
+import type { RerunFrameApi, RerunNotify } from "./recordedRerunProtocol";
+import { createRecordedRerunCameraJournal } from "./recordedRerunCameraJournal";
+
+/** Lives entirely inside the disposable iframe, including pending SDK starts. */
+export function createRecordedRerunOwner(create: () => WebViewer, mount: HTMLElement): RerunFrameApi {
+  let native: WebViewer | null = null;
+  let notify: RerunNotify | null = null;
+  const subscriptions = new Map<number, () => void>();
+  const channels = new Map<number, ReturnType<WebViewer["open_channel"]>>();
+  let cameraJournal: ReturnType<typeof createRecordedRerunCameraJournal> | null = null;
+  const send = (message: object) => notify?.(JSON.stringify(message));
+  const stop = () => {
+    notify = null;
+    for (const unsubscribe of subscriptions.values()) {
+      try { unsubscribe(); } catch { /* Continue partial-start cleanup. */ }
+    }
+    subscriptions.clear();
+    for (const channel of channels.values()) {
+      try { channel.close(); } catch { /* Other channels must still close. */ }
+    }
+    channels.clear();
+    cameraJournal?.dispose();
+    cameraJournal = null;
+    const current = native;
+    native = null;
+    try { current?.stop(); } catch { /* Realm teardown remains authoritative. */ }
+  };
+  const required = () => {
+    if (!native) throw new Error("Recorded viewer was disposed");
+    return native;
+  };
+  const start = async (id: number, args: [string | string[] | null, Parameters<WebViewer["start"]>[2]]) => {
+    const starting = required();
+    try {
+      await starting.start(args[0], mount, args[1]);
+      if (native === starting && starting.canvas) {
+        cameraJournal?.dispose();
+        cameraJournal = createRecordedRerunCameraJournal(
+          starting.canvas,
+          window as Window & typeof globalThis,
+        );
+      }
+      if (native === starting) send({ type: "started", id });
+    } catch (error) {
+      if (native === starting) send({ type: "start-failed", id, message: String(error) });
+    } finally {
+      if (native !== starting) {
+        try { starting.stop(); } catch { /* Late completion after disposal. */ }
+      }
+    }
+  };
+  return {
+    version: 2,
+    connect(callback) {
+      if (native) throw new Error("Recorded viewer already has an owner");
+      native = create();
+      notify = callback;
+    },
+    invoke(request, bytes) {
+      try {
+        const { method, args = [], id } = JSON.parse(request);
+        let result: unknown;
+        switch (method) {
+          case "stop": stop(); break;
+          case "start": required(); void start(id, args); break;
+          case "ready": result = native?.ready ?? false; break;
+          case "on": {
+            const subscribe = required().on as (event: string, callback: (...values: unknown[]) => void) => () => void;
+            subscriptions.set(id, subscribe.call(required(), args[0], (...values) => send({ type: "event", id, values })));
+            break;
+          }
+          case "off":
+            try { subscriptions.get(id)?.(); } finally { subscriptions.delete(id); }
+            break;
+          case "channel-open": {
+            const name = args[0] as string | undefined;
+            channels.set(id, required().open_channel(name));
+            break;
+          }
+          case "channel-ready": result = channels.get(id)?.ready ?? false; break;
+          case "channel-send": if (bytes) {
+            channels.get(id)?.send_rrd(bytes);
+          } break;
+          case "channel-close":
+            try { channels.get(id)?.close(); } finally {
+              channels.delete(id);
+            }
+            break;
+          case "configure-camera-journal": cameraJournal?.configure(args[0], args[1]); break;
+          case "get-camera-eye": result = cameraJournal?.current(); break;
+          case "set-camera-viewport-start": cameraJournal?.setSpatialViewportStart(args[0]); break;
+          case "set-camera-max-orbital-radius": cameraJournal?.setMaxOrbitalRadius(args[0]); break;
+          case "open": required().open(args[0]); break;
+          case "close": required().close(args[0]); break;
+          case "override_panel_state": required().override_panel_state(args[0], args[1]); break;
+          case "get_active_recording_id": result = required().get_active_recording_id(); break;
+          case "get_active_timeline": result = required().get_active_timeline(args[0]); break;
+          case "get_current_time": result = required().get_current_time(args[0], args[1]); break;
+          case "get_playing": result = required().get_playing(args[0]); break;
+          case "get_time_range": result = required().get_time_range(args[0], args[1]); break;
+          case "set_active_timeline": required().set_active_timeline(args[0], args[1]); break;
+          case "set_current_time": required().set_current_time(args[0], args[1], args[2]); break;
+          case "set_playing": required().set_playing(args[0], args[1]); break;
+          default: throw new Error("Unsupported recorded viewer command");
+        }
+        return JSON.stringify({ result });
+      } catch (error) {
+        // A native Error also has a foreign prototype. Return text, never throw
+        // that object into a parent Promise/callback retained after disposal.
+        return JSON.stringify({ error: String(error) });
+      }
+    },
+  };
+}
@@ -0,0 +1,12 @@
+/** Only parent-owned inputs and primitive strings cross the recorded realm.
+ * An SDK instance, Promise, DOM node or native callback never becomes a value
+ * retained by React. This is not a second playback clock.
+ */
+export type RerunInvoke = (request: string, bytes?: Uint8Array) => string;
+export type RerunNotify = (message: string) => void;
+export interface RerunFrameApi {
+  version: 2;
+  connect: (notify: RerunNotify) => void;
+  invoke: RerunInvoke;
+}
+export type RerunFrameWindow = Window & { missionCoreRerun?: RerunFrameApi };
@@ -0,0 +1,134 @@
+import type { ObservationSessionReplayLaunch } from "../observation/sessionArchive";
+import type { RecordedRrdArtifactDescriptor } from "../observation/viewerProfile";
+
+const SAFE_RESULT_ID = /^lab-v1-vegetation-shadow-[a-f0-9]{64}$/;
+const SAFE_SESSION_SOURCE = /^\/api\/v1\/observation-sessions\/[A-Za-z0-9][A-Za-z0-9._:-]{0,127}\/recording\.rrd$/;
+const MAX_CANONICAL_REPLAY_BYTES = 1024 * 1024 * 1024;
+
+export interface CanonicalLabReplayDescriptor extends RecordedRrdArtifactDescriptor {
+  blueprintSourceUrl: string;
+}
+
+/**
+ * Resolve the one immutable RRD used by the canonical recorded LAB.
+ *
+ * The server caches the merge of the sealed spatial recording and the LAB AI
+ * evidence. Rerun therefore opens one source and cannot present the base store
+ * before a second receiver has finished decoding the semantic layer.
+ */
+export async function resolveCanonicalLabReplay(
+  resultId: string,
+  launch: ObservationSessionReplayLaunch,
+  {
+    origin = window.location.origin,
+    signal,
+    fetcher = globalThis.fetch,
+    sourceKind = "legacy-vegetation",
+  }: {
+    origin?: string;
+    signal?: AbortSignal;
+    fetcher?: typeof globalThis.fetch;
+    sourceKind?: "legacy-vegetation" | "portable-tgs" | "portable-semantic" | "portable-objects";
+  } = {},
+): Promise<CanonicalLabReplayDescriptor> {
+  const base = new URL(origin);
+  if (
+    !(sourceKind === "portable-tgs"
+      ? /^m49-tgs-portable-review-[a-f0-9]{64}$/.test(resultId)
+      : sourceKind === "portable-semantic"
+        ? /^(?:lab-v1-eomt-ddrnet|ai-layer-(?:ddrnet|eomt))-[a-f0-9]{64}$/.test(resultId)
+        : sourceKind === "portable-objects"
+          ? /^ai-layer-(?:rf-detr|object-distance)-[a-f0-9]{64}$/.test(resultId)
+        : SAFE_RESULT_ID.test(resultId))
+    || !SAFE_SESSION_SOURCE.test(launch.sourceUrl)
+    || launch.viewerSourceUrl !== `${launch.sourceUrl}?generation=${launch.sha256}`
+    || !/^[a-f0-9]{64}$/.test(launch.sha256)
+  ) {
+    throw new Error("Канонический replay LAB имеет небезопасный descriptor.");
+  }
+  const sourceUrl = sourceKind !== "legacy-vegetation"
+    ? `/api/v1/observatory/portable-results/${resultId}/replays/${launch.sha256}/recording.rrd`
+    : `/api/v1/laboratory/vegetation-shadow/${encodeURIComponent(resultId)}/canonical-replay.rrd`;
+  const descriptorUrl = new URL(sourceUrl, `${base.origin}/`);
+  if (sourceKind === "legacy-vegetation") descriptorUrl.searchParams.set("base_generation", launch.sha256);
+  if (descriptorUrl.origin !== base.origin) {
+    throw new Error("Канонический replay LAB должен быть same-origin.");
+  }
+  const response = await fetcher(descriptorUrl.href, {
+    method: "HEAD",
+    credentials: "same-origin",
+    headers: { Accept: "application/vnd.rerun.rrd" },
+    signal,
+  });
+  const contentType = response.headers.get("Content-Type")?.split(";", 1)[0].trim();
+  const byteLength = Number(response.headers.get("Content-Length"));
+  const sha256 = response.headers.get("ETag")?.match(/^"([a-f0-9]{64})"$/)?.[1];
+  if (
+    response.status !== 200
+    || contentType !== "application/vnd.rerun.rrd"
+    || response.headers.get("X-Rerun-Format") !== "RRF2"
+    || !sha256
+    || !Number.isSafeInteger(byteLength)
+    || byteLength < 4
+    || byteLength > MAX_CANONICAL_REPLAY_BYTES
+  ) {
+    throw new Error("Единый replay LAB не прошёл проверку.");
+  }
+  return {
+    sourceUrl,
+    viewerSourceUrl: `${sourceUrl}?generation=${sha256}`,
+    byteLength,
+    sha256,
+    blueprintSourceUrl: launch.sourceUrl.replace(/\/recording\.rrd$/, "/blueprint.rrd"),
+  };
+}
+
+export async function resolveAICompositionReplay(
+  runId: string,
+  launch: ObservationSessionReplayLaunch,
+  {
+    origin = window.location.origin,
+    signal,
+    fetcher = globalThis.fetch,
+  }: {
+    origin?: string;
+    signal?: AbortSignal;
+    fetcher?: typeof globalThis.fetch;
+  } = {},
+): Promise<CanonicalLabReplayDescriptor> {
+  const base = new URL(origin);
+  if (
+    !/^ai-composition-[a-f0-9]{64}$/.test(runId)
+    || !SAFE_SESSION_SOURCE.test(launch.sourceUrl)
+    || launch.viewerSourceUrl !== `${launch.sourceUrl}?generation=${launch.sha256}`
+    || !/^[a-f0-9]{64}$/.test(launch.sha256)
+  ) {
+    throw new Error("Составной replay LAB имеет небезопасный descriptor.");
+  }
+  const sourceUrl = `/api/v1/observatory/ai-composition-runs/${runId}/replays/${launch.sha256}/recording.rrd`;
+  const descriptorUrl = new URL(sourceUrl, `${base.origin}/`);
+  const response = await fetcher(descriptorUrl.href, {
+    method: "HEAD",
+    credentials: "same-origin",
+    headers: { Accept: "application/vnd.rerun.rrd" },
+    signal,
+  });
+  const contentType = response.headers.get("Content-Type")?.split(";", 1)[0].trim();
+  const byteLength = Number(response.headers.get("Content-Length"));
+  const sha256 = response.headers.get("ETag")?.match(/^"([a-f0-9]{64})"$/)?.[1];
+  if (
+    response.status !== 200 || contentType !== "application/vnd.rerun.rrd"
+    || response.headers.get("X-Rerun-Format") !== "RRF2" || !sha256
+    || !Number.isSafeInteger(byteLength) || byteLength < 4
+    || byteLength > MAX_CANONICAL_REPLAY_BYTES
+  ) {
+    throw new Error("Составной replay LAB не прошёл проверку.");
+  }
+  return {
+    sourceUrl,
+    viewerSourceUrl: `${sourceUrl}?generation=${sha256}`,
+    byteLength,
+    sha256,
+    blueprintSourceUrl: launch.sourceUrl.replace(/\/recording\.rrd$/, "/blueprint.rrd"),
+  };
+}
@@ -37,7 +37,7 @@ export function laboratoryRecordedEvidenceDemand(
  profile: LaboratoryRecordedEvidenceViewerProfile =
    LABORATORY_RECORDED_EVIDENCE_VIEWER_PROFILE,
 ): LaboratoryRecordedEvidenceDemand {
-  if (profile.loadPolicy !== "visible-evidence-only") {
+  if (profile.loadPolicy !== "explicit-legacy-comparison-only") {
    throw new Error("Unsupported LAB recorded evidence load policy");
  }
  const mediaVisible = visibility.mediaMode !== null;
@@ -1026,7 +1026,7 @@ export async function fetchVegetationRouteTgsAnchor(
  };
 }

-export async function fetchVegetationShadowResult(
+export async function fetchVegetationShadowResultMetadata(
  resultId: string,
  {
    fetcher = fetch,
@@ -1048,6 +1048,17 @@ export async function fetchVegetationShadowResult(
    resultId,
    "/api/v1/laboratory/vegetation-shadow",
  );
+  return result;
+}
+
+export async function fetchVegetationShadowResult(
+  resultId: string,
+  {
+    fetcher = fetch,
+    signal,
+  }: { fetcher?: LaboratoryFetch; signal?: AbortSignal } = {},
+): Promise<VegetationShadowResult> {
+  const result = await fetchVegetationShadowResultMetadata(resultId, { fetcher, signal });
  if (!result.routeFullReview) return result;
  const timelineResponse = await fetcher(
    `/api/v1/laboratory/vegetation-shadow/${encodeURIComponent(resultId)}/route-timeline`,
@@ -0,0 +1,140 @@
+export const OBSERVATION_LAB_CALCULATION_PROFILE_SCHEMA =
+  "missioncore.observatory-calculation-profile/v1" as const;
+
+export type ObservationLabCalculationProfileOrigin =
+  | "archived-definition"
+  | "existing-result";
+
+export interface ObservationLabCalculationProfile {
+  readonly schemaVersion: typeof OBSERVATION_LAB_CALCULATION_PROFILE_SCHEMA;
+  readonly setupId: string;
+  readonly displayName: string;
+  readonly origin: ObservationLabCalculationProfileOrigin;
+  readonly definitionId: string | null;
+  readonly definitionVersion: number | null;
+  readonly definitionSha256: string | null;
+}
+
+export class ObservationLabCalculationProfileContractError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "ObservationLabCalculationProfileContractError";
+  }
+}
+
+const PROFILE_KEYS = new Set([
+  "schema_version",
+  "setup_id",
+  "display_name",
+  "origin",
+  "definition_id",
+  "definition_version",
+  "definition_sha256",
+]);
+const IDENTIFIER = /^[a-z][a-z0-9-]{2,95}$/;
+const SHA256 = /^[a-f0-9]{64}$/;
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function requireText(value: unknown, field: string, maximum: number): string {
+  if (
+    typeof value !== "string"
+    || value.length === 0
+    || value.length > maximum
+    || value !== value.trim()
+  ) {
+    throw new ObservationLabCalculationProfileContractError(
+      `Поле calculation_profile.${field} должно быть непустой строкой.`,
+    );
+  }
+  return value;
+}
+
+function requireIdentifier(value: unknown, field: string): string {
+  const identifier = requireText(value, field, 96);
+  if (!IDENTIFIER.test(identifier)) {
+    throw new ObservationLabCalculationProfileContractError(
+      `Поле calculation_profile.${field} содержит некорректный идентификатор.`,
+    );
+  }
+  return identifier;
+}
+
+export function decodeObservationLabCalculationProfile(
+  value: unknown,
+  sessionId: string,
+): ObservationLabCalculationProfile | null {
+  if (value === null) return null;
+  if (!isRecord(value) || Object.keys(value).some((key) => !PROFILE_KEYS.has(key))) {
+    throw new ObservationLabCalculationProfileContractError(
+      `Профиль расчёта LAB-сессии ${sessionId} нарушил контракт полей.`,
+    );
+  }
+  if (
+    Object.keys(value).length !== PROFILE_KEYS.size
+    || value.schema_version !== OBSERVATION_LAB_CALCULATION_PROFILE_SCHEMA
+  ) {
+    throw new ObservationLabCalculationProfileContractError(
+      `Профиль расчёта LAB-сессии ${sessionId} имеет неизвестную версию.`,
+    );
+  }
+
+  const origin = value.origin;
+  if (origin !== "archived-definition" && origin !== "existing-result") {
+    throw new ObservationLabCalculationProfileContractError(
+      `Профиль расчёта LAB-сессии ${sessionId} имеет неизвестное происхождение.`,
+    );
+  }
+  const definitionId = value.definition_id === null
+    ? null
+    : requireIdentifier(value.definition_id, "definition_id");
+  const definitionVersion = value.definition_version === null
+    ? null
+    : value.definition_version;
+  if (
+    definitionVersion !== null
+    && (
+      typeof definitionVersion !== "number"
+      || !Number.isInteger(definitionVersion)
+      || definitionVersion < 1
+    )
+  ) {
+    throw new ObservationLabCalculationProfileContractError(
+      `Профиль расчёта LAB-сессии ${sessionId} содержит некорректную версию определения.`,
+    );
+  }
+  const definitionSha256 = value.definition_sha256 === null
+    ? null
+    : requireText(value.definition_sha256, "definition_sha256", 64);
+  if (definitionSha256 !== null && !SHA256.test(definitionSha256)) {
+    throw new ObservationLabCalculationProfileContractError(
+      `Профиль расчёта LAB-сессии ${sessionId} не содержит SHA-256 определения.`,
+    );
+  }
+
+  const definitionFieldCount = [
+    definitionId,
+    definitionVersion,
+    definitionSha256,
+  ].filter((entry) => entry !== null).length;
+  if (
+    (origin === "existing-result" && definitionFieldCount !== 0)
+    || (origin === "archived-definition" && definitionFieldCount !== 3)
+  ) {
+    throw new ObservationLabCalculationProfileContractError(
+      `Профиль расчёта LAB-сессии ${sessionId} содержит неполную идентичность определения.`,
+    );
+  }
+
+  return {
+    schemaVersion: OBSERVATION_LAB_CALCULATION_PROFILE_SCHEMA,
+    setupId: requireIdentifier(value.setup_id, "setup_id"),
+    displayName: requireText(value.display_name, "display_name", 256),
+    origin,
+    definitionId,
+    definitionVersion,
+    definitionSha256,
+  };
+}
@@ -0,0 +1,280 @@
+export interface ObservationCanonicalLabReplayCapability {
+  schemaVersion: "missioncore.observation-lab-replay-capability/v1";
+  kind: "canonical-recorded-rerun";
+  viewerProfile: "recorded-session";
+  timeline: "session_time";
+  activation: "explicit";
+  commandsEnabled: false;
+}
+
+export interface ObservationPortableLabReplayCapability {
+  schemaVersion: "missioncore.observation-lab-replay-capability/v2";
+  kind: "portable-result-review";
+  viewerProfile: "portable-result";
+  timeline: "result-defined";
+  activation: "explicit";
+  commandsEnabled: false;
+}
+
+export type ObservationLabReplayCapability =
+  | ObservationCanonicalLabReplayCapability
+  | ObservationPortableLabReplayCapability;
+
+export class ObservationLabReplayCapabilityContractError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "ObservationLabReplayCapabilityContractError";
+  }
+}
+
+const SHA256 = /^[a-f0-9]{64}$/;
+const CAPABILITY_KEYS = new Set([
+  "schema_version",
+  "kind",
+  "viewer_profile",
+  "timeline",
+  "activation",
+  "commands_enabled",
+]);
+const CANONICAL_PROVENANCE_KEYS = new Set([
+  "schema_version",
+  "evidence_identity_sha256",
+  "result_document_sha256",
+  "replay_capability",
+  "authority",
+  "method",
+]);
+const PORTABLE_PROVENANCE_KEYS = new Set([
+  "schema_version",
+  "authority",
+  "calculation_profile",
+  "calculation_profile_sha256",
+  "job",
+  "source",
+  "run_definition",
+  "result_package",
+  "replay_capability",
+  "storage",
+  "method",
+]);
+const AUTHORITY_KEYS = new Set([
+  "commands_enabled",
+  "navigation_or_safety_accepted",
+  "actuation_accepted",
+]);
+const METHOD_KEYS = new Set([
+  "schema_version",
+  "completeness",
+  "execution_class",
+  "pipeline_id",
+  "components",
+]);
+const METHOD_COMPONENT_KEYS = new Set([
+  "kind",
+  "name",
+  "version",
+  "role",
+  "identity_sha256",
+]);
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+function assertExactKeys(
+  value: Record<string, unknown>,
+  expected: ReadonlySet<string>,
+  label: string,
+): void {
+  const keys = Object.keys(value);
+  if (keys.length !== expected.size || keys.some((key) => !expected.has(key))) {
+    throw new ObservationLabReplayCapabilityContractError(
+      `${label} содержит неизвестные или пропущенные поля.`,
+    );
+  }
+}
+
+export function decodeLabReplayCapability(
+  value: unknown,
+  sessionId: string,
+): ObservationLabReplayCapability | null {
+  if (value === null || value === undefined) return null;
+  if (!isRecord(value)) {
+    throw new ObservationLabReplayCapabilityContractError(
+      `Replay-возможность LAB-сессии ${sessionId} должна быть объектом или null.`,
+    );
+  }
+  assertExactKeys(value, CAPABILITY_KEYS, `Replay-возможность LAB-сессии ${sessionId}`);
+  if (
+    value.activation !== "explicit"
+    || value.commands_enabled !== false
+  ) {
+    throw new ObservationLabReplayCapabilityContractError(
+      `Replay-возможность LAB-сессии ${sessionId} нарушает observation-only контракт.`,
+    );
+  }
+  if (
+    value.schema_version === "missioncore.observation-lab-replay-capability/v1"
+    && value.kind === "canonical-recorded-rerun"
+    && value.viewer_profile === "recorded-session"
+    && value.timeline === "session_time"
+  ) {
+    return {
+      schemaVersion: "missioncore.observation-lab-replay-capability/v1",
+      kind: "canonical-recorded-rerun",
+      viewerProfile: "recorded-session",
+      timeline: "session_time",
+      activation: "explicit",
+      commandsEnabled: false,
+    };
+  }
+  if (
+    value.schema_version === "missioncore.observation-lab-replay-capability/v2"
+    && value.kind === "portable-result-review"
+    && value.viewer_profile === "portable-result"
+    && value.timeline === "result-defined"
+  ) {
+    return {
+      schemaVersion: "missioncore.observation-lab-replay-capability/v2",
+      kind: "portable-result-review",
+      viewerProfile: "portable-result",
+      timeline: "result-defined",
+      activation: "explicit",
+      commandsEnabled: false,
+    };
+  }
+  throw new ObservationLabReplayCapabilityContractError(
+    `Replay-возможность LAB-сессии ${sessionId} содержит неизвестный viewer capability.`,
+  );
+}
+
+export function decodeCanonicalLabReplayCapabilityProvenance(
+  provenance: Readonly<Record<string, unknown>>,
+  sessionId: string,
+  resultId: string,
+): ObservationCanonicalLabReplayCapability {
+  assertExactKeys(provenance, CANONICAL_PROVENANCE_KEYS, `Canonical provenance LAB-сессии ${sessionId}`);
+  if (
+    provenance.schema_version !== "missioncore.canonical-recorded-lab-projection/v1"
+    || typeof provenance.evidence_identity_sha256 !== "string"
+    || !SHA256.test(provenance.evidence_identity_sha256)
+    || resultId !== `lab-v1-vegetation-shadow-${provenance.evidence_identity_sha256}`
+    || typeof provenance.result_document_sha256 !== "string"
+    || !SHA256.test(provenance.result_document_sha256)
+  ) {
+    throw new ObservationLabReplayCapabilityContractError(
+      `Canonical provenance LAB-сессии ${sessionId} потеряла immutable identity.`,
+    );
+  }
+  if (!isRecord(provenance.authority)) {
+    throw new ObservationLabReplayCapabilityContractError(
+      `Canonical provenance LAB-сессии ${sessionId} не содержит authority.`,
+    );
+  }
+  assertExactKeys(provenance.authority, AUTHORITY_KEYS, `Canonical authority LAB-сессии ${sessionId}`);
+  if (
+    provenance.authority.commands_enabled !== false
+    || provenance.authority.navigation_or_safety_accepted !== false
+    || provenance.authority.actuation_accepted !== false
+  ) {
+    throw new ObservationLabReplayCapabilityContractError(
+      `Canonical provenance LAB-сессии ${sessionId} нарушает observation-only authority.`,
+    );
+  }
+  if (!isRecord(provenance.method)) {
+    throw new ObservationLabReplayCapabilityContractError(
+      `Canonical provenance LAB-сессии ${sessionId} не содержит method manifest.`,
+    );
+  }
+  assertExactKeys(provenance.method, METHOD_KEYS, `Canonical method LAB-сессии ${sessionId}`);
+  if (
+    provenance.method.schema_version !== "missioncore.laboratory-method/v1"
+    || provenance.method.completeness !== "legacy-partial"
+    || provenance.method.execution_class !== "ai-inference"
+    || provenance.method.pipeline_id
+      !== "ravnoves004tree-full-eomt-ddrnet-recorded-review/v1"
+    || !Array.isArray(provenance.method.components)
+    || provenance.method.components.length !== 1
+  ) {
+    throw new ObservationLabReplayCapabilityContractError(
+      `Canonical method LAB-сессии ${sessionId} не соответствует записанному прогону.`,
+    );
+  }
+  const component = provenance.method.components[0];
+  if (!isRecord(component)) {
+    throw new ObservationLabReplayCapabilityContractError(
+      `Canonical method LAB-сессии ${sessionId} не содержит source component.`,
+    );
+  }
+  assertExactKeys(
+    component,
+    METHOD_COMPONENT_KEYS,
+    `Canonical source component LAB-сессии ${sessionId}`,
+  );
+  if (
+    component.kind !== "source"
+    || component.name !== "sealed full-route LAB result"
+    || component.version !== "missioncore.lab-v1-vegetation-shadow/v1"
+    || component.role !== "immutable Session catalog projection"
+    || component.identity_sha256 !== provenance.evidence_identity_sha256
+  ) {
+    throw new ObservationLabReplayCapabilityContractError(
+      `Canonical source component LAB-сессии ${sessionId} потерял immutable identity.`,
+    );
+  }
+  const capability = decodeLabReplayCapability(provenance.replay_capability, sessionId);
+  if (capability === null || capability.kind !== "canonical-recorded-rerun") {
+    throw new ObservationLabReplayCapabilityContractError(
+      `Canonical provenance LAB-сессии ${sessionId} не содержит replay capability.`,
+    );
+  }
+  return capability;
+}
+
+export function decodePortableLabReplayCapabilityProvenance(
+  provenance: Readonly<Record<string, unknown>>,
+  sessionId: string,
+  resultId: string,
+  sourceSessionId: string,
+  definitionSha256: string,
+): ObservationPortableLabReplayCapability {
+  assertExactKeys(
+    provenance,
+    PORTABLE_PROVENANCE_KEYS,
+    `Portable provenance LAB-сессии ${sessionId}`,
+  );
+  if (
+    provenance.schema_version !== "missioncore.observatory-portable-result-publication/v1"
+    || !isRecord(provenance.source)
+    || provenance.source.session_id !== sourceSessionId
+    || !isRecord(provenance.run_definition)
+    || provenance.run_definition.definition_sha256 !== definitionSha256
+    || !isRecord(provenance.result_package)
+    || typeof provenance.result_package.manifest_sha256 !== "string"
+    || !SHA256.test(provenance.result_package.manifest_sha256)
+    || typeof provenance.result_package.artifact_manifest_id !== "string"
+    || !SHA256.test(provenance.result_package.artifact_manifest_id)
+    || sessionId !== resultId
+  ) {
+    throw new ObservationLabReplayCapabilityContractError(
+      `Portable provenance LAB-сессии ${sessionId} потеряла immutable identity.`,
+    );
+  }
+  const capability = decodeLabReplayCapability(provenance.replay_capability, sessionId);
+  if (capability === null || capability.kind !== "portable-result-review") {
+    throw new ObservationLabReplayCapabilityContractError(
+      `Portable provenance LAB-сессии ${sessionId} не содержит viewer capability.`,
+    );
+  }
+  return capability;
+}
+
+/** Rolling bridge for a new frontend against the pre-v2 catalog endpoint. */
+export function decodeRollingCanonicalLabReplayCapability(
+  provenance: Readonly<Record<string, unknown>>,
+  sessionId: string,
+  resultId: string,
+): ObservationLabReplayCapability | null {
+  if (!Object.prototype.hasOwnProperty.call(provenance, "replay_capability")) return null;
+  return decodeCanonicalLabReplayCapabilityProvenance(provenance, sessionId, resultId);
+}
@@ -0,0 +1,53 @@
+/** Small lease for the server's ephemeral blueprint, never for the recording. */
+export function keepRecordedBlueprintSession({
+  endpointUrl,
+  origin,
+  applicationId,
+  recordingId,
+  ownerId,
+  fetcher = fetch,
+  schedule = (callback: () => void) => window.setInterval(callback, 30_000),
+  cancel = (handle: number) => window.clearInterval(handle),
+}: {
+  endpointUrl: string;
+  origin: string;
+  applicationId: string;
+  recordingId: string;
+  ownerId: string;
+  fetcher?: typeof fetch;
+  schedule?: (callback: () => void) => number;
+  cancel?: (handle: number) => void;
+}): () => void {
+  const endpoint = new URL(endpointUrl, origin);
+  if (endpoint.origin !== origin || endpoint.search || endpoint.hash ||
+      !/^\/api\/v1\/observation-sessions\/[A-Za-z0-9._:-]+\/blueprint\.rrd$/.test(endpoint.pathname)) {
+    throw new Error("Unsafe recorded blueprint lifecycle endpoint");
+  }
+  endpoint.pathname = endpoint.pathname.replace(/blueprint\.rrd$/, "blueprint-lifecycle");
+  const identity = { application_id: applicationId, recording_id: recordingId,
+    blueprint_session_id: ownerId };
+  let closed = false;
+  let pending: AbortController | null = null;
+  const renew = () => {
+    if (closed) return;
+    pending?.abort();
+    pending = new AbortController();
+    void fetcher(endpoint.href, {
+      method: "POST", headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ ...identity, action: "renew" }), signal: pending.signal,
+    }).catch(() => { /* The TTL cleans up after a lost browser/network. */ });
+  };
+  const timer = schedule(renew);
+  return () => {
+    if (closed) return;
+    closed = true;
+    cancel(timer);
+    pending?.abort();
+    pending = null;
+    void fetcher(endpoint.href, {
+      method: "POST", headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ ...identity, action: "release" }),
+      keepalive: true, signal: AbortSignal.timeout(5_000),
+    }).catch(() => { /* Terminal release is best-effort; the server also has TTL. */ });
+  };
+}
@@ -209,6 +209,49 @@ export function attemptRecordedAutoplay(
  }
 }

+export function createRecordedInitialSeekGate(): {
+  attempt: (
+    viewerStarted: boolean,
+    fullyBuffered: boolean,
+    presentationReady: boolean,
+    rangeNs: { min: number; max: number } | null,
+    seekToStart: (startNs: number) => void,
+    preferredStartNs?: number,
+  ) => boolean;
+  attempted: () => boolean;
+} {
+  let consumed = false;
+  return {
+    attempt(
+      viewerStarted,
+      fullyBuffered,
+      presentationReady,
+      rangeNs,
+      seekToStart,
+      preferredStartNs,
+    ) {
+      if (
+        consumed
+        || !viewerStarted
+        || !fullyBuffered
+        || !presentationReady
+        || !isUsableRecordedPlaybackRange(rangeNs)
+      ) return false;
+      consumed = true;
+      const startNs = Number.isFinite(preferredStartNs)
+        ? Math.min(Math.max(preferredStartNs as number, rangeNs.min), rangeNs.max)
+        : rangeNs.min;
+      try {
+        seekToStart(startNs);
+        return true;
+      } catch {
+        return false;
+      }
+    },
+    attempted: () => consumed,
+  };
+}
+
 export function createRecordedAutoplayGate(): {
  attempt: (
    viewerStarted: boolean,
@@ -0,0 +1,43 @@
+export interface ObservationReplayAttempt {
+  readonly signal: AbortSignal;
+  isCurrent: () => boolean;
+  finish: () => boolean;
+}
+
+export interface ObservationReplayCoordinator {
+  begin: () => ObservationReplayAttempt;
+  cancel: () => void;
+}
+
+/** Latest explicit admission owns the viewer, even if an older promise settles later. */
+export function createObservationReplayCoordinator(): ObservationReplayCoordinator {
+  let sequence = 0;
+  let active: AbortController | null = null;
+
+  return {
+    begin() {
+      active?.abort();
+      const controller = new AbortController();
+      const attemptSequence = ++sequence;
+      active = controller;
+      return {
+        signal: controller.signal,
+        isCurrent: () => (
+          !controller.signal.aborted
+          && active === controller
+          && sequence === attemptSequence
+        ),
+        finish: () => {
+          if (active !== controller || sequence !== attemptSequence) return false;
+          active = null;
+          return true;
+        },
+      };
+    },
+    cancel() {
+      active?.abort();
+      // Keep settlement ownership until finish(). isCurrent() already fails,
+      // while begin() can replace this attempt immediately.
+    },
+  };
+}
@@ -1,6 +1,20 @@
 import {
  MAX_RECORDED_CAMERA_SOURCES,
 } from "./recordedSessionAdmission";
+import {
+  decodeLabReplayCapability,
+  decodeRollingCanonicalLabReplayCapability,
+  ObservationLabReplayCapabilityContractError,
+  type ObservationLabReplayCapability,
+} from "./labReplayCapability";
+import {
+  decodeObservationLabCalculationProfile,
+  ObservationLabCalculationProfileContractError,
+  type ObservationLabCalculationProfile,
+} from "./labCalculationProfile";
+
+export type { ObservationLabReplayCapability } from "./labReplayCapability";
+export type { ObservationLabCalculationProfile } from "./labCalculationProfile";

 export type ObservationSessionStatus =
  | "recording"
@@ -20,6 +34,8 @@ export interface ObservationLabInstance {
  configSha256: string | null;
  runCreatedAtUtc: string;
  publishedAtUtc: string;
+  replayCapability: ObservationLabReplayCapability | null;
+  calculationProfile: ObservationLabCalculationProfile | null;
  provenance: Readonly<Record<string, unknown>>;
 }

@@ -32,10 +48,21 @@ export interface ObservationSessionSummary {
  modalities: readonly string[];
  durationSeconds: number;
  replayable: boolean;
+  captureAttestation: ObservationCaptureAttestation | null;
  preparation: ObservationSessionCatalogPreparation | null;
  lab: ObservationLabInstance | null;
 }

+export interface ObservationCaptureAttestation {
+  readonly equipmentModelId: string;
+  readonly equipmentModelSha256: string;
+  readonly equipmentDisplayName: string;
+  readonly captureProfileId: string;
+  readonly captureProfileSha256: string;
+  readonly captureAttestationSha256: string;
+  readonly state: "attested" | "attested-with-legacy-evidence" | "unknown";
+}
+
 export interface ObservationSessionCatalog {
  items: readonly ObservationSessionSummary[];
 }
@@ -152,10 +179,11 @@ const ITEM_KEYS = new Set([
  "modalities",
  "duration_seconds",
  "replayable",
+  "capture_attestation",
  "preparation",
  "lab",
 ]);
-const LAB_KEYS = new Set([
+const LEGACY_LAB_KEYS = new Set([
  "lab_id",
  "source_session_id",
  "result_kind",
@@ -166,6 +194,27 @@ const LAB_KEYS = new Set([
  "published_at_utc",
  "provenance",
 ]);
+const LAB_V2_KEYS = new Set([...LEGACY_LAB_KEYS, "replay_capability"]);
+const LAB_V3_KEYS = new Set([
+  ...LAB_V2_KEYS,
+  "calculation_profile",
+]);
+const CAPTURE_ATTESTATION_KEYS = new Set([
+  "schema_version",
+  "equipment_model",
+  "capture_profile",
+  "capture_attestation_sha256",
+  "state",
+]);
+const EQUIPMENT_MODEL_KEYS = new Set([
+  "equipment_model_id",
+  "equipment_model_sha256",
+  "display_name",
+]);
+const CAPTURE_PROFILE_KEYS = new Set([
+  "capture_profile_id",
+  "capture_profile_sha256",
+]);
 const CATALOG_PREPARATION_KEYS = new Set([
  "preparation_id",
  "state",
@@ -379,11 +428,103 @@ function decodeItem(value: unknown, index: number): ObservationSessionSummary {
    modalities: requireModalities(value.modalities),
    durationSeconds: value.duration_seconds,
    replayable: value.replayable,
+    captureAttestation: decodeCaptureAttestation(value.capture_attestation, id),
    preparation: decodeCatalogPreparation(value.preparation, id),
    lab: decodeLabInstance(value.lab, id),
  };
 }

+function decodeCaptureAttestation(
+  value: unknown,
+  sessionId: string,
+): ObservationCaptureAttestation | null {
+  if (value === null || value === undefined) return null;
+  if (!isRecord(value)) {
+    throw new ObservationSessionContractError(
+      `Аттестация записи ${sessionId} должна быть объектом или null.`,
+    );
+  }
+  assertExactKeys(value, CAPTURE_ATTESTATION_KEYS, `Аттестация записи ${sessionId}`);
+  if (value.schema_version !== "missioncore.recorded-capture-attestation/v1") {
+    throw new ObservationSessionContractError(
+      `Аттестация записи ${sessionId} имеет неизвестную схему.`,
+    );
+  }
+  if (!isRecord(value.equipment_model) || !isRecord(value.capture_profile)) {
+    throw new ObservationSessionContractError(
+      `Аттестация записи ${sessionId} не содержит оборудование или профиль записи.`,
+    );
+  }
+  assertExactKeys(
+    value.equipment_model,
+    EQUIPMENT_MODEL_KEYS,
+    `Оборудование записи ${sessionId}`,
+  );
+  assertExactKeys(
+    value.capture_profile,
+    CAPTURE_PROFILE_KEYS,
+    `Профиль записи ${sessionId}`,
+  );
+  const equipmentModelId = requireString(
+    value.equipment_model.equipment_model_id,
+    "equipment_model_id",
+    128,
+  );
+  const equipmentModelSha256 = requireString(
+    value.equipment_model.equipment_model_sha256,
+    "equipment_model_sha256",
+    64,
+  );
+  const captureProfileId = requireString(
+    value.capture_profile.capture_profile_id,
+    "capture_profile_id",
+    128,
+  );
+  const captureProfileSha256 = requireString(
+    value.capture_profile.capture_profile_sha256,
+    "capture_profile_sha256",
+    64,
+  );
+  const captureAttestationSha256 = requireString(
+    value.capture_attestation_sha256,
+    "capture_attestation_sha256",
+    64,
+  );
+  if (
+    !SAFE_ID.test(equipmentModelId)
+    || !SAFE_ID.test(captureProfileId)
+    || !SHA256.test(equipmentModelSha256)
+    || !SHA256.test(captureProfileSha256)
+    || !SHA256.test(captureAttestationSha256)
+  ) {
+    throw new ObservationSessionContractError(
+      `Аттестация записи ${sessionId} содержит некорректную immutable identity.`,
+    );
+  }
+  if (
+    value.state !== "attested"
+    && value.state !== "attested-with-legacy-evidence"
+    && value.state !== "unknown"
+  ) {
+    throw new ObservationSessionContractError(
+      `Аттестация записи ${sessionId} содержит неизвестное состояние.`,
+    );
+  }
+  return {
+    equipmentModelId,
+    equipmentModelSha256,
+    equipmentDisplayName: requireString(
+      value.equipment_model.display_name,
+      "equipment display_name",
+      128,
+    ),
+    captureProfileId,
+    captureProfileSha256,
+    captureAttestationSha256,
+    state: value.state,
+  };
+}
+
 function decodeLabInstance(
  value: unknown,
  sessionId: string,
@@ -394,7 +535,23 @@ function decodeLabInstance(
      `LAB-привязка сессии ${sessionId} должна быть объектом или null.`,
    );
  }
-  assertExactKeys(value, LAB_KEYS, `LAB-привязка сессии ${sessionId}`);
+  const hasTypedCapability = Object.prototype.hasOwnProperty.call(
+    value,
+    "replay_capability",
+  );
+  const hasCalculationProfile = Object.prototype.hasOwnProperty.call(
+    value,
+    "calculation_profile",
+  );
+  assertExactKeys(
+    value,
+    hasCalculationProfile
+      ? LAB_V3_KEYS
+      : hasTypedCapability
+        ? LAB_V2_KEYS
+        : LEGACY_LAB_KEYS,
+    `LAB-привязка сессии ${sessionId}`,
+  );
  const labId = requireString(value.lab_id, `lab(${sessionId}).lab_id`, 36);
  if (!/^LAB [A-Z][A-Z0-9._-]{0,31}$/.test(labId)) {
    throw new ObservationSessionContractError("Каталог содержит некорректный LAB-маркер.");
@@ -430,6 +587,28 @@ function decodeLabInstance(
  if (!isRecord(value.provenance)) {
    throw new ObservationSessionContractError("LAB provenance должен быть JSON-объектом.");
  }
+  let replayCapability: ObservationLabReplayCapability | null;
+  try {
+    replayCapability = hasTypedCapability
+      ? decodeLabReplayCapability(value.replay_capability, sessionId)
+      : decodeRollingCanonicalLabReplayCapability(value.provenance, sessionId, resultId);
+  } catch (error) {
+    if (error instanceof ObservationLabReplayCapabilityContractError) {
+      throw new ObservationSessionContractError(error.message);
+    }
+    throw error;
+  }
+  let calculationProfile: ObservationLabCalculationProfile | null;
+  try {
+    calculationProfile = hasCalculationProfile
+      ? decodeObservationLabCalculationProfile(value.calculation_profile, sessionId)
+      : null;
+  } catch (error) {
+    if (error instanceof ObservationLabCalculationProfileContractError) {
+      throw new ObservationSessionContractError(error.message);
+    }
+    throw error;
+  }
  return {
    labId,
    sourceSessionId,
@@ -445,6 +624,8 @@ function decodeLabInstance(
      value.published_at_utc,
      `lab(${sessionId}).published_at_utc`,
    ),
+    replayCapability,
+    calculationProfile,
    provenance: value.provenance,
  };
 }
@@ -1181,6 +1362,7 @@ export async function fetchObservationSessionCatalog({
    queryParameters.set("limit", String(Number(limit)));
  }
  if (scope !== "all") queryParameters.set("scope", scope);
+  if (scope === "laboratory") queryParameters.set("lab_contract", "v3");
  const serializedQuery = queryParameters.toString();
  const query = serializedQuery ? `?${serializedQuery}` : "";
  let response: Response;
@@ -0,0 +1,72 @@
+import {
+  decodeObservationSessionCatalog,
+  ObservationSessionApiError,
+  ObservationSessionContractError,
+  type ObservationSessionCatalog,
+  type ObservationSessionFetch,
+  type ObservationSessionScope,
+} from "./sessionArchive";
+
+const PAGE_SCHEMA = "missioncore.observation-session-page/v1";
+const CURSOR = /^[A-Za-z0-9][A-Za-z0-9_.-]{0,127}$/;
+
+export interface ObservationSessionCatalogPage extends ObservationSessionCatalog {
+  readonly nextCursor: string | null;
+}
+
+/** Opt-in paging leaves the legacy catalog response and consumers unchanged. */
+export async function fetchObservationSessionCatalogPage({
+  scope,
+  limit = 100,
+  cursor = null,
+  signal,
+  fetcher = globalThis.fetch,
+}: {
+  scope: ObservationSessionScope;
+  limit?: number;
+  cursor?: string | null;
+  signal?: AbortSignal;
+  fetcher?: ObservationSessionFetch;
+}): Promise<ObservationSessionCatalogPage> {
+  if (!Number.isInteger(limit) || limit < 1 || limit > 100
+    || (cursor !== null && !CURSOR.test(cursor))) {
+    throw new ObservationSessionContractError("Некорректная страница каталога сессий.");
+  }
+  signal?.throwIfAborted();
+  const query = new URLSearchParams({ limit: String(limit), scope });
+  if (scope === "laboratory") query.set("lab_contract", "v3");
+  query.set("pagination", "cursor-v1");
+  if (cursor !== null) query.set("cursor", cursor);
+  const response = await fetcher(`/api/v1/observation-sessions?${query}`, {
+    method: "GET", headers: { Accept: "application/json" }, signal,
+  });
+  if (!response.ok) {
+    throw new ObservationSessionApiError(
+      `Не удалось загрузить страницу каталога сессий (HTTP ${response.status}).`,
+      response.status,
+    );
+  }
+  let body: unknown;
+  try {
+    body = await response.json();
+  } catch {
+    throw new ObservationSessionContractError("Некорректный ответ каталога сессий.");
+  }
+  if (typeof body !== "object" || body === null || Array.isArray(body)) {
+    throw new ObservationSessionContractError("Страница каталога должна быть объектом.");
+  }
+  const page = body as Record<string, unknown>;
+  if (Object.keys(page).length !== 3
+    || page.schema_version !== PAGE_SCHEMA
+    || !Object.hasOwn(page, "items")
+    || !(page.next_cursor === null
+      || (typeof page.next_cursor === "string" && CURSOR.test(page.next_cursor)))) {
+    throw new ObservationSessionContractError("Нарушен контракт страницы каталога сессий.");
+  }
+  const catalog = decodeObservationSessionCatalog({ items: page.items });
+  if (catalog.items.length > limit) {
+    throw new ObservationSessionContractError("Страница каталога превысила запрошенный размер.");
+  }
+  signal?.throwIfAborted();
+  return { ...catalog, nextCursor: page.next_cursor };
+}
@@ -12,6 +12,16 @@ import {
  type ObservationSessionScope,
  type ObservationSessionSummary,
 } from "./sessionArchive";
+import {
+  createObservationReplayCoordinator,
+  type ObservationReplayCoordinator,
+} from "./replayCoordinator";
+
+export {
+  createObservationReplayCoordinator,
+  type ObservationReplayAttempt,
+  type ObservationReplayCoordinator,
+} from "./replayCoordinator";

 export type ObservationSessionsLoadState = "idle" | "loading" | "ready" | "error";
 export type ObservationReplayOutcome = "accepted" | "error" | "cancelled";
@@ -41,17 +51,6 @@ export interface ObservationSessionsController {
  remove: (sessionId: string) => Promise<boolean>;
 }

-export interface ObservationReplayAttempt {
-  readonly signal: AbortSignal;
-  isCurrent: () => boolean;
-  finish: () => boolean;
-}
-
-export interface ObservationReplayCoordinator {
-  begin: () => ObservationReplayAttempt;
-  cancel: () => void;
-}
-
 export async function deleteObservationSessionAfterTeardown(
  sessionId: string,
  {
@@ -93,41 +92,6 @@ export class ObservationPreparationStalledError extends Error {
  }
 }

-/** Latest selection wins, even if an obsolete server job finishes later. */
-export function createObservationReplayCoordinator(): ObservationReplayCoordinator {
-  let sequence = 0;
-  let active: AbortController | null = null;
-
-  return {
-    begin() {
-      active?.abort();
-      const controller = new AbortController();
-      const attemptSequence = ++sequence;
-      active = controller;
-      return {
-        signal: controller.signal,
-        isCurrent: () => (
-          !controller.signal.aborted &&
-          active === controller &&
-          sequence === attemptSequence
-        ),
-        finish: () => {
-          if (active !== controller || sequence !== attemptSequence) return false;
-          active = null;
-          return true;
-        },
-      };
-    },
-    cancel() {
-      active?.abort();
-      // Keep ownership until the cancelled attempt reaches `finish()`. This
-      // lets its finally block settle a replacement that already passed
-      // onReplayBegin, while `isCurrent()` still fails immediately because the
-      // signal is aborted. A later `begin()` replaces and invalidates it.
-    },
-  };
-}
-
 function errorMessage(error: unknown): string {
  return error instanceof Error && error.message.trim()
    ? error.message
@@ -24,9 +24,11 @@ export interface RerunPlaybackController {

 export interface RecordedPerceptionLayers {
  enabled: boolean;
+  cameraImage?: boolean;
  detections2d: boolean;
  segmentation: boolean;
  cuboids3d: boolean;
+  costmap?: boolean;
 }

 export interface RecordedRrdArtifactDescriptor {
@@ -67,20 +69,33 @@ export interface RecordedSessionRerunProfile {
  viewResetGeneration: 0 | 1;
  followTrajectory: boolean;
  perceptionLayers: RecordedPerceptionLayers;
+  /** Explicit small blueprint endpoint when the viewer source is a merged LAB RRD. */
+  blueprintSourceUrl?: string;
+  /** Optional immutable RRD sidecar for LAB/model evidence on the same recording clock. */
+  perceptionSourceUrl?: string;
+  /** Selects one semantic entity without changing the sealed sidecar. */
+  semanticLayer?: "city" | "vegetation";
+  /** Keeps one native Rerun store/viewer while presenting the accepted two-pane LAB layout. */
+  unifiedPerception?: boolean;
+  /** Controlled camera-column share for the native horizontal Rerun container. */
+  unifiedCameraShare?: number;
+  /** Requests the canonical top-down eye without changing the world coordinate frame. */
+  planView?: boolean;
  perceptionRetryGeneration: number;
  lockPerceptionCameraInteraction: boolean;
 }

 /**
- * LAB recorded evidence is not a native Rerun mode. It owns a source-sequence
- * clock and composes the existing sealed fMP4 and retained spatial primitives.
+ * Deprecated comparison-only contract for LAB artifacts that have not yet
+ * been republished as a native Rerun sidecar. It must never be selected by a
+ * canonical LAB route or start work in the background.
 */
 export interface LaboratoryRecordedEvidenceViewerProfile {
  kind: "lab-recorded-evidence";
  clock: "source-sequence";
  cameraTransport: "generation-bound-fmp4";
  spatialTransport: "bounded-sealed-artifacts";
-  loadPolicy: "visible-evidence-only";
+  loadPolicy: "explicit-legacy-comparison-only";
  workerRequired: false;
 }

@@ -97,7 +112,7 @@ export const LABORATORY_RECORDED_EVIDENCE_VIEWER_PROFILE = Object.freeze({
  clock: "source-sequence",
  cameraTransport: "generation-bound-fmp4",
  spatialTransport: "bounded-sealed-artifacts",
-  loadPolicy: "visible-evidence-only",
+  loadPolicy: "explicit-legacy-comparison-only",
  workerRequired: false,
 } satisfies LaboratoryRecordedEvidenceViewerProfile);

@@ -0,0 +1,347 @@
+import {
+  decodeObservatoryRecordedJob,
+  type ObservatoryRecordedJob,
+} from "./recordedJobs";
+
+const COMPOSITION_SCHEMA = "missioncore.observatory-ai-composition/v1";
+const CATALOG_SCHEMA = "missioncore.observatory-ai-module-catalog/v1";
+const RECEIPT_SCHEMA = "missioncore.observatory-ai-composition-receipt/v3";
+const SHA256 = /^[a-f0-9]{64}$/;
+
+export type AIGroupId = "segmentation" | "detection" | "geometry" | "range" | "motion" | "policy";
+
+export interface AIModule {
+  readonly moduleId: string;
+  readonly moduleSha256: string;
+  readonly label: string;
+  readonly dockerName: string;
+  readonly requires: readonly string[];
+  readonly provides: readonly string[];
+  readonly defaults: Readonly<Record<string, unknown>>;
+}
+
+export interface AIModuleGroup {
+  readonly group: AIGroupId;
+  readonly modules: readonly AIModule[];
+}
+
+export interface AIModuleCatalog {
+  readonly groups: readonly AIModuleGroup[];
+}
+
+export interface AICompositionReceipt {
+  readonly compositionSha256: string;
+  readonly created: boolean;
+  readonly dispatchReady: boolean;
+  readonly dispatchReason: string;
+  readonly setupIds: readonly string[];
+  readonly jobs: readonly ObservatoryRecordedJob[];
+  readonly run: AICompositionRun;
+}
+
+export interface AIViewerLayer {
+  readonly layerId: string;
+  readonly paneId: "camera" | "spatial";
+  readonly label: string;
+  readonly control: "toggle" | "toggle-with-settings";
+  readonly order: number;
+}
+
+export interface AICompositionPresentation {
+  readonly configurationLabel: string;
+  readonly modules: readonly { readonly moduleId: string; readonly label: string }[];
+  readonly viewerLayers: readonly AIViewerLayer[];
+}
+
+export interface AICompositionRun {
+  readonly runId: string;
+  readonly sourceSessionId: string;
+  readonly compositionSha256: string;
+  readonly moduleIds: readonly string[];
+  readonly setupIds: readonly string[];
+  readonly jobIds: readonly string[];
+  readonly resultIds: readonly string[];
+  readonly createdAtUtc: string;
+  readonly state: "running" | "ready" | "failed";
+  readonly configurationLabel: string;
+  readonly displayName: string | null;
+  readonly presentation: AICompositionPresentation;
+  readonly jobs: readonly ObservatoryRecordedJob[];
+}
+
+export const AI_MODULE_SETUP_IDS: Readonly<Record<string, string>> = Object.freeze({
+  ddrnet: "ai-segmentation-ddrnet-v1",
+  eomt: "ai-segmentation-eomt-v1",
+  tgs: "m49-tgs-portable-v2",
+  "rf-detr": "ai-detection-rf-detr-v1",
+  "object-distance": "ai-range-object-distance-v1",
+});
+
+export function aiModuleIdForSetup(setupId: string): string | null {
+  return Object.entries(AI_MODULE_SETUP_IDS).find(([, value]) => value === setupId)?.[0] ?? null;
+}
+
+export async function fetchAIModuleCatalog(signal?: AbortSignal): Promise<AIModuleCatalog> {
+  const response = await fetch("/api/v1/observatory/ai-module-catalog", {
+    headers: { Accept: "application/json" }, signal,
+  });
+  const body = await bodyOf(response);
+  if (!response.ok) throw apiError(body, response.status);
+  const root = record(body, "каталог AI-модулей");
+  exactKeys(root, ["authority", "groups", "schema_version"]);
+  if (root.schema_version !== CATALOG_SCHEMA) throw new Error("Версия каталога AI-модулей изменилась.");
+  const known = new Set<AIGroupId>(["segmentation", "detection", "geometry", "range", "motion", "policy"]);
+  const groups = array(root.groups).map((value): AIModuleGroup => {
+    const group = record(value, "группа AI-модулей");
+    exactKeys(group, ["group", "modules"]);
+    if (typeof group.group !== "string" || !known.has(group.group as AIGroupId)) {
+      throw new Error("Каталог вернул неизвестную группу AI-модулей.");
+    }
+    return { group: group.group as AIGroupId, modules: array(group.modules).map(moduleOf) };
+  });
+  if (new Set(groups.map((group) => group.group)).size !== groups.length) {
+    throw new Error("Каталог AI-модулей содержит повторяющиеся группы.");
+  }
+  return { groups };
+}
+
+export async function saveAIComposition(
+  sourceSessionId: string,
+  selections: readonly { group: AIGroupId; module: AIModule }[],
+): Promise<AICompositionReceipt> {
+  const response = await fetch("/api/v1/observatory/ai-compositions", {
+    method: "POST",
+    headers: { Accept: "application/json", "Content-Type": "application/json" },
+    body: JSON.stringify({
+      schema_version: COMPOSITION_SCHEMA,
+      source_session_id: sourceSessionId,
+      idempotency_key: createIdempotencyKey(),
+      selections: selections.map(({ group, module }) => ({
+        group, module_id: module.moduleId, module_sha256: module.moduleSha256,
+        parameters: module.defaults,
+      })),
+    }),
+  });
+  const body = await bodyOf(response);
+  if (!response.ok) throw apiError(body, response.status);
+  const root = record(body, "конфигурация AI-слоя");
+  exactKeys(root, ["composition", "composition_sha256", "created", "dispatch", "run", "schema_version", "source_session_id"]);
+  if (root.schema_version !== RECEIPT_SCHEMA || root.source_session_id !== sourceSessionId) {
+    throw new Error("Сервер вернул конфигурацию для другой записи.");
+  }
+  const digest = text(root.composition_sha256);
+  if (!SHA256.test(digest)) throw new Error("Сервер вернул некорректную идентичность композиции.");
+  const dispatch = record(root.dispatch, "готовность композиции");
+  exactKeys(dispatch, ["jobs", "ready", "reason", "setup_ids"]);
+  if (dispatch.ready !== true) {
+    throw new Error(text(dispatch.reason));
+  }
+  const setupIds = array(dispatch.setup_ids).map(text);
+  const jobs = array(dispatch.jobs).map(decodeObservatoryRecordedJob);
+  if (!jobs.length || jobs.length !== setupIds.length
+    || jobs.some((job, index) => job.setupId !== setupIds[index])) {
+    throw new Error("Сервер вернул неполную очередь композиции.");
+  }
+  const run = compositionRunOf(root.run);
+  return {
+    compositionSha256: digest,
+    created: boolean(dispatch && root.created),
+    dispatchReady: boolean(dispatch.ready),
+    dispatchReason: text(dispatch.reason),
+    setupIds,
+    jobs,
+    run,
+  };
+}
+
+export async function fetchAICompositionRuns(
+  sourceSessionId: string,
+  signal?: AbortSignal,
+): Promise<readonly AICompositionRun[]> {
+  const query = new URLSearchParams({ source_session_id: sourceSessionId });
+  const response = await fetch(`/api/v1/observatory/ai-composition-runs?${query}`, {
+    headers: { Accept: "application/json" }, signal,
+  });
+  const body = await bodyOf(response);
+  if (!response.ok) throw apiError(body, response.status);
+  const root = record(body, "запуски композиций");
+  exactKeys(root, ["items", "schema_version"]);
+  if (root.schema_version !== "missioncore.observatory-ai-composition-run-list/v1") {
+    throw new Error("Версия запусков AI-композиций изменилась.");
+  }
+  return array(root.items).map(compositionRunOf);
+}
+
+export async function renameAICompositionRunProjection(
+  runId: string,
+  displayName: string,
+): Promise<string> {
+  if (!/^ai-composition-[a-f0-9]{64}$/.test(runId)) {
+    throw new Error("Некорректная идентичность результата AI inference.");
+  }
+  const normalized = displayName.trim();
+  if (!normalized || normalized.length > 160) {
+    throw new Error("Название результата должно содержать от 1 до 160 символов.");
+  }
+  const response = await fetch(`/api/v1/observatory/ai-composition-runs/${encodeURIComponent(runId)}`, {
+    method: "PATCH",
+    headers: { Accept: "application/json", "Content-Type": "application/json" },
+    body: JSON.stringify({
+      schema_version: "missioncore.observatory-ai-composition-run-rename/v1",
+      display_name: normalized,
+    }),
+  });
+  const body = await bodyOf(response);
+  if (!response.ok) throw apiError(body, response.status);
+  const row = record(body, "результат AI inference");
+  exactKeys(row, ["display_name", "run_id", "schema_version"]);
+  if (
+    row.schema_version !== "missioncore.observatory-ai-composition-run-projection/v1"
+    || row.run_id !== runId
+    || row.display_name !== normalized
+  ) throw new Error("Сервер не подтвердил переименование результата AI inference.");
+  return normalized;
+}
+
+export async function deleteAICompositionRunProjection(runId: string): Promise<void> {
+  if (!/^ai-composition-[a-f0-9]{64}$/.test(runId)) {
+    throw new Error("Некорректная идентичность результата AI inference.");
+  }
+  const response = await fetch(`/api/v1/observatory/ai-composition-runs/${encodeURIComponent(runId)}`, {
+    method: "DELETE",
+    headers: { Accept: "application/json" },
+  });
+  if (!response.ok || response.status !== 204) {
+    throw apiError(await bodyOf(response), response.status);
+  }
+}
+
+function compositionRunOf(value: unknown): AICompositionRun {
+  const row = record(value, "запуск AI-композиции");
+  const expected = [
+    "composition_sha256", "configuration_label", "created_at_utc", "display_name", "job_ids", "jobs",
+    "module_ids", "presentation", "result_ids", "run_id", "schema_version", "setup_ids",
+    "source_session_id", "state",
+  ];
+  // The receipt embeds the immutable run before its live state projection.
+  const receiptShape = [
+    "composition_sha256", "created_at_utc", "job_ids", "module_ids", "presentation",
+    "run_id", "schema_version", "setup_ids", "source_session_id",
+  ];
+  const keys = Object.keys(row);
+  const projected = keys.length === expected.length;
+  exactKeys(row, projected ? expected : receiptShape);
+  if (row.schema_version !== "missioncore.observatory-ai-composition-run/v1") {
+    throw new Error("Версия запуска AI-композиции изменилась.");
+  }
+  const sourceSessionId = text(row.source_session_id);
+  const compositionSha256 = text(row.composition_sha256);
+  const runId = text(row.run_id);
+  if (!/^ai-composition-[a-f0-9]{64}$/.test(runId) || !SHA256.test(compositionSha256)) {
+    throw new Error("Некорректная идентичность запуска AI-композиции.");
+  }
+  const presentation = presentationOf(row.presentation);
+  const state = projected ? text(row.state) : "running";
+  if (!new Set(["running", "ready", "failed"]).has(state)) {
+    throw new Error("Неизвестное состояние запуска AI-композиции.");
+  }
+  return {
+    runId,
+    sourceSessionId,
+    compositionSha256,
+    moduleIds: array(row.module_ids).map(text),
+    setupIds: array(row.setup_ids).map(text),
+    jobIds: array(row.job_ids).map(text),
+    resultIds: projected ? array(row.result_ids).map(text) : [],
+    createdAtUtc: text(row.created_at_utc),
+    state: state as AICompositionRun["state"],
+    configurationLabel: projected ? text(row.configuration_label) : presentation.configurationLabel,
+    displayName: projected
+      ? row.display_name === null ? null : text(row.display_name)
+      : null,
+    presentation,
+    jobs: projected ? array(row.jobs).map(decodeObservatoryRecordedJob) : [],
+  };
+}
+
+function presentationOf(value: unknown): AICompositionPresentation {
+  const row = record(value, "проекция AI-композиции");
+  exactKeys(row, ["configuration_label", "modules", "schema_version", "viewer_layers"]);
+  if (row.schema_version !== "missioncore.observatory-presentation-projection/v1") {
+    throw new Error("Версия проекции AI-композиции изменилась.");
+  }
+  const modules = array(row.modules).map((value) => {
+    const module = record(value, "модуль проекции");
+    exactKeys(module, ["label", "module_id"]);
+    return { moduleId: text(module.module_id), label: text(module.label) };
+  });
+  const viewerLayers = array(row.viewer_layers).map((value): AIViewerLayer => {
+    const layer = record(value, "слой viewer");
+    exactKeys(layer, ["control", "label", "layer_id", "order", "pane_id"]);
+    const paneId = text(layer.pane_id);
+    const control = text(layer.control);
+    if (!new Set(["camera", "spatial"]).has(paneId)
+      || !new Set(["toggle", "toggle-with-settings"]).has(control)
+      || typeof layer.order !== "number") {
+      throw new Error("Некорректная проекция слоя viewer.");
+    }
+    return {
+      layerId: text(layer.layer_id), paneId: paneId as AIViewerLayer["paneId"],
+      label: text(layer.label), control: control as AIViewerLayer["control"], order: layer.order,
+    };
+  });
+  return { configurationLabel: text(row.configuration_label), modules, viewerLayers };
+}
+
+export async function fetchAICompositionJobs(
+  sourceSessionId: string,
+  signal?: AbortSignal,
+): Promise<readonly ObservatoryRecordedJob[]> {
+  const query = new URLSearchParams({ source_session_id: sourceSessionId });
+  const response = await fetch(`/api/v1/observatory/ai-runs?${query}`, {
+    headers: { Accept: "application/json" }, signal,
+  });
+  const body = await bodyOf(response);
+  if (!response.ok) throw apiError(body, response.status);
+  const root = record(body, "очередь AI-слоёв");
+  exactKeys(root, ["authority", "items", "schema_version"]);
+  if (root.schema_version !== "missioncore.observatory-recorded-job-list/v1") {
+    throw new Error("Версия очереди AI-слоёв изменилась.");
+  }
+  return array(root.items).map(decodeObservatoryRecordedJob);
+}
+
+function moduleOf(value: unknown): AIModule {
+  const row = record(value, "AI-модуль");
+  exactKeys(row, ["defaults", "docker_name", "label", "module_id", "module_sha256", "parameter_choices", "provides", "requires"]);
+  const digest = text(row.module_sha256);
+  if (!SHA256.test(digest)) throw new Error("Каталог вернул некорректную версию AI-модуля.");
+  return {
+    moduleId: text(row.module_id), moduleSha256: digest, label: text(row.label),
+    dockerName: text(row.docker_name), requires: array(row.requires).map(text),
+    provides: array(row.provides).map(text), defaults: record(row.defaults, "параметры AI-модуля"),
+  };
+}
+
+function record(value: unknown, label: string): Record<string, unknown> {
+  if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error(`Некорректный ${label}.`);
+  return value as Record<string, unknown>;
+}
+function array(value: unknown): unknown[] { if (!Array.isArray(value)) throw new Error("Ожидался список."); return value; }
+function text(value: unknown): string { if (typeof value !== "string" || !value) throw new Error("Ожидался текст."); return value; }
+function boolean(value: unknown): boolean { if (typeof value !== "boolean") throw new Error("Ожидалось логическое значение."); return value; }
+function exactKeys(value: Record<string, unknown>, expected: string[]): void {
+  if (Object.keys(value).sort().join() !== [...expected].sort().join()) throw new Error("Контракт AI-слоя изменился.");
+}
+async function bodyOf(response: Response): Promise<unknown> { const value = await response.text(); try { return JSON.parse(value); } catch { return value; } }
+function apiError(body: unknown, status: number): Error {
+  const detail = body && typeof body === "object" && !Array.isArray(body) ? (body as Record<string, unknown>).detail : null;
+  return new Error(typeof detail === "string" ? detail : `Observatory API вернул HTTP ${status}.`);
+}
+
+function createIdempotencyKey(): string {
+  const entropy = typeof globalThis.crypto?.randomUUID === "function"
+    ? globalThis.crypto.randomUUID()
+    : `${Date.now()}-${Math.random().toString(16).slice(2)}`;
+  return `ai-layer:${entropy}`;
+}
@@ -0,0 +1,321 @@
+import {
+  type ObservationLabInstance,
+  type ObservationSessionFetch,
+  type ObservationSessionSummary,
+} from "../observation/sessionArchive";
+import { fetchObservationSessionCatalogPage } from "../observation/sessionCatalogPage";
+import {
+  observatoryRecordedRunBinding,
+  type ObservatoryRecordedRunBinding,
+} from "./recordedRun";
+
+export interface ObservatoryEvidence {
+  readonly sessionId: string;
+  readonly label: string;
+  readonly status: ObservationSessionSummary["status"];
+  readonly publishedAtUtc: string;
+  readonly lab: ObservationLabInstance;
+  readonly recordedRun: ObservatoryRecordedRunBinding | null;
+}
+
+export interface ObservatorySession {
+  readonly source: ObservationSessionSummary;
+  readonly evidence: readonly ObservatoryEvidence[];
+}
+
+export interface ObservatoryCatalog {
+  readonly items: readonly ObservatorySession[];
+  readonly unresolvedEvidence: readonly ObservatoryEvidence[];
+  readonly window: {
+    readonly limit: number;
+    readonly sourceCount: number;
+    readonly laboratoryCount: number;
+    readonly sourceLimitReached: boolean;
+    readonly laboratoryLimitReached: boolean;
+  };
+}
+
+export type ObservatoryCatalogMutation =
+  | {
+      readonly kind: "rename";
+      readonly displayName: string;
+      readonly revision: number;
+    }
+  | {
+      readonly kind: "delete";
+      readonly revision: number;
+    };
+
+export type ObservatoryCatalogMutationOverlay = ReadonlyMap<
+  string,
+  ObservatoryCatalogMutation
+>;
+
+export interface ObservatoryCatalogReconciliation {
+  readonly catalog: ObservatoryCatalog;
+  readonly overlay: ObservatoryCatalogMutationOverlay;
+}
+
+export class ObservatoryCatalogContractError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "ObservatoryCatalogContractError";
+  }
+}
+
+export function findObservatoryEvidence(
+  catalog: ObservatoryCatalog,
+  sessionId: string,
+): ObservatoryEvidence | null {
+  for (const item of catalog.items) {
+    const evidence = item.evidence.find(
+      (candidate) => candidate.sessionId === sessionId,
+    );
+    if (evidence) return evidence;
+  }
+  return catalog.unresolvedEvidence.find(
+    (candidate) => candidate.sessionId === sessionId,
+  ) ?? null;
+}
+
+export function observatoryCatalogConfirmsEvidenceDeletion(
+  catalog: ObservatoryCatalog,
+  sessionId: string,
+): boolean {
+  return !catalog.window.laboratoryLimitReached
+    && findObservatoryEvidence(catalog, sessionId) === null;
+}
+
+export function applyObservatoryCatalogMutationOverlay(
+  catalog: ObservatoryCatalog,
+  overlay: ObservatoryCatalogMutationOverlay,
+): ObservatoryCatalog {
+  if (overlay.size === 0) return catalog;
+
+  const removedSessionIds = new Set<string>();
+  const projectEvidence = (
+    evidence: ObservatoryEvidence,
+  ): ObservatoryEvidence | null => {
+    const mutation = overlay.get(evidence.sessionId);
+    if (!mutation) return evidence;
+    if (mutation.kind === "delete") {
+      removedSessionIds.add(evidence.sessionId);
+      return null;
+    }
+    return evidence.label === mutation.displayName
+      ? evidence
+      : { ...evidence, label: mutation.displayName };
+  };
+  const projectEvidenceList = (
+    evidence: readonly ObservatoryEvidence[],
+  ): ObservatoryEvidence[] => evidence.flatMap((candidate) => {
+    const projected = projectEvidence(candidate);
+    return projected ? [projected] : [];
+  });
+
+  const items = catalog.items.map((item) => ({
+    ...item,
+    evidence: projectEvidenceList(item.evidence),
+  }));
+  const unresolvedEvidence = projectEvidenceList(catalog.unresolvedEvidence);
+  return {
+    ...catalog,
+    items,
+    unresolvedEvidence,
+    window: {
+      ...catalog.window,
+      laboratoryCount: Math.max(
+        0,
+        catalog.window.laboratoryCount - removedSessionIds.size,
+      ),
+    },
+  };
+}
+
+export function reconcileObservatoryCatalogMutationOverlay(
+  serverCatalog: ObservatoryCatalog,
+  overlay: ObservatoryCatalogMutationOverlay,
+  requestMutationRevision: number,
+): ObservatoryCatalogReconciliation {
+  const remaining = new Map(overlay);
+  for (const [sessionId, mutation] of overlay) {
+    if (mutation.revision > requestMutationRevision) continue;
+    const evidence = findObservatoryEvidence(serverCatalog, sessionId);
+    const confirmed = mutation.kind === "rename"
+      ? evidence?.label === mutation.displayName
+      : observatoryCatalogConfirmsEvidenceDeletion(serverCatalog, sessionId);
+    if (confirmed) remaining.delete(sessionId);
+  }
+  return {
+    catalog: applyObservatoryCatalogMutationOverlay(serverCatalog, remaining),
+    overlay: remaining,
+  };
+}
+
+function newestFirst(left: string, right: string): number {
+  return Date.parse(right) - Date.parse(left);
+}
+
+function boundedLimit(limit: number): number {
+  return Number.isFinite(limit)
+    ? Math.min(100, Math.max(1, Math.floor(limit)))
+    : 100;
+}
+
+function evidenceFromSession(
+  session: ObservationSessionSummary,
+): ObservatoryEvidence | null {
+  if (!session.lab) {
+    throw new ObservatoryCatalogContractError(
+      `LAB-каталог вернул сессию ${session.id} без типизированной связи с источником.`,
+    );
+  }
+  // Historical LABs retain their archive and replay adapters. Observatory is
+  // the portable-profile product; a familiar LAB label is not admission.
+  if (session.lab.replayCapability?.kind !== "portable-result-review") return null;
+  const recordedRun = observatoryRecordedRunBinding(session.id, session.lab);
+  return {
+    sessionId: session.id,
+    label: session.label,
+    status: session.status,
+    publishedAtUtc: session.lab.publishedAtUtc,
+    lab: session.lab,
+    recordedRun,
+  };
+}
+
+function sortEvidence(
+  evidence: readonly ObservatoryEvidence[],
+): ObservatoryEvidence[] {
+  return [...evidence].sort((left, right) =>
+    newestFirst(left.publishedAtUtc, right.publishedAtUtc)
+      || left.sessionId.localeCompare(right.sessionId));
+}
+
+export function buildObservatoryCatalog(
+  sourceSessions: readonly ObservationSessionSummary[],
+  laboratorySessions: readonly ObservationSessionSummary[],
+  limit = 100,
+): ObservatoryCatalog {
+  const safeLimit = boundedLimit(limit);
+  const sources = new Map<string, ObservationSessionSummary>();
+  for (const source of sourceSessions) {
+    if (source.lab !== null) {
+      throw new ObservatoryCatalogContractError(
+        `Каталог источников вернул LAB-сессию ${source.id}.`,
+      );
+    }
+    sources.set(source.id, source);
+  }
+
+  const linked = new Map<string, ObservatoryEvidence[]>();
+  const unresolvedEvidence: ObservatoryEvidence[] = [];
+  for (const laboratorySession of laboratorySessions) {
+    const evidence = evidenceFromSession(laboratorySession);
+    if (!evidence) continue;
+    const sourceId = evidence.lab.sourceSessionId;
+    if (!sources.has(sourceId)) {
+      // A bounded traversal may stop before this source. Absence alone is
+      // not proof of a broken relationship or permission to remove data.
+      unresolvedEvidence.push(evidence);
+      continue;
+    }
+    const current = linked.get(sourceId) ?? [];
+    current.push(evidence);
+    linked.set(sourceId, current);
+  }
+
+  const items = [...sources.values()]
+    .sort((left, right) =>
+      newestFirst(left.startedAtUtc, right.startedAtUtc)
+        || left.id.localeCompare(right.id))
+    .map((source) => ({
+      source,
+      evidence: sortEvidence(linked.get(source.id) ?? []),
+    }));
+
+  return {
+    items,
+    unresolvedEvidence: sortEvidence(unresolvedEvidence),
+    window: {
+      limit: safeLimit,
+      sourceCount: sourceSessions.length,
+      laboratoryCount: [...linked.values()].reduce((count, items) => count + items.length, 0)
+        + unresolvedEvidence.length,
+      sourceLimitReached: sourceSessions.length >= safeLimit,
+      laboratoryLimitReached: laboratorySessions.length >= safeLimit,
+    },
+  };
+}
+
+export async function fetchObservatoryCatalog({
+  signal,
+  limit = 100,
+  fetcher = globalThis.fetch,
+}: {
+  signal?: AbortSignal;
+  limit?: number;
+  fetcher?: ObservationSessionFetch;
+} = {}): Promise<ObservatoryCatalog> {
+  const safeLimit = boundedLimit(limit);
+  const request = new AbortController();
+  const abort = () => request.abort(signal?.reason);
+  if (signal?.aborted) abort();
+  else signal?.addEventListener("abort", abort, { once: true });
+  try {
+    const [sources, laboratories] = await Promise.all([
+      readCatalogPages("source", safeLimit, fetcher, request.signal),
+      readCatalogPages("laboratory", safeLimit, fetcher, request.signal),
+    ]);
+    const catalog = buildObservatoryCatalog(sources.items, laboratories.items, safeLimit);
+    return {
+      ...catalog,
+      window: {
+        ...catalog.window,
+        sourceLimitReached: sources.hasMore,
+        laboratoryLimitReached: laboratories.hasMore,
+      },
+    };
+  } finally {
+    request.abort();
+    signal?.removeEventListener("abort", abort);
+  }
+}
+
+// Metadata only, never recordings or result artifacts. The cap is an explicit
+// partial window, not silent completeness or an unbounded background crawler.
+const MAX_CATALOG_PAGES = 256;
+
+async function readCatalogPages(
+  scope: "source" | "laboratory",
+  limit: number,
+  fetcher: ObservationSessionFetch,
+  signal: AbortSignal,
+): Promise<{ items: ObservationSessionSummary[]; hasMore: boolean }> {
+  const items: ObservationSessionSummary[] = [];
+  const seenIds = new Set<string>();
+  const cursors = new Set<string>();
+  let cursor: string | null = null;
+  for (let index = 0; index < MAX_CATALOG_PAGES; index += 1) {
+    const page = await fetchObservationSessionCatalogPage({ scope, limit, cursor, signal, fetcher });
+    for (const item of page.items) {
+      if (seenIds.has(item.id)) {
+        throw new ObservatoryCatalogContractError("Каталог повторил сессию между страницами.");
+      }
+      seenIds.add(item.id);
+      // Do not accumulate legacy provenance while walking the shared catalog.
+      if (scope === "source" || item.lab?.replayCapability?.kind === "portable-result-review") {
+        items.push(item);
+      } else if (!item.lab) {
+        throw new ObservatoryCatalogContractError("LAB-каталог вернул исходную сессию.");
+      }
+    }
+    cursor = page.nextCursor;
+    if (cursor === null) return { items, hasMore: false };
+    if (cursors.has(cursor)) {
+      throw new ObservatoryCatalogContractError("Каталог повторил курсор страницы.");
+    }
+    cursors.add(cursor);
+  }
+  return { items, hasMore: true };
+}
@@ -0,0 +1,210 @@
+import type { ObservatoryRecordedRunBinding } from "./recordedRun";
+
+const SAFE_SESSION_ID = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/;
+const RENAME_SCHEMA = "missioncore.observatory-lab-projection-rename/v1";
+const PROJECTION_SCHEMA = "missioncore.observatory-lab-projection/v1";
+
+export type ObservatoryCatalogMutationFetch = (
+  input: RequestInfo | URL,
+  init?: RequestInit,
+) => Promise<Response>;
+
+export interface ObservatoryLabProjectionMutationResult {
+  readonly schemaVersion: typeof PROJECTION_SCHEMA;
+  readonly sessionId: string;
+  readonly displayName: string;
+}
+
+export class ObservatoryCatalogMutationError extends Error {
+  readonly status: number | null;
+
+  constructor(message: string, status: number | null = null) {
+    super(message);
+    this.name = "ObservatoryCatalogMutationError";
+    this.status = status;
+  }
+}
+
+export async function renameObservatoryLabProjection(
+  binding: ObservatoryRecordedRunBinding,
+  displayName: string,
+  {
+    signal,
+    fetcher = globalThis.fetch,
+  }: {
+    signal?: AbortSignal;
+    fetcher?: ObservatoryCatalogMutationFetch;
+  } = {},
+): Promise<ObservatoryLabProjectionMutationResult> {
+  const sessionId = admittedProjectionId(binding);
+  const normalizedName = displayName.trim();
+  if (normalizedName.length < 1 || normalizedName.length > 160) {
+    throw new ObservatoryCatalogMutationError(
+      "Название лабораторного результата должно содержать от 1 до 160 символов.",
+    );
+  }
+  const response = await request(
+    fetcher,
+    `/api/v1/observatory/lab-projections/${encodeURIComponent(sessionId)}`,
+    {
+      method: "PATCH",
+      headers: {
+        Accept: "application/json",
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({
+        schema_version: RENAME_SCHEMA,
+        display_name: normalizedName,
+      }),
+      signal,
+    },
+    "Не удалось переименовать лабораторный результат.",
+  );
+  const body = await responseBody(response);
+  if (!response.ok || response.status !== 200) {
+    throw apiError(
+      body,
+      `Переименование лабораторного результата вернуло HTTP ${response.status}.`,
+      response.status,
+    );
+  }
+  const decoded = decodeProjection(body);
+  if (decoded.sessionId !== sessionId || decoded.displayName !== normalizedName) {
+    throw new ObservatoryCatalogMutationError(
+      "Сервер не подтвердил точное переименование выбранного результата.",
+    );
+  }
+  return decoded;
+}
+
+export async function deleteObservatoryLabProjection(
+  binding: ObservatoryRecordedRunBinding,
+  {
+    signal,
+    fetcher = globalThis.fetch,
+  }: {
+    signal?: AbortSignal;
+    fetcher?: ObservatoryCatalogMutationFetch;
+  } = {},
+): Promise<void> {
+  const sessionId = admittedProjectionId(binding);
+  const response = await request(
+    fetcher,
+    `/api/v1/observatory/lab-projections/${encodeURIComponent(sessionId)}`,
+    {
+      method: "DELETE",
+      headers: { Accept: "application/json" },
+      signal,
+    },
+    "Не удалось удалить лабораторный результат из Обсерватории.",
+  );
+  const body = await responseBody(response);
+  if (!response.ok || response.status !== 204) {
+    throw apiError(
+      body,
+      `Удаление лабораторного результата вернуло HTTP ${response.status}.`,
+      response.status,
+    );
+  }
+  if (body !== undefined) {
+    throw new ObservatoryCatalogMutationError(
+      "Сервер вернул данные после подтверждённого удаления лабораторного результата.",
+    );
+  }
+}
+
+function admittedProjectionId(binding: ObservatoryRecordedRunBinding): string {
+  const sessionId = binding.evidenceSessionId;
+  const admittedViewer = (
+    binding.kind === "canonical-recorded-rerun"
+    && binding.viewerProfile === "recorded-session"
+    && binding.timeline === "session_time"
+  ) || (
+    binding.kind === "portable-result-review"
+    && binding.viewerProfile === "portable-result"
+    && binding.timeline === "result-defined"
+  );
+  if (
+    !admittedViewer
+    || binding.activation !== "explicit"
+    || binding.resultId !== sessionId
+    || binding.sourceSessionId === sessionId
+    || !SAFE_SESSION_ID.test(sessionId)
+  ) {
+    throw new ObservatoryCatalogMutationError(
+      "Выбранный результат не допущен к изменению каталога Обсерватории.",
+    );
+  }
+  return sessionId;
+}
+
+async function request(
+  fetcher: ObservatoryCatalogMutationFetch,
+  input: string,
+  init: RequestInit,
+  fallback: string,
+): Promise<Response> {
+  try {
+    return await fetcher(input, init);
+  } catch (error) {
+    if (error instanceof DOMException && error.name === "AbortError") throw error;
+    throw new ObservatoryCatalogMutationError(fallback);
+  }
+}
+
+async function responseBody(response: Response): Promise<unknown> {
+  const text = await response.text();
+  if (!text) return undefined;
+  try {
+    return JSON.parse(text) as unknown;
+  } catch {
+    return text;
+  }
+}
+
+function apiError(body: unknown, fallback: string, status: number): Error {
+  if (isRecord(body) && typeof body.detail === "string" && body.detail.trim()) {
+    return new ObservatoryCatalogMutationError(body.detail.trim(), status);
+  }
+  if (typeof body === "string" && body.trim()) {
+    return new ObservatoryCatalogMutationError(body.trim(), status);
+  }
+  return new ObservatoryCatalogMutationError(fallback, status);
+}
+
+function decodeProjection(value: unknown): ObservatoryLabProjectionMutationResult {
+  if (!isRecord(value)) {
+    throw new ObservatoryCatalogMutationError(
+      "Сервер вернул некорректное подтверждение лабораторного результата.",
+    );
+  }
+  const keys = Object.keys(value).sort();
+  const expected = ["display_name", "schema_version", "session_id"];
+  if (keys.length !== expected.length || keys.some((key, index) => key !== expected[index])) {
+    throw new ObservatoryCatalogMutationError(
+      "Подтверждение лабораторного результата содержит неизвестные поля.",
+    );
+  }
+  if (
+    value.schema_version !== PROJECTION_SCHEMA
+    || typeof value.session_id !== "string"
+    || !SAFE_SESSION_ID.test(value.session_id)
+    || typeof value.display_name !== "string"
+    || value.display_name.trim() !== value.display_name
+    || value.display_name.length < 1
+    || value.display_name.length > 160
+  ) {
+    throw new ObservatoryCatalogMutationError(
+      "Сервер вернул неподдерживаемый контракт лабораторного результата.",
+    );
+  }
+  return {
+    schemaVersion: PROJECTION_SCHEMA,
+    sessionId: value.session_id,
+    displayName: value.display_name,
+  };
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
@@ -0,0 +1,104 @@
+import type { SceneSettings } from "../../sceneSettings";
+
+const PROFILE_SCHEMA = "missioncore.observatory-lab-view-profile/v1";
+
+export async function fetchLabViewProfile(
+  resultId: string,
+  signal?: AbortSignal,
+): Promise<SceneSettings | null> {
+  const response = await fetch(`/api/v1/observatory/lab-view-profiles/${encodeURIComponent(resultId)}`, {
+    headers: { Accept: "application/json" },
+    signal,
+  });
+  if (response.status === 404) return null;
+  const body: unknown = await response.json();
+  if (!response.ok) throw new Error("Профиль отображения LAB не загрузился.");
+  return decodeProfile(body, resultId);
+}
+
+export async function saveLabViewProfile(
+  resultId: string,
+  settings: SceneSettings,
+  signal?: AbortSignal,
+): Promise<SceneSettings> {
+  const response = await fetch(`/api/v1/observatory/lab-view-profiles/${encodeURIComponent(resultId)}`, {
+    method: "PUT",
+    headers: { Accept: "application/json", "Content-Type": "application/json" },
+    body: JSON.stringify({
+      schema_version: PROFILE_SCHEMA,
+      result_id: resultId,
+      scene_settings: {
+        point_size: settings.pointSize,
+        accumulation_seconds: settings.accumulationSeconds,
+        color_mode: settings.colorMode,
+        palette: settings.palette,
+        show_grid: settings.showGrid,
+        show_labels: settings.showLabels,
+        show_camera_frustums: settings.showCameraFrustums,
+      },
+    }),
+    signal,
+  });
+  const body: unknown = await response.json();
+  if (!response.ok) throw new Error("Настройки LAB не сохранились. Повторите закрытие окна.");
+  return decodeProfile(body, resultId);
+}
+
+function decodeProfile(value: unknown, expectedResultId: string): SceneSettings {
+  const row = record(value);
+  exactKeys(row, ["result_id", "scene_settings", "schema_version", "updated_at_utc"]);
+  if (row.schema_version !== PROFILE_SCHEMA || row.result_id !== expectedResultId) {
+    throw new Error("Сервер вернул профиль другой LAB.");
+  }
+  const settings = record(row.scene_settings);
+  exactKeys(settings, [
+    "accumulation_seconds", "color_mode", "palette", "point_size",
+    "show_camera_frustums", "show_grid", "show_labels",
+  ]);
+  const pointSize = finite(settings.point_size);
+  const accumulationSeconds = finite(settings.accumulation_seconds);
+  const colorMode = settings.color_mode;
+  const palette = settings.palette;
+  if (
+    pointSize < 0.1
+    || accumulationSeconds < 0
+    || !new Set(["intensity", "height", "distance", "rgb", "class"]).has(String(colorMode))
+    || !new Set(["turbo", "viridis", "plasma", "grayscale"]).has(String(palette))
+    || typeof settings.show_grid !== "boolean"
+    || typeof settings.show_labels !== "boolean"
+    || typeof settings.show_camera_frustums !== "boolean"
+  ) throw new Error("Сервер вернул повреждённый профиль LAB.");
+  return {
+    projection: "3d",
+    pointSize,
+    colorMode: colorMode as SceneSettings["colorMode"],
+    palette: palette as SceneSettings["palette"],
+    customColor: "#35d7c1",
+    accumulationSeconds,
+    showPoints: true,
+    showTrajectory: true,
+    showGrid: settings.show_grid,
+    showLabels: settings.show_labels,
+    showCameraFrustums: settings.show_camera_frustums,
+  };
+}
+
+function record(value: unknown): Record<string, unknown> {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error("Некорректный профиль отображения LAB.");
+  }
+  return value as Record<string, unknown>;
+}
+
+function finite(value: unknown): number {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    throw new Error("Некорректное числовое значение профиля LAB.");
+  }
+  return value;
+}
+
+function exactKeys(value: Record<string, unknown>, expected: string[]): void {
+  if (Object.keys(value).sort().join() !== [...expected].sort().join()) {
+    throw new Error("Контракт профиля отображения LAB изменился.");
+  }
+}
@@ -0,0 +1,449 @@
+export { fetchObservatoryPortableLaboratorySetups } from "./portableLaboratorySetups";
+
+const CATALOG_SCHEMA = "missioncore.observatory-laboratory-setup-catalog/v1";
+const PREFLIGHT_REQUEST_SCHEMA = "missioncore.observatory-run-preflight-request/v1";
+const PREFLIGHT_SCHEMA = "missioncore.observatory-run-preflight/v1";
+const SHA256 = /^[a-f0-9]{64}$/;
+
+export type ObservatoryLaboratorySetupOrigin =
+  | "archived-definition"
+  | "existing-result"
+  | "portable-definition";
+export type ObservatoryLaboratorySetupAction =
+  | "open-existing"
+  | "open-legacy"
+  | "check"
+  | "blocked";
+
+export interface ObservatoryLaboratoryRunDefinition {
+  readonly definitionId: string;
+  readonly version: number;
+  readonly workId: string | null;
+  readonly definitionSha256: string;
+  readonly resultSchema: string | null;
+  readonly resultKind: string | null;
+  readonly models: readonly {
+    readonly name: string;
+    readonly releaseId: string;
+    readonly modelId: string;
+    readonly architecture: string;
+  }[];
+  readonly configuration: readonly {
+    readonly role: string;
+    readonly sha256: string;
+  }[];
+}
+
+export interface ObservatoryLaboratoryPreservedResult {
+  readonly resultId: string;
+  readonly resultKind: string;
+  readonly relation: string;
+  readonly access: "legacy-lab" | "observatory" | "evidence-only";
+  readonly createdAtUtc: string;
+  readonly observatoryProjectionAvailable: boolean;
+}
+
+export interface ObservatoryLaboratorySetup {
+  readonly setupId: string;
+  readonly displayName: string;
+  readonly description: string;
+  readonly origin: ObservatoryLaboratorySetupOrigin;
+  readonly runDefinition: ObservatoryLaboratoryRunDefinition | null;
+  readonly compatibility: {
+    readonly compatible: boolean;
+    readonly reasons: readonly { readonly code: string; readonly message: string }[];
+  };
+  readonly executor: {
+    readonly contourId: string;
+    readonly state: "not-installed" | "ready";
+    readonly reasonCode: string;
+    readonly reason: string;
+  };
+  readonly preservedResults: readonly ObservatoryLaboratoryPreservedResult[];
+  readonly preflight: {
+    readonly outcome: "existing" | "ready" | "blocked";
+    readonly action: ObservatoryLaboratorySetupAction;
+    readonly reason: string;
+    readonly submissionAllowed: boolean;
+    readonly existingResultIds: readonly string[];
+  };
+}
+
+export interface ObservatoryLaboratorySetupCatalog {
+  readonly sourceSessionId: string;
+  readonly setups: readonly ObservatoryLaboratorySetup[];
+}
+
+// Cache identity is verified by the portable catalog decoder/server, never by a LAB label.
+export function selectableObservatorySetups(catalog: ObservatoryLaboratorySetupCatalog | null) {
+  return catalog?.setups.filter((setup) => (
+    setup.origin === "portable-definition"
+    && setup.runDefinition !== null
+    && setup.compatibility.compatible
+    && setup.preflight.outcome !== "existing"
+  )) ?? [];
+}
+
+export interface ObservatoryLaboratoryRunPreflight {
+  readonly sourceSessionId: string;
+  readonly setupId: string;
+  readonly definitionSha256: string | null;
+  readonly checkSha256: string | null;
+  readonly outcome: "existing" | "queueable" | "blocked";
+  readonly submissionAllowed: boolean;
+  readonly checks: readonly {
+    readonly checkId: string;
+    readonly outcome: "pass" | "fail" | "not-applicable";
+    readonly reasonCode: string;
+    readonly message: string;
+  }[];
+  readonly existingResultIds: readonly string[];
+}
+
+export type ObservatoryLaboratorySetupFetch = (
+  input: RequestInfo | URL,
+  init?: RequestInit,
+) => Promise<Response>;
+
+export class ObservatoryLaboratorySetupContractError extends Error {
+  readonly status: number | null;
+
+  constructor(message: string, status: number | null = null) {
+    super(message);
+    this.name = "ObservatoryLaboratorySetupContractError";
+    this.status = status;
+  }
+}
+
+export async function fetchObservatoryLaboratorySetups(
+  sourceSessionId: string,
+  {
+    signal,
+    fetcher = globalThis.fetch,
+  }: {
+    signal?: AbortSignal;
+    fetcher?: ObservatoryLaboratorySetupFetch;
+  } = {},
+): Promise<ObservatoryLaboratorySetupCatalog> {
+  const response = await request(
+    fetcher,
+    `/api/v1/observatory/laboratory-setups?source_session_id=${encodeURIComponent(sourceSessionId)}`,
+    { method: "GET", headers: { Accept: "application/json" }, signal },
+  );
+  const body = await responseBody(response);
+  if (!response.ok) throw apiError(body, response.status);
+  const catalog = decodeCatalog(body);
+  if (catalog.sourceSessionId !== sourceSessionId) {
+    throw new ObservatoryLaboratorySetupContractError(
+      "Каталог сетапов относится к другой исходной сессии.",
+    );
+  }
+  return catalog;
+}
+
+export async function preflightObservatoryLaboratorySetup(
+  sourceSessionId: string,
+  setup: ObservatoryLaboratorySetup,
+  {
+    signal,
+    fetcher = globalThis.fetch,
+  }: {
+    signal?: AbortSignal;
+    fetcher?: ObservatoryLaboratorySetupFetch;
+  } = {},
+): Promise<ObservatoryLaboratoryRunPreflight> {
+  const response = await request(
+    fetcher,
+    "/api/v1/observatory/run-preflights",
+    {
+      method: "POST",
+      headers: { Accept: "application/json", "Content-Type": "application/json" },
+      body: JSON.stringify({
+        schema_version: PREFLIGHT_REQUEST_SCHEMA,
+        source_session_id: sourceSessionId,
+        setup_id: setup.setupId,
+        definition_sha256: setup.runDefinition?.definitionSha256 ?? null,
+      }),
+      signal,
+    },
+  );
+  const body = await responseBody(response);
+  if (!response.ok) throw apiError(body, response.status);
+  const preflight = decodePreflight(body);
+  if (preflight.sourceSessionId !== sourceSessionId || preflight.setupId !== setup.setupId) {
+    throw new ObservatoryLaboratorySetupContractError(
+      "Preflight относится к другому источнику или сетапу.",
+    );
+  }
+  if (preflight.definitionSha256 !== (setup.runDefinition?.definitionSha256 ?? null)) {
+    throw new ObservatoryLaboratorySetupContractError(
+      "Preflight относится к другой версии сетапа.",
+    );
+  }
+  return preflight;
+}
+
+function decodeCatalog(value: unknown): ObservatoryLaboratorySetupCatalog {
+  const row = record(value, "каталог сетапов");
+  exactKeys(row, ["authority", "schema_version", "setups", "source_session_id"], "каталог сетапов");
+  exact(row.schema_version, CATALOG_SCHEMA, "schema_version каталога сетапов");
+  observationAuthority(row.authority);
+  return {
+    sourceSessionId: text(row.source_session_id, "source_session_id"),
+    setups: array(row.setups, "setups").map(decodeSetup),
+  };
+}
+
+function decodeSetup(value: unknown): ObservatoryLaboratorySetup {
+  const row = record(value, "сетап");
+  exactKeys(row, [
+    "authority", "compatibility", "description", "display_name", "executor", "origin",
+    "preflight", "preserved_results", "run_definition", "setup_id", "source",
+  ], "сетап");
+  observationAuthority(row.authority);
+  const origin = oneOf(row.origin, ["archived-definition", "existing-result"] as const, "origin");
+  const compatibility = record(row.compatibility, "compatibility");
+  const executor = record(row.executor, "executor");
+  const preflight = record(row.preflight, "preflight");
+  const source = record(row.source, "source");
+  const runDefinition = row.run_definition === null
+    ? null
+    : decodeRunDefinition(row.run_definition);
+  if ((origin === "archived-definition") !== (runDefinition !== null)) {
+    throw new ObservatoryLaboratorySetupContractError(
+      "Происхождение сетапа не совпадает с RunDefinition.",
+    );
+  }
+  exactKeys(source, ["label", "required_modalities", "session_id"], "source");
+  text(source.session_id, "source.session_id");
+  text(source.label, "source.label");
+  array(source.required_modalities, "source.required_modalities").forEach((item) => text(item, "source modality"));
+  exactKeys(compatibility, ["compatible", "reasons"], "compatibility");
+  exactKeys(executor, ["contour_id", "reason", "reason_code", "state"], "executor");
+  exactKeys(preflight, ["action", "existing_result_ids", "outcome", "reason", "submission_allowed"], "preflight");
+  return {
+    setupId: text(row.setup_id, "setup_id"),
+    displayName: text(row.display_name, "display_name"),
+    description: text(row.description, "description"),
+    origin,
+    runDefinition,
+    compatibility: {
+      compatible: boolean(row.compatibility && compatibility.compatible, "compatible"),
+      reasons: array(compatibility.reasons, "compatibility.reasons").map((item) => {
+        const reason = record(item, "compatibility reason");
+        exactKeys(reason, ["code", "message"], "compatibility reason");
+        return { code: text(reason.code, "reason.code"), message: text(reason.message, "reason.message") };
+      }),
+    },
+    executor: {
+      contourId: text(executor.contour_id, "executor.contour_id"),
+      state: exact(executor.state, "not-installed", "executor.state"),
+      reasonCode: text(executor.reason_code, "executor.reason_code"),
+      reason: text(executor.reason, "executor.reason"),
+    },
+    preservedResults: array(row.preserved_results, "preserved_results").map(decodePreservedResult),
+    preflight: {
+      outcome: oneOf(preflight.outcome, ["existing", "blocked"] as const, "preflight.outcome"),
+      action: oneOf(preflight.action, ["open-existing", "open-legacy", "blocked"] as const, "preflight.action"),
+      reason: text(preflight.reason, "preflight.reason"),
+      submissionAllowed: exact(preflight.submission_allowed, false, "preflight.submission_allowed"),
+      existingResultIds: array(preflight.existing_result_ids, "preflight.existing_result_ids").map((item) => text(item, "existing result id")),
+    },
+  };
+}
+
+function decodeRunDefinition(value: unknown): ObservatoryLaboratoryRunDefinition {
+  const row = record(value, "RunDefinition");
+  exactKeys(row, [
+    "authority", "configuration", "definition_id", "definition_sha256", "schema_version",
+    "source", "version", "work_id",
+  ], "RunDefinition");
+  exact(row.schema_version, "missioncore.observatory-run-definition/v1", "RunDefinition schema");
+  observationAuthority(row.authority);
+  const source = record(row.source, "RunDefinition source");
+  exactKeys(source, ["label", "required_modalities", "session_id"], "RunDefinition source");
+  text(source.session_id, "RunDefinition source.session_id");
+  text(source.label, "RunDefinition source.label");
+  array(source.required_modalities, "RunDefinition source.required_modalities")
+    .forEach((item) => text(item, "RunDefinition source modality"));
+  const digest = text(row.definition_sha256, "definition_sha256");
+  if (!SHA256.test(digest)) throw new ObservatoryLaboratorySetupContractError("Некорректный digest RunDefinition.");
+  return {
+    definitionId: text(row.definition_id, "definition_id"),
+    version: positiveInteger(row.version, "definition version"),
+    workId: text(row.work_id, "work_id"),
+    definitionSha256: digest,
+    resultSchema: null,
+    resultKind: null,
+    models: [],
+    configuration: array(row.configuration, "configuration").map((item) => {
+      const reference = record(item, "configuration reference");
+      exactKeys(reference, ["role", "sha256"], "configuration reference");
+      const sha256 = text(reference.sha256, "configuration sha256");
+      if (!SHA256.test(sha256)) throw new ObservatoryLaboratorySetupContractError("Некорректный digest конфигурации.");
+      return { role: text(reference.role, "configuration role"), sha256 };
+    }),
+  };
+}
+
+function decodePreservedResult(value: unknown): ObservatoryLaboratoryPreservedResult {
+  const row = record(value, "preserved result");
+  exactKeys(row, [
+    "access", "created_at_utc", "observatory_projection_available", "relation",
+    "result_id", "result_kind",
+  ], "preserved result");
+  return {
+    resultId: text(row.result_id, "result_id"),
+    resultKind: text(row.result_kind, "result_kind"),
+    relation: text(row.relation, "relation"),
+    access: oneOf(row.access, ["legacy-lab", "observatory", "evidence-only"] as const, "result access"),
+    createdAtUtc: text(row.created_at_utc, "created_at_utc"),
+    observatoryProjectionAvailable: boolean(row.observatory_projection_available, "observatory projection availability"),
+  };
+}
+
+function decodePreflight(value: unknown): ObservatoryLaboratoryRunPreflight {
+  const row = record(value, "preflight");
+  const baseKeys = [
+    "authority", "checks", "definition_sha256", "executor", "existing_result_ids",
+    "outcome", "schema_version", "setup_id", "source_session_id", "submission_allowed",
+  ] as const;
+  const hasPortableCheck = Object.hasOwn(row, "check_sha256");
+  exactKeys(
+    row,
+    hasPortableCheck ? [...baseKeys, "check_sha256"] : baseKeys,
+    "preflight",
+  );
+  exact(row.schema_version, PREFLIGHT_SCHEMA, "preflight schema");
+  observationAuthority(row.authority);
+  const digest = row.definition_sha256;
+  if (digest !== null && (typeof digest !== "string" || !SHA256.test(digest))) {
+    throw new ObservatoryLaboratorySetupContractError("Некорректный digest preflight.");
+  }
+  const checkDigest = hasPortableCheck ? row.check_sha256 : null;
+  if (
+    checkDigest !== null
+    && (typeof checkDigest !== "string" || !SHA256.test(checkDigest))
+  ) {
+    throw new ObservatoryLaboratorySetupContractError(
+      "Некорректный check digest preflight.",
+    );
+  }
+  const outcome = oneOf(
+    row.outcome,
+    ["existing", "queueable", "blocked"] as const,
+    "preflight outcome",
+  );
+  const submissionAllowed = boolean(
+    row.submission_allowed,
+    "preflight submission_allowed",
+  );
+  if (
+    submissionAllowed !== (outcome === "queueable")
+    || (hasPortableCheck && outcome === "queueable" && checkDigest === null)
+  ) {
+    throw new ObservatoryLaboratorySetupContractError(
+      "Preflight содержит противоречивое разрешение постановки в очередь.",
+    );
+  }
+  return {
+    sourceSessionId: text(row.source_session_id, "preflight source_session_id"),
+    setupId: text(row.setup_id, "preflight setup_id"),
+    definitionSha256: digest,
+    checkSha256: checkDigest,
+    outcome,
+    submissionAllowed,
+    checks: array(row.checks, "preflight checks").map((item) => {
+      const check = record(item, "preflight check");
+      exactKeys(check, ["check_id", "message", "outcome", "reason_code"], "preflight check");
+      return {
+        checkId: text(check.check_id, "check_id"),
+        outcome: oneOf(check.outcome, ["pass", "fail", "not-applicable"] as const, "check outcome"),
+        reasonCode: text(check.reason_code, "check reason_code"),
+        message: text(check.message, "check message"),
+      };
+    }),
+    existingResultIds: array(row.existing_result_ids, "existing_result_ids").map((item) => text(item, "existing result id")),
+  };
+}
+
+function observationAuthority(value: unknown): void {
+  const row = record(value, "authority");
+  const keys = ["commands_enabled", "actuation_allowed", "navigation_or_safety_accepted", "production_accepted"];
+  exactKeys(row, keys, "authority");
+  for (const key of keys) {
+    exact(row[key], false, `authority.${key}`);
+  }
+}
+
+async function request(fetcher: ObservatoryLaboratorySetupFetch, input: string, init: RequestInit): Promise<Response> {
+  try {
+    return await fetcher(input, init);
+  } catch (error) {
+    if (error instanceof DOMException && error.name === "AbortError") throw error;
+    throw new ObservatoryLaboratorySetupContractError("Каталог сетапов недоступен.");
+  }
+}
+
+async function responseBody(response: Response): Promise<unknown> {
+  const textBody = await response.text();
+  if (!textBody) return undefined;
+  try { return JSON.parse(textBody) as unknown; } catch { return textBody; }
+}
+
+function apiError(body: unknown, status: number): ObservatoryLaboratorySetupContractError {
+  const detail = body && typeof body === "object" && !Array.isArray(body)
+    ? (body as Record<string, unknown>).detail
+    : null;
+  return new ObservatoryLaboratorySetupContractError(
+    typeof detail === "string" && detail.trim() ? detail : `Observatory API вернул HTTP ${status}.`,
+    status,
+  );
+}
+
+function record(value: unknown, label: string): Record<string, unknown> {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new ObservatoryLaboratorySetupContractError(`${label}: ожидался объект.`);
+  }
+  return value as Record<string, unknown>;
+}
+
+function array(value: unknown, label: string): unknown[] {
+  if (!Array.isArray(value)) throw new ObservatoryLaboratorySetupContractError(`${label}: ожидался массив.`);
+  return value;
+}
+
+function text(value: unknown, label: string): string {
+  if (typeof value !== "string" || !value.trim()) throw new ObservatoryLaboratorySetupContractError(`${label}: ожидался текст.`);
+  return value;
+}
+
+function boolean(value: unknown, label: string): boolean {
+  if (typeof value !== "boolean") throw new ObservatoryLaboratorySetupContractError(`${label}: ожидался boolean.`);
+  return value;
+}
+
+function positiveInteger(value: unknown, label: string): number {
+  if (!Number.isInteger(value) || Number(value) < 1) throw new ObservatoryLaboratorySetupContractError(`${label}: ожидалось положительное целое.`);
+  return Number(value);
+}
+
+function exact<T>(value: unknown, expected: T, label: string): T {
+  if (value !== expected) throw new ObservatoryLaboratorySetupContractError(`${label}: значение изменилось.`);
+  return expected;
+}
+
+function oneOf<const T extends readonly string[]>(value: unknown, allowed: T, label: string): T[number] {
+  if (typeof value !== "string" || !allowed.includes(value)) {
+    throw new ObservatoryLaboratorySetupContractError(`${label}: значение не поддерживается.`);
+  }
+  return value as T[number];
+}
+
+function exactKeys(value: Record<string, unknown>, expected: readonly string[], label: string): void {
+  const actual = Object.keys(value).sort();
+  const sortedExpected = [...expected].sort();
+  if (actual.length !== sortedExpected.length || actual.some((key, index) => key !== sortedExpected[index])) {
+    throw new ObservatoryLaboratorySetupContractError(`${label}: обнаружены неизвестные поля.`);
+  }
+}
@@ -0,0 +1,373 @@
+import type {
+  ObservatoryLaboratoryPreservedResult,
+  ObservatoryLaboratoryRunDefinition,
+  ObservatoryLaboratorySetup,
+  ObservatoryLaboratorySetupCatalog,
+} from "./laboratorySetups";
+
+const PORTABLE_CATALOG_SCHEMA = "missioncore.observatory-portable-setup-catalog/v2";
+const SHA256 = /^[a-f0-9]{64}$/;
+
+export class ObservatoryPortableSetupDecodeError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "ObservatoryPortableSetupDecodeError";
+  }
+}
+
+export function decodePortableCatalog(value: unknown): ObservatoryLaboratorySetupCatalog {
+  const row = record(value, "portable-каталог сетапов");
+  exactKeys(
+    row,
+    ["authority", "schema_version", "setups", "source_session_id"],
+    "portable-каталог сетапов",
+  );
+  exact(row.schema_version, PORTABLE_CATALOG_SCHEMA, "schema_version portable-каталога");
+  observationAuthority(row.authority);
+  const sourceSessionId = text(row.source_session_id, "portable source_session_id");
+  return {
+    sourceSessionId,
+    setups: array(row.setups, "portable setups").map((item) => decodePortableSetup(item, sourceSessionId)),
+  };
+}
+
+function decodePortableSetup(value: unknown, sourceSessionId: string): ObservatoryLaboratorySetup {
+  const row = record(value, "portable-сетап");
+  exactKeys(row, [
+    "authority", "description", "display_name", "executor", "existing_results",
+    "origin", "preflight", "run_definition", "setup_id", "source_compatibility",
+    "source_requirements",
+  ], "portable-сетап");
+  exact(row.origin, "portable-definition", "portable origin");
+  observationAuthority(row.authority);
+  decodePortableSourceRequirements(row.source_requirements);
+  const setupId = text(row.setup_id, "portable setup_id");
+  const runDefinition = decodePortableRunDefinition(row.run_definition);
+
+  const compatibility = record(row.source_compatibility, "portable source_compatibility");
+  exactKeys(
+    compatibility,
+    ["compatible", "outcome", "reason", "reason_code"],
+    "portable source_compatibility",
+  );
+  const compatible = boolean(compatibility.compatible, "portable compatible");
+  exact(
+    compatibility.outcome,
+    compatible ? "pass" : "blocked",
+    "portable compatibility outcome",
+  );
+  const compatibilityReason = text(compatibility.reason, "portable compatibility reason");
+  const compatibilityReasonCode = text(
+    compatibility.reason_code,
+    "portable compatibility reason_code",
+  );
+
+  const executor = record(row.executor, "portable executor");
+  exactKeys(
+    executor,
+    ["contour_id", "ready", "reason", "reason_code", "state"],
+    "portable executor",
+  );
+  const executorState = oneOf(
+    executor.state,
+    ["not-installed", "ready"] as const,
+    "portable executor state",
+  );
+  const executorReady = boolean(executor.ready, "portable executor ready");
+  if (executorReady !== (executorState === "ready")) {
+    throw new ObservatoryPortableSetupDecodeError(
+      "Portable executor: состояние готовности противоречиво.",
+    );
+  }
+  const executorReason = executor.reason === null
+    ? "Исполнитель установлен."
+    : text(executor.reason, "portable executor reason");
+  const executorReasonCode = executor.reason_code === null
+    ? "portable-executor-ready"
+    : text(executor.reason_code, "portable executor reason_code");
+  if (
+    (executorReady && (executor.reason !== null || executor.reason_code !== null))
+    || (!executorReady && (executor.reason === null || executor.reason_code === null))
+  ) {
+    throw new ObservatoryPortableSetupDecodeError(
+      "Portable executor: причина недоступности противоречит состоянию.",
+    );
+  }
+
+  const preflight = record(row.preflight, "portable preflight");
+  exactKeys(preflight, [
+    "action", "existing_result_ids", "outcome", "reason", "submission_allowed",
+  ], "portable preflight");
+  const preflightOutcome = oneOf(
+    preflight.outcome,
+    ["existing", "ready", "blocked"] as const,
+    "portable preflight outcome",
+  );
+  const preflightAction = oneOf(
+    preflight.action,
+    ["open-existing", "check", "blocked"] as const,
+    "portable preflight action",
+  );
+  const submissionAllowed = boolean(
+    preflight.submission_allowed,
+    "portable preflight submission_allowed",
+  );
+  if (
+    submissionAllowed !== (preflightOutcome === "ready")
+    || (preflightOutcome === "ready" && preflightAction !== "check")
+    || (preflightOutcome === "blocked" && preflightAction !== "blocked")
+    || (preflightOutcome === "existing" && preflightAction !== "open-existing")
+    || (submissionAllowed && (!compatible || !executorReady))
+  ) {
+    throw new ObservatoryPortableSetupDecodeError(
+      "Portable preflight: состояние запуска противоречиво.",
+    );
+  }
+  const existingResults = array(row.existing_results, "portable existing_results").map(
+    (item) => decodePortableResult(item, sourceSessionId, setupId, runDefinition),
+  );
+  const existingResultIds = array(
+    preflight.existing_result_ids,
+    "portable existing_result_ids",
+  ).map((item) => text(item, "portable existing result id"));
+  if (
+    (existingResults.length > 0) !== (preflightOutcome === "existing")
+    || existingResultIds.length !== existingResults.length
+    || new Set(existingResultIds).size !== existingResultIds.length
+    || existingResults.some((result, index) => result.resultId !== existingResultIds[index])
+  ) {
+    throw new ObservatoryPortableSetupDecodeError(
+      "Portable result: готовность не соответствует проверенным результатам.",
+    );
+  }
+
+  return {
+    setupId,
+    displayName: text(row.display_name, "portable display_name"),
+    description: text(row.description, "portable description"),
+    origin: "portable-definition",
+    runDefinition,
+    compatibility: {
+      compatible,
+      reasons: compatible
+        ? []
+        : [{ code: compatibilityReasonCode, message: compatibilityReason }],
+    },
+    executor: {
+      contourId: text(executor.contour_id, "portable executor contour_id"),
+      state: executorState,
+      reasonCode: executorReasonCode,
+      reason: executorReason,
+    },
+    preservedResults: existingResults,
+    preflight: {
+      outcome: preflightOutcome,
+      action: preflightAction,
+      reason: text(preflight.reason, "portable preflight reason"),
+      submissionAllowed,
+      existingResultIds,
+    },
+  };
+}
+
+function decodePortableResult(
+  value: unknown, sourceSessionId: string, setupId: string,
+  definition: ObservatoryLaboratoryRunDefinition,
+): ObservatoryLaboratoryPreservedResult {
+  const row = record(value, "portable result");
+  exactKeys(row, [
+    "result_id", "result_kind", "relation", "access", "created_at_utc",
+    "observatory_projection_available", "identity",
+  ], "portable result");
+  exact(row.result_kind, definition.resultKind, "portable result kind");
+  exact(row.relation, "exact-recorded-computation", "portable result relation");
+  exact(row.access, "observatory", "portable result access");
+  exact(row.observatory_projection_available, true, "portable result availability");
+  const identity = record(row.identity, "portable result identity");
+  exactKeys(identity, [
+    "job_id", "source_session_id", "source_catalog_sha256", "source_bundle_sha256",
+    "source_capability_manifest_sha256", "setup_id", "definition_sha256",
+    "package_sha256", "artifact_manifest_id",
+  ], "portable result identity");
+  exact(identity.source_session_id, sourceSessionId, "portable result source");
+  exact(identity.setup_id, setupId, "portable result setup");
+  exact(identity.definition_sha256, definition.definitionSha256, "portable result definition");
+  text(identity.job_id, "portable result job");
+  for (const key of [
+    "source_catalog_sha256", "source_bundle_sha256", "source_capability_manifest_sha256",
+    "definition_sha256", "package_sha256", "artifact_manifest_id",
+  ]) {
+    if (!SHA256.test(text(identity[key], `portable result ${key}`))) {
+      throw new ObservatoryPortableSetupDecodeError(`Portable result: некорректный ${key}.`);
+    }
+  }
+  return {
+    resultId: text(row.result_id, "portable result id"),
+    resultKind: text(row.result_kind, "portable result kind"),
+    relation: "exact-recorded-computation",
+    access: "observatory",
+    createdAtUtc: text(row.created_at_utc, "portable result created_at_utc"),
+    observatoryProjectionAvailable: true,
+  };
+}
+
+function decodePortableSourceRequirements(value: unknown): void {
+  const row = record(value, "portable source_requirements");
+  exactKeys(row, [
+    "archive_id", "calibration_identity_sha256", "calibration_slot", "camera_height",
+    "camera_semantic_channel_id", "camera_source_id", "camera_width",
+    "exactly_one_media_epoch", "plugin_id", "recorded_media_init_sha256",
+    "recorded_media_type", "required_modalities", "seekable",
+  ], "portable source_requirements");
+  for (const key of [
+    "archive_id", "calibration_slot", "camera_semantic_channel_id", "camera_source_id",
+    "plugin_id", "recorded_media_type",
+  ]) text(row[key], `portable source_requirements.${key}`);
+  for (const key of ["calibration_identity_sha256", "recorded_media_init_sha256"]) {
+    const digest = text(row[key], `portable source_requirements.${key}`);
+    if (!SHA256.test(digest)) {
+      throw new ObservatoryPortableSetupDecodeError(
+        `portable source_requirements.${key}: некорректный digest.`,
+      );
+    }
+  }
+  positiveInteger(row.camera_width, "portable camera_width");
+  positiveInteger(row.camera_height, "portable camera_height");
+  exact(row.exactly_one_media_epoch, true, "portable exactly_one_media_epoch");
+  exact(row.seekable, true, "portable seekable");
+  array(row.required_modalities, "portable required_modalities")
+    .forEach((item) => text(item, "portable required modality"));
+}
+
+function decodePortableRunDefinition(value: unknown): ObservatoryLaboratoryRunDefinition {
+  const row = record(value, "portable RunDefinition");
+  exactKeys(row, [
+    "definition_id", "definition_sha256", "models", "result_kind", "result_schema",
+    "version",
+  ], "portable RunDefinition");
+  const digest = text(row.definition_sha256, "portable definition_sha256");
+  if (!SHA256.test(digest)) {
+    throw new ObservatoryPortableSetupDecodeError(
+      "Portable RunDefinition: некорректный digest.",
+    );
+  }
+  return {
+    definitionId: text(row.definition_id, "portable definition_id"),
+    version: positiveInteger(row.version, "portable definition version"),
+    workId: null,
+    definitionSha256: digest,
+    resultSchema: text(row.result_schema, "portable result_schema"),
+    resultKind: text(row.result_kind, "portable result_kind"),
+    models: array(row.models, "portable models").map((item) => {
+      const model = record(item, "portable model");
+      exactKeys(
+        model,
+        ["architecture", "model_id", "name", "release_id"],
+        "portable model",
+      );
+      return {
+        name: text(model.name, "portable model name"),
+        releaseId: text(model.release_id, "portable model release_id"),
+        modelId: text(model.model_id, "portable model model_id"),
+        architecture: text(model.architecture, "portable model architecture"),
+      };
+    }),
+    configuration: [],
+  };
+}
+
+function observationAuthority(value: unknown): void {
+  const row = record(value, "authority");
+  const keys = [
+    "commands_enabled",
+    "actuation_allowed",
+    "navigation_or_safety_accepted",
+    "production_accepted",
+  ];
+  exactKeys(row, keys, "authority");
+  for (const key of keys) exact(row[key], false, `authority.${key}`);
+}
+
+function record(value: unknown, label: string): Record<string, unknown> {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new ObservatoryPortableSetupDecodeError(
+      `${label}: ожидался объект.`,
+    );
+  }
+  return value as Record<string, unknown>;
+}
+
+function array(value: unknown, label: string): unknown[] {
+  if (!Array.isArray(value)) {
+    throw new ObservatoryPortableSetupDecodeError(
+      `${label}: ожидался массив.`,
+    );
+  }
+  return value;
+}
+
+function text(value: unknown, label: string): string {
+  if (typeof value !== "string" || !value.trim()) {
+    throw new ObservatoryPortableSetupDecodeError(
+      `${label}: ожидался текст.`,
+    );
+  }
+  return value;
+}
+
+function boolean(value: unknown, label: string): boolean {
+  if (typeof value !== "boolean") {
+    throw new ObservatoryPortableSetupDecodeError(
+      `${label}: ожидался boolean.`,
+    );
+  }
+  return value;
+}
+
+function positiveInteger(value: unknown, label: string): number {
+  if (!Number.isInteger(value) || Number(value) < 1) {
+    throw new ObservatoryPortableSetupDecodeError(
+      `${label}: ожидалось положительное целое.`,
+    );
+  }
+  return Number(value);
+}
+
+function exact<T>(value: unknown, expected: T, label: string): T {
+  if (value !== expected) {
+    throw new ObservatoryPortableSetupDecodeError(
+      `${label}: значение изменилось.`,
+    );
+  }
+  return expected;
+}
+
+function oneOf<const T extends readonly string[]>(
+  value: unknown,
+  allowed: T,
+  label: string,
+): T[number] {
+  if (typeof value !== "string" || !allowed.includes(value)) {
+    throw new ObservatoryPortableSetupDecodeError(
+      `${label}: значение не поддерживается.`,
+    );
+  }
+  return value as T[number];
+}
+
+function exactKeys(
+  value: Record<string, unknown>,
+  expected: readonly string[],
+  label: string,
+): void {
+  const actual = Object.keys(value).sort();
+  const sortedExpected = [...expected].sort();
+  if (
+    actual.length !== sortedExpected.length
+    || actual.some((key, index) => key !== sortedExpected[index])
+  ) {
+    throw new ObservatoryPortableSetupDecodeError(
+      `${label}: обнаружены неизвестные поля.`,
+    );
+  }
+}
@@ -0,0 +1,85 @@
+import { decodePortableCatalog } from "./portableLaboratorySetupDecoder";
+import type {
+  ObservatoryLaboratorySetupCatalog,
+} from "./laboratorySetups";
+
+export type ObservatoryPortableLaboratorySetupFetch = (
+  input: RequestInfo | URL,
+  init?: RequestInit,
+) => Promise<Response>;
+
+class ObservatoryPortableLaboratorySetupContractError extends Error {
+  readonly status: number | null;
+
+  constructor(message: string, status: number | null = null) {
+    super(message);
+    this.name = "ObservatoryPortableLaboratorySetupContractError";
+    this.status = status;
+  }
+}
+
+export async function fetchObservatoryPortableLaboratorySetups(
+  sourceSessionId: string,
+  {
+    signal,
+    fetcher = globalThis.fetch,
+  }: {
+    signal?: AbortSignal;
+    fetcher?: ObservatoryPortableLaboratorySetupFetch;
+  } = {},
+): Promise<ObservatoryLaboratorySetupCatalog> {
+  const response = await request(
+    fetcher,
+    `/api/v1/observatory/portable-laboratory-setups?source_session_id=${encodeURIComponent(sourceSessionId)}`,
+    { method: "GET", headers: { Accept: "application/json" }, signal },
+  );
+  const body = await responseBody(response);
+  if (!response.ok) throw apiError(body, response.status);
+  const catalog = decodePortableCatalog(body);
+  if (catalog.sourceSessionId !== sourceSessionId) {
+    throw new ObservatoryPortableLaboratorySetupContractError(
+      "Portable-каталог сетапов относится к другой исходной сессии.",
+    );
+  }
+  return catalog;
+}
+
+async function request(
+  fetcher: ObservatoryPortableLaboratorySetupFetch,
+  input: string,
+  init: RequestInit,
+): Promise<Response> {
+  try {
+    return await fetcher(input, init);
+  } catch (error) {
+    if (error instanceof DOMException && error.name === "AbortError") throw error;
+    throw new ObservatoryPortableLaboratorySetupContractError(
+      "Portable-каталог сетапов недоступен.",
+    );
+  }
+}
+
+async function responseBody(response: Response): Promise<unknown> {
+  const textBody = await response.text();
+  if (!textBody) return undefined;
+  try {
+    return JSON.parse(textBody) as unknown;
+  } catch {
+    return textBody;
+  }
+}
+
+function apiError(
+  body: unknown,
+  status: number,
+): ObservatoryPortableLaboratorySetupContractError {
+  const detail = body && typeof body === "object" && !Array.isArray(body)
+    ? (body as Record<string, unknown>).detail
+    : null;
+  return new ObservatoryPortableLaboratorySetupContractError(
+    typeof detail === "string" && detail.trim()
+      ? detail
+      : `Observatory API вернул HTTP ${status}.`,
+    status,
+  );
+}
@@ -0,0 +1,338 @@
+const SUBMIT_SCHEMA = "missioncore.observatory-recorded-run-submit/v1";
+const JOB_SCHEMA = "missioncore.observatory-recorded-job/v1";
+const JOB_LIST_SCHEMA = "missioncore.observatory-recorded-job-list/v1";
+const SHA256 = /^[a-f0-9]{64}$/;
+
+export type ObservatoryRecordedJobState =
+  | "accepted"
+  | "queued"
+  | "claimed"
+  | "running"
+  | "paused"
+  | "preemption-pending"
+  | "succeeded"
+  | "failed"
+  | "reconciliation-required";
+
+export type ObservatoryRecordedJobPublicationState =
+  | "not-required"
+  | "pending"
+  | "failed"
+  | "published";
+
+export interface ObservatoryRecordedJob {
+  readonly jobId: string;
+  readonly idempotencyKey: string;
+  readonly sourceSessionId: string;
+  readonly setupId: string;
+  readonly definitionSha256: string;
+  readonly claimGeneration: number;
+  readonly state: ObservatoryRecordedJobState;
+  readonly restartFromZero: boolean;
+  readonly resultId: string | null;
+  readonly terminalMessage: string | null;
+  readonly publication: {
+    readonly state: ObservatoryRecordedJobPublicationState;
+    readonly attempts: number;
+    readonly error: string | null;
+    readonly publishedAtUtc: string | null;
+  };
+  readonly createdAtUtc: string;
+  readonly updatedAtUtc: string;
+}
+
+export type ObservatoryRecordedJobFetch = (
+  input: RequestInfo | URL,
+  init?: RequestInit,
+) => Promise<Response>;
+
+export class ObservatoryRecordedJobContractError extends Error {
+  readonly status: number | null;
+
+  constructor(message: string, status: number | null = null) {
+    super(message);
+    this.name = "ObservatoryRecordedJobContractError";
+    this.status = status;
+  }
+}
+
+export async function fetchObservatoryRecordedJobs(
+  sourceSessionId: string,
+  setupId: string,
+  {
+    signal,
+    definitionSha256,
+    fetcher = globalThis.fetch,
+  }: {
+    signal?: AbortSignal;
+    definitionSha256?: string;
+    fetcher?: ObservatoryRecordedJobFetch;
+  } = {},
+): Promise<readonly ObservatoryRecordedJob[]> {
+  const query = new URLSearchParams({
+    source_session_id: sourceSessionId,
+    setup_id: setupId,
+    limit: "20",
+  });
+  if (definitionSha256 !== undefined) query.set("definition_sha256", definitionSha256);
+  const response = await request(fetcher, `/api/v1/observatory/runs?${query}`, {
+    method: "GET",
+    headers: { Accept: "application/json" },
+    signal,
+  });
+  const body = await responseBody(response);
+  if (!response.ok) throw apiError(body, response.status);
+  const row = record(body, "список расчётов");
+  exactKeys(row, ["authority", "items", "schema_version"], "список расчётов");
+  exact(row.schema_version, JOB_LIST_SCHEMA, "schema_version списка расчётов");
+  observationAuthority(row.authority);
+  return array(row.items, "items").map(decodeObservatoryRecordedJob).filter((job) => (
+    job.sourceSessionId === sourceSessionId && job.setupId === setupId
+    && (definitionSha256 === undefined || job.definitionSha256 === definitionSha256)
+  ));
+}
+
+export async function submitObservatoryRecordedJob(
+  sourceSessionId: string,
+  setupId: string,
+  idempotencyKey: string,
+  portableBinding: {
+    readonly definitionSha256: string;
+    readonly checkSha256: string;
+  } | null,
+  {
+    signal,
+    fetcher = globalThis.fetch,
+  }: {
+    signal?: AbortSignal;
+    fetcher?: ObservatoryRecordedJobFetch;
+  } = {},
+): Promise<ObservatoryRecordedJob> {
+  const response = await request(fetcher, "/api/v1/observatory/runs", {
+    method: "POST",
+    headers: { Accept: "application/json", "Content-Type": "application/json" },
+    body: JSON.stringify({
+      schema_version: SUBMIT_SCHEMA,
+      idempotency_key: idempotencyKey,
+      source_session_id: sourceSessionId,
+      setup_id: setupId,
+      ...(portableBinding === null ? {} : {
+        definition_sha256: portableBinding.definitionSha256,
+        check_sha256: portableBinding.checkSha256,
+      }),
+    }),
+    signal,
+  });
+  const body = await responseBody(response);
+  if (!response.ok) throw apiError(body, response.status);
+  const job = decodeObservatoryRecordedJob(body);
+  if (job.sourceSessionId !== sourceSessionId || job.setupId !== setupId
+    || (portableBinding !== null && job.definitionSha256 !== portableBinding.definitionSha256)) {
+    throw new ObservatoryRecordedJobContractError(
+      "Расчёт относится к другой сессии, сетапу или версии профиля.",
+    );
+  }
+  return job;
+}
+
+export async function retryObservatoryRecordedJobPublication(
+  jobId: string,
+  {
+    signal,
+    fetcher = globalThis.fetch,
+  }: {
+    signal?: AbortSignal;
+    fetcher?: ObservatoryRecordedJobFetch;
+  } = {},
+): Promise<ObservatoryRecordedJob> {
+  const response = await request(
+    fetcher,
+    `/api/v1/observatory/runs/${encodeURIComponent(jobId)}/publication/retry`,
+    {
+      method: "POST",
+      headers: { Accept: "application/json" },
+      signal,
+    },
+  );
+  const body = await responseBody(response);
+  if (!response.ok) throw apiError(body, response.status);
+  const job = decodeObservatoryRecordedJob(body);
+  if (job.jobId !== jobId) {
+    throw new ObservatoryRecordedJobContractError(
+      "Повтор публикации вернул другой расчёт.",
+    );
+  }
+  return job;
+}
+
+export function decodeObservatoryRecordedJob(value: unknown): ObservatoryRecordedJob {
+  const row = record(value, "расчёт");
+  exactKeys(row, [
+    "authority", "checkpoint_policy", "claim_generation", "claim_lease", "created_at_utc", "executor",
+    "idempotency_key", "identity_sha256", "job_id", "preemption_receipt_sha256",
+    "preemption_requested", "priority", "publication", "request_sha256", "restart_from_zero", "result",
+    "schema_version", "setup", "source", "state", "submission_receipt_sha256", "terminal",
+    "updated_at_utc",
+  ], "расчёт");
+  exact(row.schema_version, JOB_SCHEMA, "schema_version расчёта");
+  observationAuthority(row.authority);
+  digest(row.request_sha256, "request_sha256");
+  digest(row.identity_sha256, "identity_sha256");
+  digest(row.submission_receipt_sha256, "submission_receipt_sha256");
+  const source = record(row.source, "source");
+  exactKeys(source, [
+    "adapter", "bundle_sha256", "capability_manifest_sha256", "catalog_sha256", "session_id",
+  ], "source");
+  digest(source.catalog_sha256, "source.catalog_sha256");
+  digest(source.bundle_sha256, "source.bundle_sha256");
+  digest(source.capability_manifest_sha256, "source.capability_manifest_sha256");
+  const setup = record(row.setup, "setup");
+  exactKeys(setup, ["definition_id", "definition_sha256", "definition_version", "setup_id"], "setup");
+  digest(setup.definition_sha256, "setup.definition_sha256");
+  const state = oneOf(row.state, [
+    "accepted", "queued", "claimed", "running", "paused", "preemption-pending",
+    "succeeded", "failed", "reconciliation-required",
+  ] as const, "state");
+  if (row.claim_lease !== null) {
+    const lease = record(row.claim_lease, "claim_lease");
+    exactKeys(
+      lease,
+      ["claimed_at_utc", "expires_at_utc", "heartbeat_at_utc", "renewal_count"],
+      "claim_lease",
+    );
+    text(lease.claimed_at_utc, "claim_lease.claimed_at_utc");
+    text(lease.expires_at_utc, "claim_lease.expires_at_utc");
+    text(lease.heartbeat_at_utc, "claim_lease.heartbeat_at_utc");
+    nonNegativeInteger(lease.renewal_count, "claim_lease.renewal_count");
+  }
+  const result = row.result === null ? null : record(row.result, "result");
+  if (result !== null) exactKeys(result, ["result_id", "sha256"], "result");
+  const terminal = row.terminal === null ? null : record(row.terminal, "terminal");
+  if (terminal !== null) exactKeys(terminal, ["code", "message"], "terminal");
+  const publication = record(row.publication, "publication");
+  exactKeys(
+    publication,
+    ["attempts", "error", "published_at_utc", "state"],
+    "publication",
+  );
+  const publicationState = oneOf(publication.state, [
+    "not-required", "pending", "failed", "published",
+  ] as const, "publication.state");
+  const publicationError = publication.error === null
+    ? null
+    : text(publication.error, "publication.error");
+  const publishedAtUtc = publication.published_at_utc === null
+    ? null
+    : text(publication.published_at_utc, "publication.published_at_utc");
+  return {
+    jobId: text(row.job_id, "job_id"),
+    idempotencyKey: text(row.idempotency_key, "idempotency_key"),
+    sourceSessionId: text(source.session_id, "source.session_id"),
+    setupId: text(setup.setup_id, "setup.setup_id"),
+    definitionSha256: String(setup.definition_sha256),
+    claimGeneration: nonNegativeInteger(row.claim_generation, "claim_generation"),
+    state,
+    restartFromZero: boolean(row.restart_from_zero, "restart_from_zero"),
+    resultId: result === null ? null : text(result.result_id, "result.result_id"),
+    terminalMessage: terminal === null || terminal.message === null
+      ? null
+      : text(terminal.message, "terminal.message"),
+    publication: {
+      state: publicationState,
+      attempts: nonNegativeInteger(publication.attempts, "publication.attempts"),
+      error: publicationError,
+      publishedAtUtc,
+    },
+    createdAtUtc: text(row.created_at_utc, "created_at_utc"),
+    updatedAtUtc: text(row.updated_at_utc, "updated_at_utc"),
+  };
+}
+
+function observationAuthority(value: unknown): void {
+  const row = record(value, "authority");
+  const keys = ["commands_enabled", "actuation_allowed", "navigation_or_safety_accepted", "production_accepted"];
+  exactKeys(row, keys, "authority");
+  keys.forEach((key) => exact(row[key], false, `authority.${key}`));
+}
+
+async function request(fetcher: ObservatoryRecordedJobFetch, input: string, init: RequestInit): Promise<Response> {
+  try {
+    return await fetcher(input, init);
+  } catch (error) {
+    if (error instanceof DOMException && error.name === "AbortError") throw error;
+    throw new ObservatoryRecordedJobContractError("Очередь расчётов недоступна.");
+  }
+}
+
+async function responseBody(response: Response): Promise<unknown> {
+  const body = await response.text();
+  if (!body) return undefined;
+  try { return JSON.parse(body) as unknown; } catch { return body; }
+}
+
+function apiError(body: unknown, status: number): ObservatoryRecordedJobContractError {
+  const detail = body && typeof body === "object" && !Array.isArray(body)
+    ? (body as Record<string, unknown>).detail
+    : null;
+  return new ObservatoryRecordedJobContractError(
+    typeof detail === "string" && detail.trim() ? detail : `Observatory API вернул HTTP ${status}.`,
+    status,
+  );
+}
+
+function record(value: unknown, label: string): Record<string, unknown> {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new ObservatoryRecordedJobContractError(`${label}: ожидался объект.`);
+  }
+  return value as Record<string, unknown>;
+}
+
+function array(value: unknown, label: string): unknown[] {
+  if (!Array.isArray(value)) throw new ObservatoryRecordedJobContractError(`${label}: ожидался массив.`);
+  return value;
+}
+
+function text(value: unknown, label: string): string {
+  if (typeof value !== "string" || !value.trim()) {
+    throw new ObservatoryRecordedJobContractError(`${label}: ожидался текст.`);
+  }
+  return value;
+}
+
+function digest(value: unknown, label: string): string {
+  const valueText = text(value, label);
+  if (!SHA256.test(valueText)) throw new ObservatoryRecordedJobContractError(`${label}: некорректный digest.`);
+  return valueText;
+}
+
+function boolean(value: unknown, label: string): boolean {
+  if (typeof value !== "boolean") throw new ObservatoryRecordedJobContractError(`${label}: ожидался boolean.`);
+  return value;
+}
+
+function nonNegativeInteger(value: unknown, label: string): number {
+  if (!Number.isInteger(value) || Number(value) < 0) {
+    throw new ObservatoryRecordedJobContractError(`${label}: ожидалось целое число.`);
+  }
+  return Number(value);
+}
+
+function exact<T>(value: unknown, expected: T, label: string): T {
+  if (value !== expected) throw new ObservatoryRecordedJobContractError(`${label}: значение изменилось.`);
+  return expected;
+}
+
+function oneOf<const T extends readonly string[]>(value: unknown, allowed: T, label: string): T[number] {
+  if (typeof value !== "string" || !allowed.includes(value)) {
+    throw new ObservatoryRecordedJobContractError(`${label}: значение не поддерживается.`);
+  }
+  return value as T[number];
+}
+
+function exactKeys(value: Record<string, unknown>, expected: readonly string[], label: string): void {
+  const actual = Object.keys(value).sort();
+  const sortedExpected = [...expected].sort();
+  if (actual.length !== sortedExpected.length || actual.some((key, index) => key !== sortedExpected[index])) {
+    throw new ObservatoryRecordedJobContractError(`${label}: обнаружены неизвестные поля.`);
+  }
+}
@@ -0,0 +1,124 @@
+import type { ObservatoryRecordedJob } from "./recordedJobs";
+
+const PHASES = {
+  "source-transfer": "Передаём входные данные",
+  "source-preparation": "Подготавливаем вход",
+  computing: "Обрабатываем запись",
+  "result-assembly": "Собираем результат",
+  "result-transfer": "Передаём результат",
+} as const;
+const UNITS = { frames: "кадров", members: "файлов", steps: "операций" } as const;
+type Phase = keyof typeof PHASES;
+type Unit = keyof typeof UNITS;
+
+export interface RecordedProgressView {
+  readonly jobId: string;
+  readonly claimGeneration: number;
+  readonly sequence: number;
+  readonly phase: Phase;
+  readonly unit: Unit;
+  readonly completed: number;
+  readonly total: number | null;
+  readonly ageSeconds: number;
+  readonly elapsedSeconds: number;
+  readonly phaseElapsedSeconds: number;
+}
+
+export async function fetchRecordedProgress(
+  job: ObservatoryRecordedJob,
+  { signal, fetcher = globalThis.fetch }: {
+    signal?: AbortSignal;
+    fetcher?: typeof globalThis.fetch;
+  } = {},
+): Promise<RecordedProgressView | null> {
+  const request = new AbortController();
+  const abort = () => request.abort();
+  signal?.addEventListener("abort", abort, { once: true });
+  if (signal?.aborted) request.abort();
+  const timer = globalThis.setTimeout(abort, 2_500);
+  try {
+    const response = await fetcher(
+      `/api/v1/observatory/runs/${encodeURIComponent(job.jobId)}/progress`,
+      { signal: request.signal, headers: { Accept: "application/json" } },
+    );
+    if (!response.ok) throw new Error("Прогресс расчёта недоступен.");
+    return decodeRecordedProgress(await response.json(), job);
+  } finally {
+    globalThis.clearTimeout(timer);
+    signal?.removeEventListener("abort", abort);
+  }
+}
+
+export function decodeRecordedProgress(
+  value: unknown, job: ObservatoryRecordedJob,
+): RecordedProgressView | null {
+  const row = object(value);
+  keys(row, ["schema_version", "job_id", "source_session_id", "setup_id",
+    "definition_sha256", "claim_generation", "state", "received_at_utc", "age_seconds", "progress"]);
+  if (row.schema_version !== "missioncore.observatory-recorded-progress-view/v1"
+    || row.job_id !== job.jobId || row.source_session_id !== job.sourceSessionId
+    || row.setup_id !== job.setupId || row.definition_sha256 !== job.definitionSha256
+    || row.claim_generation !== job.claimGeneration) throw new Error("Прогресс другой попытки.");
+  if (row.progress === null || row.state !== job.state) return null;
+  const progress = object(row.progress);
+  keys(progress, ["schema_version", "claim_generation", "sequence", "phase_index",
+    "phase", "unit", "completed", "total", "elapsed_seconds", "phase_elapsed_seconds"]);
+  if (progress.schema_version !== "missioncore.observatory-recorded-progress/v1"
+    || progress.claim_generation !== row.claim_generation
+    || !(typeof progress.phase === "string" && Object.hasOwn(PHASES, progress.phase))
+    || !(typeof progress.unit === "string" && Object.hasOwn(UNITS, progress.unit))
+    || typeof row.received_at_utc !== "string" || !Number.isFinite(Date.parse(row.received_at_utc))) {
+    throw new Error("Некорректный прогресс.");
+  }
+  const completed = integer(progress.completed);
+  const total = progress.total === null ? null : integer(progress.total, 1);
+  const elapsed = finite(progress.elapsed_seconds);
+  const phaseElapsed = finite(progress.phase_elapsed_seconds);
+  if ((total !== null && completed > total) || phaseElapsed > elapsed) {
+    throw new Error("Некорректные счётчики прогресса.");
+  }
+  integer(progress.phase_index);
+  return {
+    jobId: job.jobId, claimGeneration: integer(progress.claim_generation, 1),
+    sequence: integer(progress.sequence, 1), phase: progress.phase as Phase,
+    unit: progress.unit as Unit, completed, total, ageSeconds: finite(row.age_seconds),
+    elapsedSeconds: elapsed, phaseElapsedSeconds: phaseElapsed,
+  };
+}
+
+export function recordedProgressLabel(
+  job: ObservatoryRecordedJob | null, progress: RecordedProgressView | null,
+): string {
+  if (job?.publication.state === "pending") return "Сохраняем результат";
+  if (!job || job.state === "accepted" || job.state === "queued") return "Ожидаем расчёт";
+  if (job.state === "failed") return "Ошибка расчёта";
+  if (job.state === "succeeded") return "Расчёт завершён";
+  if (job.state === "paused" || job.state === "preemption-pending") return "Расчёт приостановлен";
+  if (job.state === "reconciliation-required") return "Проверяем состояние расчёта";
+  if (!progress || progress.jobId !== job.jobId
+    || progress.claimGeneration !== job.claimGeneration) return "Ожидаем данные расчёта";
+  if (progress.ageSeconds > 15) return "Ожидаем обновление прогресса";
+  const count = progress.total === null
+    ? (progress.completed > 0 ? ` · ${progress.completed.toLocaleString("ru-RU")} ${UNITS[progress.unit]}` : "")
+    : ` · ${progress.completed.toLocaleString("ru-RU")} / ${progress.total.toLocaleString("ru-RU")} ${UNITS[progress.unit]}`;
+  return PHASES[progress.phase] + count;
+}
+
+function object(value: unknown): Record<string, unknown> {
+  if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error("Прогресс: ожидался объект.");
+  return value as Record<string, unknown>;
+}
+function keys(row: Record<string, unknown>, expected: string[]): void {
+  if (Object.keys(row).length !== expected.length || expected.some((key) => !Object.hasOwn(row, key))) {
+    throw new Error("Прогресс: неизвестные поля.");
+  }
+}
+function finite(value: unknown): number {
+  if (typeof value !== "number" || !Number.isFinite(value) || value < 0) throw new Error("Прогресс: некорректное число.");
+  return value;
+}
+function integer(value: unknown, minimum = 0): number {
+  const number = finite(value);
+  if (!Number.isSafeInteger(number) || number < minimum) throw new Error("Прогресс: некорректный счётчик.");
+  return number;
+}
@@ -0,0 +1,335 @@
+import type { LaboratoryFetch } from "../laboratory/advancedResults";
+import {
+  fetchVegetationShadowResultMetadata,
+  type VegetationFullRouteReview,
+  type VegetationShadowResult,
+} from "../laboratory/vegetationShadow";
+import type { ObservationLabInstance } from "../observation/sessionArchive";
+import {
+  decodeLabReplayCapability,
+  decodeCanonicalLabReplayCapabilityProvenance,
+  decodePortableLabReplayCapabilityProvenance,
+  ObservationLabReplayCapabilityContractError,
+} from "../observation/labReplayCapability";
+
+const CANONICAL_RESULT_ID = /^lab-v1-vegetation-shadow-[a-f0-9]{64}$/;
+const CANONICAL_SOURCE_SESSION_ID = "20260828T130511Z_viewer_live";
+
+interface ObservatoryRecordedRunBindingBase {
+  readonly evidenceSessionId: string;
+  readonly sourceSessionId: string;
+  readonly resultId: string;
+  readonly activation: "explicit";
+}
+
+export interface ObservatoryCanonicalRecordedRunBinding
+  extends ObservatoryRecordedRunBindingBase {
+  readonly kind: "canonical-recorded-rerun";
+  readonly viewerProfile: "recorded-session";
+  readonly timeline: "session_time";
+}
+
+export interface ObservatoryPortableResultBinding
+  extends ObservatoryRecordedRunBindingBase {
+  readonly kind: "portable-result-review";
+  readonly viewerProfile: "portable-result";
+  readonly timeline: "result-defined";
+  readonly definitionSha256: string;
+}
+
+export type ObservatoryRecordedRunBinding =
+  | ObservatoryCanonicalRecordedRunBinding
+  | ObservatoryPortableResultBinding;
+
+export interface ObservatoryPortableResultReview {
+  readonly kind: "portable-result";
+  readonly resultId: string;
+  readonly sourceSessionId: string;
+  readonly resultKind: string;
+  readonly definitionSha256: string;
+  readonly calculationProfile: Readonly<Record<string, unknown>> | null;
+  readonly artifactManifestId: string;
+  readonly artifacts: readonly {
+    readonly role: string;
+    readonly mediaType: string;
+    readonly sha256: string;
+    readonly byteLength: number;
+  }[];
+  readonly resultDocument: Readonly<Record<string, unknown>>;
+}
+
+export type ObservatoryRecordedRunReview =
+  | { readonly kind: "canonical-recorded-rerun"; readonly review: VegetationFullRouteReview }
+  | ObservatoryPortableResultReview;
+
+export class ObservatoryRecordedRunContractError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "ObservatoryRecordedRunContractError";
+  }
+}
+
+export function observatoryRecordedRunBinding(
+  evidenceSessionId: string,
+  lab: ObservationLabInstance,
+): ObservatoryRecordedRunBinding | null {
+  const capability = lab.replayCapability;
+  if (!capability) return null;
+  if (capability.kind === "portable-result-review") {
+    if (
+      evidenceSessionId !== lab.resultId
+      || lab.sourceSessionId === evidenceSessionId
+      || lab.configSha256 === null
+      || !/^[a-f0-9]{64}$/.test(lab.configSha256)
+      || capability.viewerProfile !== "portable-result"
+      || capability.timeline !== "result-defined"
+      || capability.activation !== "explicit"
+      || capability.commandsEnabled !== false
+    ) {
+      throw new ObservatoryRecordedRunContractError(
+        `Portable-результат ${lab.resultId} не допущен к универсальному viewer.`,
+      );
+    }
+    try {
+      decodePortableLabReplayCapabilityProvenance(
+        lab.provenance,
+        evidenceSessionId,
+        lab.resultId,
+        lab.sourceSessionId,
+        lab.configSha256,
+      );
+    } catch (error) {
+      if (!(error instanceof ObservationLabReplayCapabilityContractError)) throw error;
+      throw new ObservatoryRecordedRunContractError(error.message);
+    }
+    return {
+      kind: "portable-result-review",
+      evidenceSessionId,
+      sourceSessionId: lab.sourceSessionId,
+      resultId: lab.resultId,
+      viewerProfile: "portable-result",
+      timeline: "result-defined",
+      activation: "explicit",
+      definitionSha256: lab.configSha256,
+    };
+  }
+  try {
+    decodeCanonicalLabReplayCapabilityProvenance(
+      lab.provenance,
+      evidenceSessionId,
+      lab.resultId,
+    );
+  } catch (error) {
+    if (!(error instanceof ObservationLabReplayCapabilityContractError)) throw error;
+    throw new ObservatoryRecordedRunContractError(error.message);
+  }
+  if (
+    evidenceSessionId !== lab.resultId
+    || lab.sourceSessionId !== CANONICAL_SOURCE_SESSION_ID
+    || lab.labId !== "LAB V1"
+    || lab.resultKind !== "recorded-perception-qualification"
+    || !CANONICAL_RESULT_ID.test(lab.resultId)
+    || lab.configSha256 !== null
+    || lab.sourceResultId === null
+    || !CANONICAL_RESULT_ID.test(lab.sourceResultId)
+    || capability.kind !== "canonical-recorded-rerun"
+    || capability.viewerProfile !== "recorded-session"
+    || capability.timeline !== "session_time"
+    || capability.activation !== "explicit"
+    || capability.commandsEnabled !== false
+  ) {
+    throw new ObservatoryRecordedRunContractError(
+      `LAB-результат ${lab.resultId} не допущен к каноническому recorded replay.`,
+    );
+  }
+  return {
+    kind: "canonical-recorded-rerun",
+    evidenceSessionId,
+    sourceSessionId: lab.sourceSessionId,
+    resultId: lab.resultId,
+    viewerProfile: "recorded-session",
+    timeline: "session_time",
+    activation: "explicit",
+  };
+}
+
+export async function fetchObservatoryRecordedRunReview(
+  binding: ObservatoryRecordedRunBinding,
+  {
+    selectedSourceSessionId,
+    fetcher = fetch,
+    signal,
+  }: {
+    selectedSourceSessionId: string;
+    fetcher?: LaboratoryFetch;
+    signal?: AbortSignal;
+  },
+): Promise<ObservatoryRecordedRunReview> {
+  if (binding.sourceSessionId !== selectedSourceSessionId) {
+    throw new ObservatoryRecordedRunContractError(
+      "Запуск не связан с выбранной исходной сессией.",
+    );
+  }
+  if (binding.kind === "portable-result-review") {
+    return fetchPortableResultReview(binding, { fetcher, signal });
+  }
+  const result = await fetchVegetationShadowResultMetadata(binding.resultId, {
+    fetcher,
+    signal,
+  });
+  return {
+    kind: "canonical-recorded-rerun",
+    review: admitObservatoryRecordedRunReview(
+      binding,
+      selectedSourceSessionId,
+      result,
+    ),
+  };
+}
+
+export function admitObservatoryRecordedRunReview(
+  binding: ObservatoryCanonicalRecordedRunBinding,
+  selectedSourceSessionId: string,
+  result: VegetationShadowResult,
+): VegetationFullRouteReview {
+  if (binding.sourceSessionId !== selectedSourceSessionId) {
+    throw new ObservatoryRecordedRunContractError(
+      "Запуск не связан с выбранной исходной сессией.",
+    );
+  }
+  if (result.resultId !== binding.resultId) {
+    throw new ObservatoryRecordedRunContractError(
+      "Запечатанный результат не совпадает с выбранным запуском.",
+    );
+  }
+  const review = result.routeFullReview;
+  if (!review || review.sessionId !== binding.sourceSessionId) {
+    throw new ObservatoryRecordedRunContractError(
+      "Запечатанный результат потерял точную связь с исходной сессией.",
+    );
+  }
+  return review;
+}
+
+async function fetchPortableResultReview(
+  binding: ObservatoryPortableResultBinding,
+  {
+    fetcher,
+    signal,
+  }: {
+    fetcher: LaboratoryFetch;
+    signal?: AbortSignal;
+  },
+): Promise<ObservatoryPortableResultReview> {
+  const response = await fetcher(
+    `/api/v1/observatory/portable-results/${encodeURIComponent(binding.resultId)}`,
+    { headers: { Accept: "application/json" }, signal },
+  );
+  let body: unknown;
+  try {
+    body = await response.json();
+  } catch {
+    throw new ObservatoryRecordedRunContractError(
+      "Portable viewer получил некорректный ответ сервера.",
+    );
+  }
+  if (!response.ok) {
+    throw new ObservatoryRecordedRunContractError(
+      isRecord(body) && typeof body.detail === "string"
+        ? body.detail
+        : `Portable viewer вернул HTTP ${response.status}.`,
+    );
+  }
+  return decodePortableResultReview(body, binding);
+}
+
+function decodePortableResultReview(
+  value: unknown,
+  binding: ObservatoryPortableResultBinding,
+): ObservatoryPortableResultReview {
+  if (!isRecord(value)) {
+    throw new ObservatoryRecordedRunContractError("Portable viewer вернул не объект.");
+  }
+  const expected = new Set([
+    "schema_version",
+    "result_id",
+    "source_session_id",
+    "result_kind",
+    "definition_sha256",
+    "viewer_capability",
+    "calculation_profile",
+    "artifact_manifest_id",
+    "artifacts",
+    "result_document",
+  ]);
+  if (Object.keys(value).some((key) => !expected.has(key)) || Object.keys(value).length !== expected.size) {
+    throw new ObservatoryRecordedRunContractError("Portable viewer изменил контракт ответа.");
+  }
+  let viewerCapability;
+  try {
+    viewerCapability = decodeLabReplayCapability(
+      value.viewer_capability,
+      binding.evidenceSessionId,
+    );
+  } catch (error) {
+    if (!(error instanceof ObservationLabReplayCapabilityContractError)) throw error;
+    throw new ObservatoryRecordedRunContractError(error.message);
+  }
+  if (
+    value.schema_version !== "missioncore.observatory-portable-result-view/v1"
+    || value.result_id !== binding.resultId
+    || value.source_session_id !== binding.sourceSessionId
+    || value.definition_sha256 !== binding.definitionSha256
+    || typeof value.result_kind !== "string"
+    || typeof value.artifact_manifest_id !== "string"
+    || !/^[a-f0-9]{64}$/.test(value.artifact_manifest_id)
+    || !Array.isArray(value.artifacts)
+    || !isRecord(value.result_document)
+    || !isRecord(value.calculation_profile)
+    || viewerCapability === null
+    || viewerCapability.kind !== "portable-result-review"
+    || viewerCapability.viewerProfile !== binding.viewerProfile
+    || viewerCapability.timeline !== binding.timeline
+  ) {
+    throw new ObservatoryRecordedRunContractError("Portable viewer потерял identity результата.");
+  }
+  const artifacts = value.artifacts.map((item) => {
+    if (
+      !isRecord(item)
+      || Object.keys(item).length !== 4
+      || !["role", "media_type", "sha256", "byte_length"].every(
+        (key) => Object.prototype.hasOwnProperty.call(item, key),
+      )
+      || typeof item.role !== "string"
+      || typeof item.media_type !== "string"
+      || typeof item.sha256 !== "string"
+      || !/^[a-f0-9]{64}$/.test(item.sha256)
+      || typeof item.byte_length !== "number"
+      || !Number.isSafeInteger(item.byte_length)
+      || item.byte_length < 0
+    ) {
+      throw new ObservatoryRecordedRunContractError("Portable viewer получил неверный artifact.");
+    }
+    return {
+      role: item.role,
+      mediaType: item.media_type,
+      sha256: item.sha256,
+      byteLength: item.byte_length,
+    };
+  });
+  return {
+    kind: "portable-result",
+    resultId: binding.resultId,
+    sourceSessionId: binding.sourceSessionId,
+    resultKind: value.result_kind,
+    definitionSha256: binding.definitionSha256,
+    calculationProfile: value.calculation_profile,
+    artifactManifestId: value.artifact_manifest_id,
+    artifacts,
+    resultDocument: value.result_document,
+  };
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
@@ -0,0 +1,98 @@
+import { useCallback, useEffect, useState } from "react";
+
+import {
+  AI_MODULE_SETUP_IDS,
+  fetchAIModuleCatalog,
+  fetchAICompositionJobs,
+  fetchAICompositionRuns,
+  type AICompositionRun,
+} from "./aiComposition";
+import { fetchRecordedProgress, type RecordedProgressView } from "./recordedProgress";
+import type { ObservatoryRecordedJob } from "./recordedJobs";
+
+const OPEN = new Set(["accepted", "queued", "claimed", "running", "paused",
+  "preemption-pending", "reconciliation-required"]);
+
+interface Snapshot {
+  readonly sourceSessionId: string;
+  readonly jobs: readonly ObservatoryRecordedJob[];
+  readonly runs: readonly AICompositionRun[];
+  readonly moduleLabelsBySetup: Readonly<Record<string, string>>;
+  readonly progress: Readonly<Record<string, RecordedProgressView>>;
+  readonly error: string | null;
+}
+
+export function useAICompositionJobs(sourceSessionId: string) {
+  const [revision, setRevision] = useState(0);
+  const [snapshot, setSnapshot] = useState<Snapshot>({
+    sourceSessionId: "", jobs: [], runs: [], moduleLabelsBySetup: {}, progress: {}, error: null,
+  });
+  const current = snapshot.sourceSessionId === sourceSessionId ? snapshot : {
+    sourceSessionId, jobs: [], runs: [], moduleLabelsBySetup: {}, progress: {}, error: null,
+  };
+
+  useEffect(() => {
+    if (!sourceSessionId) {
+      setSnapshot({ sourceSessionId, jobs: [], runs: [], moduleLabelsBySetup: {}, progress: {}, error: null });
+      return;
+    }
+    const request = new AbortController();
+    void Promise.all([
+      fetchAICompositionJobs(sourceSessionId, request.signal),
+      fetchAICompositionRuns(sourceSessionId, request.signal),
+      fetchAIModuleCatalog(request.signal),
+    ]).then(async ([jobs, runs, catalog]) => {
+      const active = jobs.filter((job) => OPEN.has(job.state));
+      const samples = await Promise.all(active.map(async (job) => [
+        job.jobId, await fetchRecordedProgress(job, { signal: request.signal }).catch(() => null),
+      ] as const));
+      if (request.signal.aborted) return;
+      const catalogLabels = catalog.groups.flatMap(({ modules }) => (
+        modules.flatMap((module) => {
+          const setupId = AI_MODULE_SETUP_IDS[module.moduleId];
+          return setupId ? [[setupId, module.label] as const] : [];
+        })
+      ));
+      const projectedLabels = runs.flatMap((run) => run.presentation.modules.flatMap((module) => {
+        const setupId = AI_MODULE_SETUP_IDS[module.moduleId];
+        return setupId ? [[setupId, module.label] as const] : [];
+      }));
+      setSnapshot({
+        sourceSessionId, jobs, runs,
+        moduleLabelsBySetup: Object.fromEntries([...catalogLabels, ...projectedLabels]),
+        progress: Object.fromEntries(samples.filter(
+          (sample): sample is readonly [string, RecordedProgressView] => sample[1] !== null,
+        )),
+        error: null,
+      });
+    }).catch((error: unknown) => {
+      if (request.signal.aborted) return;
+      setSnapshot((value) => ({
+        sourceSessionId, jobs: value.sourceSessionId === sourceSessionId ? value.jobs : [],
+        runs: value.sourceSessionId === sourceSessionId ? value.runs : [],
+        moduleLabelsBySetup: value.sourceSessionId === sourceSessionId
+          ? value.moduleLabelsBySetup : {},
+        progress: value.sourceSessionId === sourceSessionId ? value.progress : {},
+        error: error instanceof Error ? error.message : "Очередь AI-слоёв недоступна.",
+      }));
+    });
+    return () => request.abort();
+  }, [revision, sourceSessionId]);
+
+  const active = current.runs.some((run) => run.state === "running")
+    || current.jobs.some((job) => OPEN.has(job.state) || job.publication.state === "pending");
+  useEffect(() => {
+    if (!active) return;
+    const timer = globalThis.setTimeout(() => setRevision((value) => value + 1), 1_500);
+    return () => globalThis.clearTimeout(timer);
+  }, [active, revision]);
+
+  return {
+    jobs: current.jobs,
+    runs: current.runs,
+    moduleLabelsBySetup: current.moduleLabelsBySetup,
+    progress: current.progress,
+    error: current.error,
+    refresh: useCallback(() => setRevision((value) => value + 1), []),
+  };
+}
@@ -0,0 +1,148 @@
+import { useCallback, useEffect, useRef, useState } from "react";
+
+import {
+  applyObservatoryCatalogMutationOverlay,
+  fetchObservatoryCatalog,
+  reconcileObservatoryCatalogMutationOverlay,
+  type ObservatoryCatalog,
+  type ObservatoryCatalogMutationOverlay,
+} from "./catalog";
+
+export type ObservatoryCatalogState =
+  | "idle"
+  | "loading"
+  | "ready"
+  | "refreshing"
+  | "error";
+
+export interface ObservatoryCatalogController {
+  readonly catalog: ObservatoryCatalog | null;
+  readonly state: ObservatoryCatalogState;
+  readonly error: string | null;
+  readonly refresh: () => Promise<ObservatoryCatalog | null>;
+  readonly applyEvidenceRename: (
+    sessionId: string,
+    displayName: string,
+  ) => void;
+  readonly applyEvidenceDeletion: (sessionId: string) => void;
+}
+
+interface ActiveCatalogRequest {
+  readonly id: number;
+  readonly controller: AbortController;
+}
+
+type ObservatoryCatalogMutationDraft =
+  | { readonly kind: "rename"; readonly displayName: string }
+  | { readonly kind: "delete" };
+
+function errorMessage(error: unknown): string {
+  return error instanceof Error && error.message.trim()
+    ? error.message
+    : "Каталог Обсерватории недоступен.";
+}
+
+function isAbortError(error: unknown): boolean {
+  return error instanceof DOMException && error.name === "AbortError";
+}
+
+export function useObservatoryCatalog(): ObservatoryCatalogController {
+  const [catalog, setCatalog] = useState<ObservatoryCatalog | null>(null);
+  const [state, setState] = useState<ObservatoryCatalogState>("idle");
+  const [error, setError] = useState<string | null>(null);
+  const catalogRef = useRef<ObservatoryCatalog | null>(null);
+  const overlayRef = useRef<ObservatoryCatalogMutationOverlay>(new Map());
+  const mutationRevisionRef = useRef(0);
+  const requestSequenceRef = useRef(0);
+  const activeRequestRef = useRef<ActiveCatalogRequest | null>(null);
+
+  const loadCatalog = useCallback(async (): Promise<ObservatoryCatalog | null> => {
+    const id = requestSequenceRef.current + 1;
+    requestSequenceRef.current = id;
+    activeRequestRef.current?.controller.abort();
+    const controller = new AbortController();
+    activeRequestRef.current = { id, controller };
+    const requestMutationRevision = mutationRevisionRef.current;
+
+    setState(catalogRef.current ? "refreshing" : "loading");
+    setError(null);
+    try {
+      const serverCatalog = await fetchObservatoryCatalog({
+        signal: controller.signal,
+      });
+      if (controller.signal.aborted || requestSequenceRef.current !== id) {
+        return null;
+      }
+      const reconciled = reconcileObservatoryCatalogMutationOverlay(
+        serverCatalog,
+        overlayRef.current,
+        requestMutationRevision,
+      );
+      overlayRef.current = reconciled.overlay;
+      catalogRef.current = reconciled.catalog;
+      activeRequestRef.current = null;
+      setCatalog(reconciled.catalog);
+      setState("ready");
+      return reconciled.catalog;
+    } catch (loadError: unknown) {
+      if (
+        controller.signal.aborted
+        || requestSequenceRef.current !== id
+        || isAbortError(loadError)
+      ) {
+        return null;
+      }
+      activeRequestRef.current = null;
+      setError(errorMessage(loadError));
+      setState("error");
+      return null;
+    }
+  }, []);
+
+  useEffect(() => {
+    void loadCatalog();
+    return () => {
+      requestSequenceRef.current += 1;
+      activeRequestRef.current?.controller.abort();
+      activeRequestRef.current = null;
+    };
+  }, [loadCatalog]);
+
+  const applyMutation = useCallback((
+    sessionId: string,
+    mutation: ObservatoryCatalogMutationDraft,
+  ) => {
+    const revision = mutationRevisionRef.current + 1;
+    mutationRevisionRef.current = revision;
+    const overlay = new Map(overlayRef.current);
+    overlay.set(sessionId, { ...mutation, revision });
+    overlayRef.current = overlay;
+    if (!catalogRef.current) return;
+    const projected = applyObservatoryCatalogMutationOverlay(
+      catalogRef.current,
+      overlay,
+    );
+    catalogRef.current = projected;
+    setCatalog(projected);
+  }, []);
+
+  const applyEvidenceRename = useCallback((
+    sessionId: string,
+    displayName: string,
+  ) => {
+    applyMutation(sessionId, { kind: "rename", displayName });
+  }, [applyMutation]);
+
+  const applyEvidenceDeletion = useCallback((sessionId: string) => {
+    applyMutation(sessionId, { kind: "delete" });
+  }, [applyMutation]);
+
+  return {
+    catalog,
+    state,
+    error,
+    refresh: loadCatalog,
+    applyEvidenceRename,
+    applyEvidenceDeletion,
+  };
+}
@@ -0,0 +1,132 @@
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+
+import {
+  fetchObservatoryPortableLaboratorySetups,
+  preflightObservatoryLaboratorySetup,
+  selectableObservatorySetups,
+  type ObservatoryLaboratoryRunPreflight,
+  type ObservatoryLaboratorySetupCatalog,
+} from "./laboratorySetups";
+
+type SetupCatalogState = "idle" | "loading" | "ready" | "refreshing" | "error";
+export type SetupPreflightState =
+  | { readonly kind: "idle" }
+  | { readonly kind: "checking" }
+  | { readonly kind: "ready"; readonly value: ObservatoryLaboratoryRunPreflight }
+  | { readonly kind: "error"; readonly message: string };
+
+export function useObservatoryLaboratorySetups(sourceSessionId: string) {
+  const [catalog, setCatalog] = useState<ObservatoryLaboratorySetupCatalog | null>(null);
+  const [state, setState] = useState<SetupCatalogState>("idle");
+  const [error, setError] = useState<string | null>(null);
+  const [selectedSetupId, setSelectedSetupId] = useState("");
+  const [revision, setRevision] = useState(0);
+  const [preflight, setPreflight] = useState<SetupPreflightState>({ kind: "idle" });
+  const requestSequence = useRef(0);
+  const preflightRequest = useRef<AbortController | null>(null);
+  const activeCatalog = catalog?.sourceSessionId === sourceSessionId ? catalog : null;
+  const selectableSetups = useMemo(() => selectableObservatorySetups(activeCatalog), [activeCatalog]);
+  const selectedSetup = selectableSetups.find((setup) => setup.setupId === selectedSetupId) ?? null;
+  const selectedDefinitionSha256 = selectedSetup?.runDefinition?.definitionSha256 ?? null;
+
+  useEffect(() => {
+    preflightRequest.current?.abort();
+    preflightRequest.current = null;
+    if (!sourceSessionId) {
+      setCatalog(null);
+      setState("idle");
+      setError(null);
+      setSelectedSetupId("");
+      setPreflight({ kind: "idle" });
+      return;
+    }
+    const sequence = ++requestSequence.current;
+    const request = new AbortController();
+    setState((current) => activeCatalog && current !== "idle" ? "refreshing" : "loading");
+    setError(null);
+    setPreflight({ kind: "idle" });
+    // Archived definitions belong to evidence, not to the calculation selector.
+    void fetchObservatoryPortableLaboratorySetups(sourceSessionId, { signal: request.signal })
+      .then((next) => {
+        if (request.signal.aborted || requestSequence.current !== sequence) return;
+        setCatalog(next);
+        const selectable = selectableObservatorySetups(next);
+        setSelectedSetupId((current) => (
+          selectable.some((setup) => setup.setupId === current)
+            ? current
+            : selectable[0]?.setupId ?? ""
+        ));
+        setState("ready");
+      })
+      .catch((caught: unknown) => {
+        if (request.signal.aborted || requestSequence.current !== sequence) return;
+        setState("error");
+        setError(caught instanceof Error && caught.message.trim()
+          ? caught.message
+          : "Каталог профилей недоступен.");
+      });
+    return () => request.abort();
+  }, [revision, sourceSessionId]);
+
+  useEffect(() => () => preflightRequest.current?.abort(), []);
+
+  useEffect(() => {
+    preflightRequest.current?.abort();
+    preflightRequest.current = null;
+    setPreflight((current) => current.kind === "idle" ? current : { kind: "idle" });
+  }, [selectedSetupId, sourceSessionId, selectedDefinitionSha256]);
+
+  const selectSetup = useCallback((setupId: string) => {
+    preflightRequest.current?.abort();
+    preflightRequest.current = null;
+    setSelectedSetupId(setupId);
+    setPreflight({ kind: "idle" });
+  }, []);
+
+  const refresh = useCallback(() => setRevision((value) => value + 1), []);
+
+  const check = useCallback(async () => {
+    if (!sourceSessionId || !selectedSetup || preflight.kind === "checking") return;
+    preflightRequest.current?.abort();
+    const request = new AbortController();
+    preflightRequest.current = request;
+    setPreflight({ kind: "checking" });
+    try {
+      const value = await preflightObservatoryLaboratorySetup(
+        sourceSessionId,
+        selectedSetup,
+        { signal: request.signal },
+      );
+      if (request.signal.aborted || preflightRequest.current !== request) return;
+      setPreflight({ kind: "ready", value });
+    } catch (caught) {
+      if (request.signal.aborted || preflightRequest.current !== request) return;
+      setPreflight({
+        kind: "error",
+        message: caught instanceof Error && caught.message.trim()
+          ? caught.message
+          : "Не удалось проверить возможность запуска.",
+      });
+    } finally {
+      if (preflightRequest.current === request) preflightRequest.current = null;
+    }
+  }, [preflight.kind, selectedSetup, sourceSessionId]);
+
+  useEffect(() => {
+    if (state !== "ready" || !selectedSetup || preflight.kind !== "idle") return;
+    void check();
+  }, [check, preflight.kind, selectedSetup, state]);
+
+  return {
+    catalog: activeCatalog,
+    selectableSetups,
+    state,
+    error,
+    selectedSetupId: selectedSetup?.setupId ?? "",
+    selectedSetup,
+    selectSetup,
+    refresh,
+    preflight,
+    check,
+  };
+}
@@ -0,0 +1,207 @@
+import { useCallback, useEffect, useRef, useState } from "react";
+import { fetchRecordedProgress, type RecordedProgressView } from "./recordedProgress";
+
+import {
+  fetchObservatoryRecordedJobs,
+  retryObservatoryRecordedJobPublication,
+  submitObservatoryRecordedJob,
+  type ObservatoryRecordedJob,
+} from "./recordedJobs";
+
+type RecordedJobsState =
+  | "idle"
+  | "loading"
+  | "ready"
+  | "refreshing"
+  | "submitting"
+  | "retrying-publication"
+  | "error";
+
+interface JobSnapshot {
+  readonly selectionKey: string;
+  readonly jobs: readonly ObservatoryRecordedJob[];
+  readonly state: RecordedJobsState;
+  readonly error: string | null;
+  readonly progress?: RecordedProgressView | null;
+}
+const EMPTY_JOBS = [] as const;
+const OPEN_STATES = new Set([
+  "accepted", "queued", "claimed", "running", "paused", "preemption-pending",
+  "reconciliation-required",
+]);
+const POLL_INTERVAL_MS = 1_500;
+
+export function useObservatoryRecordedJobs(
+  sourceSessionId: string,
+  setupId: string,
+  definitionSha256: string,
+) {
+  const selectionKey = JSON.stringify([sourceSessionId, setupId, definitionSha256]);
+  const [snapshot, setSnapshot] = useState<JobSnapshot>({
+    selectionKey: "", jobs: EMPTY_JOBS, state: "idle", error: null,
+  });
+  const [revision, setRevision] = useState(0);
+  const requestRef = useRef<AbortController | null>(null);
+  const requestSequence = useRef(0);
+  const idempotencyKeys = useRef(new Map<string, string>());
+  const observedJobId = useRef<string | null>(null);
+  const hasSelection = Boolean(sourceSessionId && setupId && definitionSha256);
+  // A source/profile change must not display even one render of the previous queue.
+  const current = snapshot.selectionKey === selectionKey ? snapshot : null;
+  const jobs = current?.jobs ?? EMPTY_JOBS;
+  const state = current?.state ?? (hasSelection ? "loading" : "idle");
+  const error = current?.error ?? null;
+
+  useEffect(() => {
+    requestRef.current?.abort();
+    requestRef.current = null;
+    if (!hasSelection) {
+      setSnapshot({ selectionKey, jobs: EMPTY_JOBS, state: "idle", error: null });
+      return;
+    }
+    const sequence = ++requestSequence.current;
+    const request = new AbortController();
+    requestRef.current = request;
+    setSnapshot({
+      selectionKey, jobs,
+      state: jobs.length > 0 ? "refreshing" : "loading", error: null,
+      progress: current?.progress ?? null,
+    });
+    void fetchObservatoryRecordedJobs(sourceSessionId, setupId, {
+      definitionSha256, signal: request.signal,
+    }).then(async (next) => {
+      if (request.signal.aborted || requestSequence.current !== sequence) return;
+      const pending = next.find((job) => OPEN_STATES.has(job.state));
+      const progress = pending
+        ? await fetchRecordedProgress(pending, { signal: request.signal }).catch(() => null)
+        : null;
+      if (request.signal.aborted || requestSequence.current !== sequence) return;
+      if (pending) observedJobId.current = pending.jobId;
+      setSnapshot({ selectionKey, jobs: next, state: "ready", error: null, progress });
+    }).catch((caught: unknown) => {
+      if (request.signal.aborted || requestSequence.current !== sequence) return;
+      setSnapshot({
+        selectionKey, jobs, state: "error",
+        error: caught instanceof Error && caught.message.trim()
+          ? caught.message
+          : "Очередь расчётов недоступна.",
+      });
+    }).finally(() => {
+      if (requestRef.current === request) requestRef.current = null;
+    });
+    return () => request.abort();
+  }, [revision, selectionKey]);
+
+  useEffect(() => () => requestRef.current?.abort(), []);
+
+  const latestJob = jobs[0] ?? null;
+  const activeJob = jobs.find((job) => OPEN_STATES.has(job.state)) ?? null;
+  const publicationPending = jobs.some((job) => job.publication.state === "pending");
+  // Do not promote historical terminal logs to a new operator action's error.
+  const computationFailed = latestJob?.state === "failed"
+    && latestJob.jobId === observedJobId.current;
+
+  useEffect(() => {
+    if ((state !== "ready" && state !== "error") || (!activeJob && !publicationPending)) return;
+    const timer = globalThis.setTimeout(
+      () => setRevision((value) => value + 1),
+      POLL_INTERVAL_MS,
+    );
+    return () => globalThis.clearTimeout(timer);
+  }, [activeJob, publicationPending, revision, state]);
+
+  useEffect(() => {
+    if (!latestJob || activeJob) return;
+    idempotencyKeys.current.delete(selectionKey);
+  }, [activeJob, latestJob, selectionKey]);
+
+  const refresh = useCallback(() => setRevision((value) => value + 1), []);
+
+  const submit = useCallback(async (
+    portableBinding: {
+      readonly definitionSha256: string;
+      readonly checkSha256: string;
+    } | null = null,
+  ): Promise<ObservatoryRecordedJob | null> => {
+    if (!hasSelection || state !== "ready"
+      || portableBinding?.definitionSha256 !== definitionSha256
+      || publicationPending || latestJob?.publication.state === "failed") return null;
+    if (activeJob) return activeJob;
+    requestRef.current?.abort();
+    const request = new AbortController();
+    requestRef.current = request;
+    const key = idempotencyKeys.current.get(selectionKey) ?? createIdempotencyKey();
+    idempotencyKeys.current.set(selectionKey, key);
+    setSnapshot({ selectionKey, jobs, state: "submitting", error: null });
+    try {
+      const job = await submitObservatoryRecordedJob(
+        sourceSessionId, setupId, key, portableBinding, { signal: request.signal },
+      );
+      if (request.signal.aborted || requestRef.current !== request) return null;
+      observedJobId.current = job.jobId;
+      setSnapshot({
+        selectionKey, jobs: [job, ...jobs.filter((candidate) => candidate.jobId !== job.jobId)],
+        state: "ready", error: null,
+      });
+      return job;
+    } catch (caught) {
+      if (request.signal.aborted || requestRef.current !== request) return null;
+      setSnapshot({
+        selectionKey, jobs, state: "error",
+        error: caught instanceof Error && caught.message.trim()
+          ? caught.message
+          : "Не удалось поставить расчёт в очередь.",
+      });
+      return null;
+    } finally {
+      if (requestRef.current === request) requestRef.current = null;
+    }
+  }, [activeJob, definitionSha256, hasSelection, jobs, latestJob,
+    publicationPending, selectionKey, setupId, sourceSessionId, state]);
+
+  const retryPublication = useCallback(async (): Promise<ObservatoryRecordedJob | null> => {
+    if (!latestJob || latestJob.publication.state !== "failed"
+      || state === "retrying-publication") return null;
+    requestRef.current?.abort();
+    const request = new AbortController();
+    requestRef.current = request;
+    setSnapshot({ selectionKey, jobs, state: "retrying-publication", error: null });
+    try {
+      const job = await retryObservatoryRecordedJobPublication(latestJob.jobId, {
+        signal: request.signal,
+      });
+      if (request.signal.aborted || requestRef.current !== request) return null;
+      setSnapshot({
+        selectionKey, jobs: [job, ...jobs.filter((candidate) => candidate.jobId !== job.jobId)],
+        state: "ready", error: null,
+      });
+      return job;
+    } catch (caught) {
+      if (request.signal.aborted || requestRef.current !== request) return null;
+      setSnapshot({
+        selectionKey, jobs, state: "error",
+        error: caught instanceof Error && caught.message.trim()
+          ? caught.message
+          : "Не удалось повторить публикацию результата.",
+      });
+      return null;
+    } finally {
+      if (requestRef.current === request) requestRef.current = null;
+    }
+  }, [jobs, latestJob, selectionKey, state]);
+
+  return {
+    jobs, latestJob, activeJob, publicationPending, computationFailed,
+    progress: current?.progress ?? null,
+    state, error, refresh, submit, retryPublication,
+  };
+}
+
+function createIdempotencyKey(): string {
+  const entropy = typeof globalThis.crypto?.randomUUID === "function"
+    ? globalThis.crypto.randomUUID()
+    : `${Date.now().toString(36)}-${Math.random().toString(16).slice(2)}`;
+  return `observatory-ui:${entropy}`;
+}
+
+export type ObservatoryRecordedJobsController = ReturnType<typeof useObservatoryRecordedJobs>;
@@ -38,6 +38,8 @@ export function useWorkerTelemetry(
      setError(null);
      return;
    }
+    setTelemetry(null);
+    setError(null);
    const controller = new AbortController();
    const stopPolling = startSequentialPolling(async () => {
      setLoading(true);
@@ -48,6 +50,7 @@ export function useWorkerTelemetry(
        setError(null);
      } catch (reason: unknown) {
        if (controller.signal.aborted) return;
+        setTelemetry(null);
        setError(
          reason instanceof Error
            ? reason.message
@@ -114,6 +114,9 @@ export interface WorkerTelemetry {
      power_watts?: number;
      temperature_celsius?: number;
      memory_used_percent?: number;
+      sm_clock_mhz?: number | null;
+      memory_clock_mhz?: number | null;
+      driver_version?: string | null;
    } | null;
    triton: {
      ready: boolean;
@@ -131,6 +134,13 @@ export interface WorkerTelemetry {
    completed_runs: number | null;
    failed_runs: number | null;
    model_load_seconds: number | null;
+    profile_name?: string | null;
+    input_state?: string | null;
+    wait_reason?: string | null;
+    live_children?: number | null;
+    input_pauses?: number | null;
+    pending_bundles?: number | null;
+    buffer_bytes?: number | null;
    stages: WorkerPipelineStage[];
  };
  network: {
@@ -189,7 +199,9 @@ export async function fetchWorkerTelemetry(
      `/api/v1/system/contours/${encodeURIComponent(contourId)}/telemetry?history=90`,
      {
        method: "GET",
-        signal,
+        signal: signal
+          ? AbortSignal.any([signal, AbortSignal.timeout(5_000)])
+          : AbortSignal.timeout(5_000),
      },
    ),
    "missioncore.worker-telemetry/v1",
@@ -23,7 +23,8 @@ export type WorkspaceKind =
  | "datasets"
  | "artifact-health"
  | "lab-archive"
-  | "simulations";
+  | "simulations"
+  | "observatory";

 export type CapabilityStatus = "active" | "ready" | "contract" | "later";

@@ -166,6 +167,17 @@ export const workspaces: WorkspaceDefinition[] = [
    kind: "simulations",
    groups: [],
  },
+  {
+    id: "observatory",
+    root: "polygon",
+    label: "Обсерватория",
+    title: "AI inference",
+    eyebrow: "ТЕСТОВЫЙ КОНТУР / ОБСЕРВАТОРИЯ",
+    description: "Сессии и квалификация без доступа к управлению.",
+    icon: "eye",
+    kind: "observatory",
+    groups: [],
+  },
  {
    id: "contour-health",
    root: "fleet",
@@ -21,6 +21,7 @@
@import "./styles/device.css";
@import "./styles/responsive.css";
@import "./styles/observation.css";
+@import "./styles/observatory.css";
@import "./styles/environment-settings.css";
@import "./styles/system-telemetry.css";
@import "./styles/artifact-health.css";
@@ -27,6 +27,78 @@
  display: block;
 }

+.m4-replay-threat-visual__unified-content {
+  position: absolute;
+  z-index: 1;
+  inset: 0;
+  min-width: 0;
+  min-height: 0;
+}
+
+.m4-replay-threat-visual__unified-content > *,
+.m4-replay-threat-visual__unified-content .rerun-viewport {
+  width: 100%;
+  height: 100%;
+}
+
+.m4-replay-threat-visual__deck[data-native-rerun="true"] > .nodedc-split-pane {
+  position: relative;
+  z-index: 2;
+  pointer-events: none;
+}
+
+.m4-replay-threat-visual__deck[data-native-rerun="true"]
+  .m4-replay-threat-visual__pane {
+  background: transparent;
+  pointer-events: none;
+}
+
+.m4-replay-threat-visual__deck[data-native-rerun="true"]
+  .nodedc-split-pane__separator,
+.m4-replay-threat-visual__deck[data-native-rerun="true"]
+  .m4-replay-threat-visual__pane-toolbar,
+.m4-replay-threat-visual__deck[data-native-rerun="true"]
+  .m4-replay-threat-visual__pane-toolbar * {
+  pointer-events: auto;
+}
+
+.canonical-vegetation-rerun-replay {
+  width: 100%;
+  min-width: 0;
+}
+
+.canonical-vegetation-rerun-replay:not([data-presentation-state="ready"])
+  .m4-replay-threat-visual__pane-toolbar,
+.canonical-vegetation-rerun-replay:not([data-presentation-state="ready"])
+  .laboratory-evidence-viewer__controls,
+.canonical-vegetation-rerun-replay:not([data-presentation-state="ready"])
+  .laboratory-evidence-viewer__transport {
+  visibility: hidden;
+  pointer-events: none;
+}
+
+.canonical-vegetation-rerun-replay[data-presentation-state="loading"]
+  .m4-replay-threat-visual__unified-content {
+  visibility: hidden;
+}
+
+.canonical-vegetation-rerun-replay__viewport-lock {
+  width: 100%;
+  height: 100%;
+  min-width: 0;
+  min-height: 0;
+}
+
+.canonical-vegetation-rerun-replay__loading {
+  position: absolute;
+  z-index: 6;
+  inset: 0;
+  display: grid;
+  place-items: center;
+  background: var(--nodedc-canvas);
+  pointer-events: none;
+}
+
 .m4-replay-threat-visual__deck[data-empty="true"] > .l3-visual-audit__state {
  position: absolute;
  z-index: 1;
@@ -73,29 +145,16 @@
  display: flex;
  min-width: 0;
  align-items: center;
+  align-content: flex-start;
+  flex-wrap: wrap;
  gap: 0.35rem;
  pointer-events: none;
 }

 .m4-replay-threat-visual__pane-toolbar[data-pane-toolbar="media"] {
-  justify-content: flex-end;
-}
-
-.m4-replay-threat-visual__pane-toolbar[data-pane-toolbar="media"][data-multi-semantic="true"] {
-  flex-wrap: wrap;
-}
-
-.m4-replay-threat-visual__pane-toolbar[data-pane-toolbar="media"][data-multi-semantic="true"]
-  > .m4-replay-threat-visual__pane-layer-controls {
-  flex: 1 0 100%;
  justify-content: flex-start;
 }

-.m4-replay-threat-visual__pane-toolbar[data-pane-toolbar="media"][data-multi-semantic="true"]
-  > .m4-replay-threat-visual__pane-mode-controls {
-  margin-left: auto;
-}
-
 .m4-replay-threat-evidence-viewer[data-mode-controls="content"]:has(
  .m4-replay-threat-visual__review-controls
 ) .m4-replay-threat-visual__pane-toolbar[data-pane-toolbar="media"] {
@@ -103,12 +162,17 @@
 }

 .m4-replay-threat-visual__pane-toolbar[data-pane-toolbar="spatial"] {
-  justify-content: space-between;
+  justify-content: flex-start;
 }

 .m4-replay-threat-evidence-viewer[data-mode-controls="content"]
-  .m4-replay-threat-visual__pane-toolbar[data-pane-toolbar="spatial"] {
-  right: 3.8rem;
+  .m4-replay-threat-visual__pane-toolbar[data-pane-toolbar="spatial"],
+.m4-replay-threat-evidence-viewer[data-mode-controls="content"]
+  .m4-replay-threat-visual__deck:not([data-split="true"])
+  .m4-replay-threat-visual__pane-toolbar[data-pane-toolbar="media"] {
+  /* The two viewer-wide actions stay at the deck's right edge. Keep their
+     complete hit area out of this viewport-owned toolbar at every split. */
+  right: 7rem;
 }

 .m4-replay-threat-visual__pane-toolbar > *,
@@ -117,18 +181,15 @@
 }

 .m4-replay-threat-visual__spatial-toolbar-end {
-  display: flex;
-  min-width: 0;
-  align-items: center;
-  justify-content: flex-end;
-  gap: 0.35rem;
-  overflow-x: auto;
-  overscroll-behavior-inline: contain;
-  scrollbar-width: none;
+  display: contents;
 }

-.m4-replay-threat-visual__spatial-toolbar-end::-webkit-scrollbar {
-  display: none;
+.m4-replay-threat-visual__pane-toolbar > .m4-replay-threat-visual__pane-layer-controls,
+.m4-replay-threat-visual__spatial-toolbar-end > .m4-replay-threat-visual__pane-layer-controls {
+  /* A viewport toolbar is one adaptive flex sequence. `display: contents`
+     keeps the semantic layer group while allowing each control to move to the
+     next row only when the viewport itself runs out of width. */
+  display: contents;
 }

 .m4-replay-threat-visual__pane-mode-controls {
@@ -177,7 +238,8 @@
  display: flex;
  align-items: center;
  gap: 0.4rem;
-  border: 1px solid var(--nodedc-glass-outline);
+  border: 0;
+  outline: 0;
  border-radius: var(--nodedc-radius-control-compact);
  background: var(--nodedc-floating-surface);
  padding: 0.42rem 0.58rem;
@@ -198,6 +260,15 @@
  pointer-events: none;
 }

+.canonical-vegetation-rerun-replay
+  .m4-replay-threat-evidence-viewer[data-mode-controls="content"]
+  .laboratory-evidence-viewer__controls {
+  right: 0.6rem;
+  left: auto;
+  width: auto;
+  justify-content: flex-end;
+}
+
 .m4-replay-threat-evidence-viewer[data-mode-controls="content"] .laboratory-evidence-viewer__controls > .nodedc-icon-button {
  pointer-events: auto;
 }
@@ -222,6 +293,30 @@
  scrollbar-width: none;
 }

+.m4-replay-threat-visual__layer-with-settings {
+  display: inline-flex;
+  flex: none;
+  align-items: center;
+  gap: 0.18rem;
+  border: 0;
+  border-radius: 999px;
+  background: var(--nodedc-glass-control-bg);
+  padding: 0.12rem;
+}
+
+.m4-replay-threat-visual__layer-with-settings > .nodedc-icon-button {
+  width: 1.75rem;
+  height: 1.75rem;
+  border: 0;
+  outline: 0;
+  box-shadow: none;
+}
+
+.m4-replay-threat-visual__layer-with-settings > .nodedc-icon-button:focus-visible {
+  background: var(--nodedc-focus-surface);
+  box-shadow: inset 0 0 0 1px rgb(var(--nodedc-accent-rgb) / 0.22);
+}
+
 .m4-replay-threat-visual__review-controls,
 .m4-replay-threat-visual__review-controls > *,
 .m4-replay-threat-visual__single-pane-controls,
@@ -247,6 +342,10 @@
  grid-template-columns: auto auto auto minmax(0, 1fr) auto;
 }

+.canonical-vegetation-rerun-replay__timeline .observation-timeline__playback {
+  grid-template-columns: auto auto minmax(0, 1fr) auto;
+}
+
 .m4-replay-threat-visual__overlay {
  box-sizing: border-box;
  min-width: 0;
@@ -0,0 +1,640 @@
+.observatory-workspace {
+  display: grid;
+  grid-auto-rows: max-content;
+  align-content: start;
+  gap: 1rem;
+  min-width: 0;
+  min-height: 100%;
+  padding: 1rem;
+  container-name: observatory-workspace;
+  container-type: inline-size;
+}
+
+.observatory-catalog-bar,
+.observatory-catalog-bar__controls,
+.observatory-notice,
+.observatory-evidence > header {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 1rem;
+}
+
+.observatory-notice {
+  flex-wrap: wrap;
+}
+
+.observatory-catalog-bar__copy,
+.observatory-evidence header > div {
+  min-width: 0;
+}
+
+.observatory-catalog-bar h3,
+.observatory-session-summary h3,
+.observatory-evidence h3 {
+  margin: 0.3rem 0 0;
+}
+
+.observatory-catalog-bar h3,
+.observatory-session-summary h3,
+.observatory-evidence h3 {
+  font-size: var(--nodedc-font-size-lg);
+  letter-spacing: -0.02em;
+  line-height: 1.15;
+}
+
+.observatory-state p,
+.observatory-evidence-empty p {
+  max-width: 52rem;
+  margin: 0.35rem 0 0;
+  color: var(--nodedc-text-muted);
+  font-size: var(--nodedc-font-size-sm);
+  line-height: 1.35;
+}
+
+.observatory-catalog-bar,
+.observatory-session-summary {
+  align-self: start;
+  min-height: 0;
+}
+
+.observatory-catalog-bar__copy {
+  display: grid;
+  flex: 0 0 auto;
+  align-content: center;
+  gap: 0.1rem;
+}
+
+.observatory-catalog-bar h3 {
+  margin-top: 0.1rem;
+}
+
+.observatory-catalog-bar__controls {
+  min-width: 0;
+  flex: 1 1 auto;
+  flex-wrap: nowrap;
+  justify-content: flex-end;
+}
+
+.observatory-catalog-bar__controls .nodedc-select-anchor {
+  flex: 1 1 18rem;
+  min-width: 0;
+}
+
+.observatory-catalog-bar__controls > .nodedc-button {
+  flex: 0 0 auto;
+}
+
+.observatory-catalog-bar__run {
+  display: flex;
+  flex: 0 0 auto;
+  align-items: center;
+  gap: 0.55rem;
+}
+
+.observatory-state {
+  display: grid;
+  min-height: 19rem;
+  place-items: center;
+  align-content: center;
+  gap: 0.7rem;
+  text-align: center;
+}
+
+.observatory-state h3 {
+  max-width: 42rem;
+  margin: 0;
+}
+
+.observatory-session-stack {
+  display: grid;
+  grid-auto-rows: max-content;
+  align-content: start;
+  gap: 0.9rem;
+  container-name: observatory-session;
+  container-type: inline-size;
+}
+
+.observatory-session-summary {
+  display: grid;
+  grid-template-columns: minmax(11rem, 1.05fr) minmax(20rem, 1.6fr) minmax(11rem, auto);
+  align-items: center;
+  gap: 0.75rem;
+}
+
+.observatory-session-summary__identity {
+  display: grid;
+  min-width: 0;
+  gap: 0.22rem;
+}
+
+.observatory-session-summary__identity h3 {
+  margin: 0.1rem 0 0;
+}
+
+.observatory-session-summary__identity code {
+  overflow: hidden;
+  color: var(--nodedc-text-muted);
+  font-size: var(--nodedc-font-size-xs);
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.observatory-session-summary__facts {
+  display: grid;
+  grid-template-columns: repeat(3, minmax(6.5rem, 1fr));
+  gap: 0.75rem;
+  margin: 0;
+}
+
+.observatory-session-summary__facts > div {
+  display: grid;
+  min-width: 0;
+  gap: 0.24rem;
+}
+
+.observatory-session-summary__facts dt {
+  color: var(--nodedc-text-muted);
+  font-size: var(--nodedc-font-size-xs);
+}
+
+.observatory-session-summary__facts dd {
+  min-width: 0;
+  margin: 0;
+  overflow-wrap: anywhere;
+  color: var(--nodedc-text-secondary);
+  font-size: var(--nodedc-font-size-sm);
+  line-height: 1.35;
+}
+
+.observatory-session-summary__end {
+  display: grid;
+  min-width: 0;
+  justify-items: end;
+  gap: 0.4rem;
+}
+
+.observatory-modalities {
+  display: flex;
+  flex-wrap: wrap;
+  justify-content: flex-end;
+  gap: 0.45rem;
+  align-items: center;
+  color: var(--nodedc-text-muted);
+}
+
+.observatory-evidence {
+  display: grid;
+  gap: 0.65rem;
+}
+
+.observatory-evidence > header {
+  padding: 0 0.2rem;
+}
+
+.observatory-evidence__ordering {
+  display: flex;
+  flex: none;
+  align-items: center;
+  gap: 0.55rem;
+}
+
+.observatory-evidence__sort {
+  display: grid;
+  width: 1.7rem;
+  height: 1.7rem;
+  place-items: center;
+  border: 0;
+  outline: 0;
+  border-radius: 0;
+  background: transparent;
+  padding: 0;
+  color: var(--nodedc-text-secondary);
+  cursor: pointer;
+}
+
+.observatory-evidence__sort:hover,
+.observatory-evidence__sort:focus-visible {
+  background: var(--nodedc-glass-control-bg);
+  color: var(--nodedc-text-primary);
+}
+
+.observatory-evidence__sort svg {
+  width: 1.1rem;
+  height: 1.1rem;
+  transition: transform 160ms ease-out;
+}
+
+.observatory-evidence__sort path {
+  fill: none;
+  stroke: currentColor;
+  stroke-linecap: round;
+  stroke-width: 1.5;
+}
+
+.observatory-evidence__sort[data-direction="oldest"] svg {
+  transform: rotate(180deg);
+}
+
+.observatory-evidence-list {
+  display: grid;
+  gap: 0.4rem;
+  margin: 0;
+  padding: 0;
+  list-style: none;
+}
+
+.observatory-evidence-card {
+  display: grid;
+  grid-template-columns: auto minmax(0, 1fr) auto auto;
+  align-items: center;
+  gap: 0.8rem;
+  min-height: 4.25rem;
+  padding: 0.7rem 0.85rem;
+  border-radius: var(--nodedc-radius-control-compact);
+  background: var(--nodedc-glass-control-bg);
+}
+
+.observatory-evidence-card__icon {
+  display: grid;
+  width: 2.15rem;
+  height: 2.15rem;
+  place-items: center;
+  border-radius: var(--nodedc-radius-circle);
+  background: var(--nodedc-panel-icon-bg);
+  color: var(--nodedc-text-secondary);
+}
+
+.observatory-evidence-card__copy {
+  display: grid;
+  min-width: 0;
+  gap: 0.16rem;
+}
+
+.observatory-evidence-card__copy strong,
+.observatory-evidence-card__copy span,
+.observatory-evidence-card__copy small {
+  min-width: 0;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.observatory-evidence-card__copy strong {
+  overflow: visible;
+  text-overflow: clip;
+  white-space: normal;
+  font-size: var(--nodedc-font-size-sm);
+  line-height: 1.3;
+}
+
+.observatory-evidence-card__copy span {
+  color: var(--nodedc-text-secondary);
+  font-size: var(--nodedc-font-size-sm);
+}
+
+.observatory-evidence-card__copy small {
+  color: var(--nodedc-text-muted);
+  font-size: var(--nodedc-font-size-xs);
+}
+
+.observatory-evidence-card--progress {
+  grid-template-columns: auto minmax(0, 1fr) auto auto;
+  border: 0;
+  outline: 0;
+}
+
+.observatory-evidence-card__progress {
+  height: 0.28rem;
+  margin: 0.18rem 0 0.08rem;
+  overflow: hidden;
+  border-radius: 999px;
+  background: rgb(var(--nodedc-accent-rgb) / 0.12);
+}
+
+.observatory-evidence-card__progress > span {
+  display: block;
+  height: 100%;
+  border-radius: inherit;
+  background: rgb(var(--nodedc-accent-rgb));
+  transition: width 180ms ease-out;
+}
+
+.observatory-evidence-card__actions,
+.observatory-replay__header,
+.observatory-replay-state,
+.observatory-replay-state__actions {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 0.85rem;
+}
+
+.observatory-replay-state {
+  flex-wrap: wrap;
+}
+
+.observatory-replay__header > div,
+.observatory-replay-state > div {
+  min-width: 0;
+}
+
+.observatory-evidence-card__actions:empty {
+  display: none;
+}
+
+.observatory-replay,
+.observatory-replay-state {
+  min-width: 0;
+}
+
+.observatory-replay {
+  display: grid;
+  gap: 0.85rem;
+  font-family: var(--nodedc-font-family);
+}
+
+.observatory-replay__header {
+  padding: 0.25rem 0.25rem 0;
+}
+
+.observatory-replay__header h3,
+.observatory-replay-state h3 {
+  margin: 0.3rem 0 0;
+}
+
+.observatory-replay__header h3 {
+  font-size: var(--nodedc-font-size-sm);
+  line-height: 1.3;
+}
+
+.observatory-replay__header p,
+.observatory-replay-state p,
+.observatory-replay__description {
+  margin: 0.35rem 0 0;
+  color: var(--nodedc-text-muted);
+  font-family: var(--nodedc-font-family);
+  font-size: var(--nodedc-font-size-sm);
+  font-weight: var(--nodedc-font-weight-regular);
+  line-height: 1.35;
+}
+
+.observatory-replay__description {
+  margin-right: 0.25rem;
+  margin-left: 0.25rem;
+}
+
+.observatory-replay .m4-replay-threat-visual__buffering {
+  border: 0;
+  outline: 0;
+}
+
+.observatory-replay .laboratory-evidence-viewer {
+  border: 0;
+  outline: 0;
+  border-radius: 0;
+  box-shadow: none;
+}
+
+.observatory-evidence-empty {
+  display: grid;
+  min-height: 13rem;
+  place-items: center;
+  align-content: center;
+  gap: 0.55rem;
+  text-align: center;
+}
+
+.observatory-notice {
+  justify-content: flex-start;
+  color: var(--nodedc-text-secondary);
+}
+
+.observatory-notice__copy {
+  min-width: 0;
+  flex: 1 1 auto;
+}
+
+.observatory-rename-form,
+.observatory-delete-confirmation {
+  display: grid;
+  gap: 0.75rem;
+}
+
+.observatory-delete-confirmation p,
+.observatory-mutation-error {
+  margin: 0;
+  line-height: 1.5;
+}
+
+.observatory-mutation-error {
+  color: rgb(var(--nodedc-danger-rgb));
+  font-size: var(--nodedc-font-size-sm);
+}
+
+@container observatory-session (max-width: 46rem) {
+  .observatory-session-summary {
+    grid-template-columns: minmax(0, 1fr);
+    align-items: start;
+  }
+
+  .observatory-session-summary__end,
+  .observatory-modalities {
+    justify-items: start;
+    justify-content: flex-start;
+  }
+}
+
+@container observatory-session (max-width: 48rem) {
+  .observatory-evidence-card {
+    grid-template-columns: auto minmax(0, 1fr) auto;
+  }
+
+  .observatory-evidence-card > .nodedc-status {
+    display: none;
+  }
+}
+
+@container observatory-session (max-width: 38rem) {
+  .observatory-session-summary__facts {
+    grid-template-columns: minmax(0, 1fr);
+  }
+
+  .observatory-evidence-card__copy small {
+    white-space: normal;
+  }
+}
+
+@container observatory-workspace (max-width: 920px) {
+  .observatory-catalog-bar,
+  .observatory-catalog-bar__controls,
+  .observatory-notice {
+    align-items: stretch;
+    flex-direction: column;
+  }
+
+  .observatory-catalog-bar__controls {
+    flex-basis: auto;
+  }
+
+  .observatory-catalog-bar__controls .nodedc-select-anchor {
+    flex: 0 0 auto;
+    width: 100%;
+    min-width: 0;
+  }
+
+  .observatory-catalog-bar__run {
+    justify-content: flex-end;
+  }
+}
+
+@media (max-width: 920px) {
+  .observatory-replay__header,
+  .observatory-replay-state {
+    align-items: stretch;
+    flex-direction: column;
+  }
+}
+.observatory-ai-config {
+  display: grid;
+  gap: var(--nodedc-space-4);
+}
+
+.observatory-ai-config__lead,
+.observatory-ai-config__error {
+  margin: 0;
+  color: var(--nodedc-text-secondary);
+  font-size: var(--nodedc-font-size-sm);
+  line-height: 1.45;
+}
+
+.observatory-ai-config__error {
+  color: rgb(var(--nodedc-danger-rgb));
+}
+
+.observatory-ai-config__duplicate {
+  margin-right: auto;
+  color: var(--nodedc-text-secondary);
+  font-size: var(--nodedc-font-size-sm);
+  line-height: 1.4;
+}
+
+@keyframes observatory-ai-calculate-pulse {
+  0%,
+  100% {
+    background-color: var(--nodedc-primary-action-bg);
+  }
+
+  50% {
+    background-color: color-mix(
+      in srgb,
+      var(--nodedc-primary-action-bg) 88%,
+      var(--nodedc-canvas-soft)
+    );
+  }
+}
+
+.observatory-ai-config__calculate--saving:disabled {
+  animation: observatory-ai-calculate-pulse 1.8s ease-in-out infinite;
+  cursor: progress;
+  opacity: 1;
+}
+
+.observatory-ai-config-window {
+  border: 0;
+  outline: 0;
+  box-shadow: var(--nodedc-shadow-window);
+}
+
+.observatory-ai-config-window::before,
+.observatory-ai-config-window::after {
+  display: none;
+}
+
+.observatory-ai-module-group {
+  overflow: hidden;
+  border: 0;
+  outline: 0;
+  border-radius: var(--nodedc-radius-control-compact);
+  background: var(--nodedc-glass-control-bg);
+}
+
+.observatory-ai-module-group > header {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: var(--nodedc-space-3);
+  padding: var(--nodedc-space-3) var(--nodedc-space-4);
+  border: 0;
+  outline: 0;
+}
+
+.observatory-ai-module-group > header > div {
+  display: grid;
+  min-width: 0;
+  gap: 0.2rem;
+}
+
+.observatory-ai-module-group > header .nodedc-status {
+  min-width: 0;
+  max-width: 55%;
+  overflow: hidden;
+  text-overflow: ellipsis;
+}
+
+.observatory-ai-module-group > header span {
+  color: var(--nodedc-text-muted);
+  font-size: var(--nodedc-font-size-xs);
+}
+
+.observatory-ai-module-group__body {
+  padding: var(--nodedc-space-4);
+  border: 0;
+  outline: 0;
+}
+
+.observatory-ai-module-group__body .nodedc-select-anchor {
+  width: 100%;
+}
+
+.observatory-ai-config-window .nodedc-select-trigger,
+.observatory-ai-config-window .nodedc-window__close {
+  border: 0;
+  outline: 0;
+  box-shadow: none;
+}
+
+.observatory-ai-config-window .nodedc-select-trigger:focus-visible,
+.observatory-ai-config-window .nodedc-window__close:focus-visible {
+  background-color: var(--nodedc-focus-surface);
+  box-shadow:
+    var(--nodedc-glass-control-shadow),
+    inset 0 0 0 1px rgb(var(--nodedc-accent-rgb) / 0.22);
+}
+
+@media (max-width: 560px) {
+  .observatory-ai-config-window .nodedc-window__title {
+    white-space: normal;
+  }
+
+  .observatory-ai-module-group > header {
+    align-items: flex-start;
+    flex-direction: column;
+  }
+
+  .observatory-ai-module-group > header .nodedc-status {
+    max-width: 100%;
+    justify-content: flex-start;
+  }
+}
+
+@media (prefers-reduced-motion: reduce) {
+  .observatory-ai-config__calculate--saving:disabled {
+    animation: none;
+    background-color: color-mix(
+      in srgb,
+      var(--nodedc-primary-action-bg) 94%,
+      var(--nodedc-canvas-soft)
+    );
+  }
+}
@@ -78,7 +78,7 @@
  overflow: hidden;
 }

-/* Rerun WebViewer 0.34.1 keeps three fixed 24px canvas rows even after its
+/* The upstream Rerun canvas keeps three fixed 24px rows even after its
   panels are overridden: the native top row, recording tab and view tab.
   They are drawn inside WASM and cannot be styled independently, so crop the
   fixed native chrome while keeping the actual 3D viewport full-height. */
@@ -88,6 +88,13 @@
  height: calc(100% + var(--rerun-native-chrome-height));
 }

+.rerun-viewport__runtime {
+  display: block;
+  width: 100%;
+  height: 100%;
+  border: 0;
+}
+
 .rerun-viewport__canvas canvas {
  display: block;
  width: 100% !important;
@@ -41,6 +41,7 @@ import { SimulationWorkspace } from "./simulation/SimulationWorkspace";
 import { ComputeModulesWorkspace } from "./system/ComputeModulesWorkspace";
 import { NetworkWorkspace } from "./system/NetworkWorkspace";
 import { WorldMapWorkspace } from "./map/WorldMapWorkspace";
+import { ObservatoryWorkspace } from "./observatory/ObservatoryWorkspace";
 function statusTone(status: CapabilityStatus): "success" | "accent" | "warning" | "neutral" {
  if (status === "active") return "success";
  if (status === "ready") return "accent";
@@ -1191,6 +1192,8 @@ export function WorkspaceRenderer(props: WorkspaceRendererProps) {
      );
    case "simulations":
      return <SimulationWorkspace />;
+    case "observatory":
+      return <ObservatoryWorkspace definition={props.definition} />;
    case "device":
      return null;
  }
@@ -0,0 +1 @@
+export { CanonicalVegetationRerunReplay } from "../../components/laboratory/CanonicalVegetationRerunReplay";
@@ -54,6 +54,7 @@ import {
  buildLaboratoryProfiles,
  experimentOptionsForProfile,
  freshestLaboratorySelection,
+  isLegacyPublishedLaboratoryWork,
  workOptionsForExperiment,
 } from "./laboratoryArchiveProfiles";
 import {
@@ -499,12 +500,7 @@ export function LaboratoryArchiveWorkspace(props: LaboratoryWorkspaceProps) {
    onDeleteBegin: props.sessionArchive.onDeleteBegin,
  });
  const publishedWorks = useMemo(
-    () => sessions.items.filter((session) => (
-      session.lab !== null
-      && session.status === "ready"
-      && session.replayable
-      && session.modalities.includes("point-cloud")
-    )).sort((left, right) => (
+    () => sessions.items.filter(isLegacyPublishedLaboratoryWork).sort((left, right) => (
      Date.parse(right.lab?.runCreatedAtUtc ?? right.startedAtUtc)
      - Date.parse(left.lab?.runCreatedAtUtc ?? left.startedAtUtc)
    )),
@@ -1,4 +1,4 @@
-import { useEffect, useMemo, useState } from "react";
+import { useEffect, useState } from "react";

 import {
  LaboratoryEvidence,
@@ -7,7 +7,6 @@ import {
  LaboratoryWorkTemplate,
 } from "../../components/laboratory/LaboratoryPresentation";
 import {
-  vegetationFullRouteMaskUrl,
  vegetationVideoMaskUrl,
  type VegetationFullRouteReview,
  type VegetationShadowResult,
@@ -17,13 +16,7 @@ import {
  type M49TgsFullShadowResult,
 } from "../../core/laboratory/m49TgsFullShadow";
 import { M49TgsFullShadowEvidence } from "./M49TgsFullShadowEvidence";
-import {
-  M4ReplayThreatVisual,
-  type M4ReplayClassifiedSpatialLayer,
-  type M4ReplayThreatSemanticLayer,
-} from "./M4ReplayThreatVisual";
-
-const VEGETATION_TIMELINE_ENDPOINT = "/api/v1/laboratory/vegetation-shadow";
+import { CanonicalVegetationRerunReplay } from "./CanonicalVegetationRerunReplay";

 function decimal(value: number, digits = 1): string {
  return value.toLocaleString("ru-RU", { maximumFractionDigits: digits });
@@ -36,56 +29,7 @@ function FullRouteReviewEvidence({
  resultId: string;
  review: VegetationFullRouteReview;
 }) {
-  const semanticLayers = useMemo<readonly M4ReplayThreatSemanticLayer[]>(() => ([
-    {
-      id: "city",
-      controlLabel: "ГОРОД · EoMT",
-      resultId,
-      spatialResultId: null,
-      taxonomy: review.city.taxonomy,
-      maskUrl: (sequence) => vegetationFullRouteMaskUrl(resultId, "city", sequence),
-      label: review.city.name,
-      maskAriaLabel: "EoMT city semantic prediction",
-    },
-    {
-      id: "vegetation",
-      controlLabel: "ПРИРОДА · DDRNet",
-      resultId,
-      spatialResultId: null,
-      taxonomy: review.vegetation.taxonomy,
-      maskUrl: (sequence) => vegetationFullRouteMaskUrl(resultId, "vegetation", sequence),
-      label: review.vegetation.name,
-      maskAriaLabel: "DDRNet nature semantic prediction",
-    },
-  ]), [resultId, review.city, review.vegetation]);
-  const sealedSpatialGap = useMemo<M4ReplayClassifiedSpatialLayer>(() => ({
-    label: "RAVNOVES004TREE",
-    pointLayerLabel: "SOURCE POINTS",
-    cellLayerLabel: "TGS COSTMAP",
-    cellLayerAvailable: false,
-    expectedAtSequence: false,
-    frame: null,
-    loading: false,
-    error: null,
-    replacePointCloud: false,
-  }), []);
-
-  return (
-    <M4ReplayThreatVisual
-      resultId={resultId}
-      timelineEndpointRoot={VEGETATION_TIMELINE_ENDPOINT}
-      semanticLayers={semanticLayers}
-      initialSemanticLayerId="vegetation"
-      initialSpatialMode="3d"
-      classifiedSpatialLayer={sealedSpatialGap}
-      evidenceLabel="RAVNOVES004TREE"
-      playbackTransport="segmented"
-      spatialPlaybackTransport="sealed-binary"
-      recoverTimestampStalls
-      showReferenceMediaLayers
-      showSpatialOverlaySummary
-    />
-  );
+  return <CanonicalVegetationRerunReplay resultId={resultId} review={review} />;
 }

 function FullRouteReviewResult({
@@ -102,16 +46,16 @@ function FullRouteReviewResult({
      summary={(
        <LaboratorySummary
          title="LAB V1 · RAVNOVES004TREE · полный маршрут"
-          description="Принятый recorded-LAB инструмент воспроизводит RAV004 без отдельного viewer: одна media-clock timeline, RIGHT camera, source points, bounded Local SLAM и переключаемые EoMT/DDRNet."
-          status="FULL RECORDED REVIEW · truth отсутствует · commands OFF"
+          description="Принятый инструмент записанной LAB воспроизводит RAV004 без отдельного viewer: единый таймлайн, правая камера, исходные точки, ограниченный Local SLAM и переключаемые EoMT/DDRNet."
+          status="ПОЛНЫЙ ПРОСМОТР ЗАПИСИ · эталон отсутствует · команды ВЫКЛ"
          statusTone="warning"
          facts={[
-            { label: "Источник", value: `${review.sourceId} · ${review.frameCount}/${review.frameCount} camera frames` },
-            { label: "3D", value: "1444 source cloud increments · gravity-stable RFU → body" },
-            { label: "Город", value: `${review.city.name} · ${decimal(review.city.inferenceFps, 2)} fps` },
-            { label: "Природа", value: `${review.vegetation.name} · ${decimal(review.vegetation.inferenceFps, 2)} fps` },
-            { label: "TGS", value: "10 review anchors существуют · full-route artifact отсутствует" },
-            { label: "Authority", value: `${rigLabel} · VISUAL REVIEW ONLY · commands OFF` },
+            { label: "Источник", value: `${review.sourceId} · ${review.frameCount}/${review.frameCount} кадров камеры` },
+            { label: "3D", value: "1444 приращения исходного облака · стабильная по гравитации RFU → корпус" },
+            { label: "Город", value: `${review.city.name} · ${decimal(review.city.inferenceFps, 2)} кадра/с` },
+            { label: "Природа", value: `${review.vegetation.name} · ${decimal(review.vegetation.inferenceFps, 2)} кадра/с` },
+            { label: "TGS", value: "существуют 10 контрольных якорей · артефакт полного маршрута отсутствует" },
+            { label: "Полномочия", value: `${rigLabel} · ТОЛЬКО ВИЗУАЛЬНЫЙ ПРОСМОТР · команды ВЫКЛ` },
          ]}
          brief={{
            question: "Что реально видно на полном RAV004-прогоне с высокой травой, оврагами и переходом к городу?",
@@ -134,8 +78,8 @@ function FullRouteReviewResult({
      )}
      evidence={(
        <LaboratoryEvidence
-          eyebrow="CANONICAL RECORDED LAB · RAVNOVES004TREE"
-          title="CAMERA + SOURCE POINTS + LOCAL SLAM + TGS COSTMAP + SEMANTICS · 6830/6830"
+          eyebrow="КАНОНИЧЕСКАЯ ЗАПИСАННАЯ LAB · RAVNOVES004TREE"
+          title="КАМЕРА + ИСХОДНЫЕ ТОЧКИ + ЛОКАЛЬНЫЙ SLAM + КАРТА TGS + СЕМАНТИКА · 6830/6830"
          kind="recorded-replay"
          resizable
        >
@@ -145,18 +89,18 @@ function FullRouteReviewResult({
      result={(
        <LaboratoryResultSummary
          title="RAV004 переведён на общий replay-каркас; safety evidence ещё не полно"
-          status="Recorded evidence · navigation/actuation OFF"
+          status="Записанные доказательства · навигация/управление ВЫКЛ"
          statusTone="warning"
          metrics={[
-            { label: "Camera timeline", value: "6830 frames · ≈9.51 Hz", hint: "media clock owns video, overlays and spatial" },
-            { label: "Source geometry", value: "1444 increments · ≈2 Hz", hint: "last proven spatial frame is held between source arrivals" },
-            { label: "EoMT throughput", value: `${decimal(review.city.inferenceFps, 2)} fps`, hint: "изолированный full pass; не realtime stack" },
-            { label: "DDRNet throughput", value: `${decimal(review.vegetation.inferenceFps, 2)} fps`, hint: "изолированный full pass; temporal stability не принята" },
+            { label: "Таймлайн камеры", value: "6830 кадров · ≈9,51 Гц", hint: "единые часы управляют видео, слоями и пространством" },
+            { label: "Исходная геометрия", value: "1444 приращения · ≈2 Гц", hint: "между поступлениями удерживается последний подтверждённый пространственный кадр" },
+            { label: "Пропускная способность EoMT", value: `${decimal(review.city.inferenceFps, 2)} кадра/с`, hint: "изолированный полный прогон; не стек реального времени" },
+            { label: "Пропускная способность DDRNet", value: `${decimal(review.vegetation.inferenceFps, 2)} кадра/с`, hint: "изолированный полный прогон; временная стабильность не принята" },
          ]}
          conclusion={{
-            proved: "Camera, seek, spatial layers and semantic switching use one accepted reusable viewer and one media clock; RFU source geometry no longer inherits LiDAR roll/pitch.",
-            notProved: "Не доказаны continuous TGS, независимый detector/STOP, truth accuracy, temporal stability DDRNet и ≥10 FPS совместного live stack.",
-            decision: "Продолжать как visual audit. До запечатанного full-route TGS и detector/load gate navigation/actuation остаются OFF.",
+            proved: "Камера, перемотка, пространственные слои и переключение семантики используют один принятый переиспользуемый viewer и единые часы; исходная геометрия RFU больше не наследует крен и тангаж LiDAR.",
+            notProved: "Не доказаны непрерывная TGS, независимый детектор/STOP, точность относительно эталона, временная стабильность DDRNet и ≥10 кадров/с совместного стека реального времени.",
+            decision: "Продолжать как визуальный аудит. До запечатанной TGS полного маршрута и барьера детектора/нагрузки навигация и управление остаются выключенными.",
          }}
        />
      )}
@@ -459,6 +459,17 @@ function pipelineIdForSession(session: ObservationSessionSummary): string {
  return session.lab?.resultKind ?? "legacy-perception";
 }

+/** Keep capability projections owned by Observatory out of the legacy LAB surface. */
+export function isLegacyPublishedLaboratoryWork(
+  session: ObservationSessionSummary,
+): boolean {
+  return session.lab !== null
+    && session.lab.replayCapability === null
+    && session.status === "ready"
+    && session.replayable
+    && session.modalities.includes("point-cloud");
+}
+
 export function buildLaboratoryCatalog({
  rigLabel,
  knownWorks,
@@ -17,9 +17,14 @@ import {
 } from "../../core/system/useWorkerTelemetry";

 function pipelineStateLabel(state: string): string {
-  if (state === "busy") return "Выполняет задачу";
+  if (state === "busy" || state === "running") return "Выполняет задачу";
+  if (state === "waiting") return "Ожидает восстановления данных";
+  if (state === "synchronizing") return "Синхронизирует поток";
+  if (state === "starting") return "Загружает профиль";
+  if (state === "stopped" || state === "cancelled") return "Профиль остановлен";
+  if (state === "failed") return "Ошибка профиля";
  if (state === "ready") return "Готов к задаче";
-  return "Нет live-состояния";
+  return "Нет свежих данных о задаче";
 }

 function formatResourcePair(
@@ -116,7 +121,7 @@ export function ComputeModulesWorkspace() {
      {!legacyDiagnostic && !agentTelemetry ? (
        <GlassSurface className="system-workspace__notice" padding="md" tone="soft">
          <StatusBadge tone="warning">
-            Агентный data-plane ещё не опубликовал нормализованный срез этого контура.
+            Ожидаем свежую телеметрию выбранного узла.
          </StatusBadge>
        </GlassSurface>
      ) : null}
@@ -187,6 +192,8 @@ export function ComputeModulesWorkspace() {
                ? `${node.gpu.temperature_celsius} °C`
                : "—"
            }</dd></div>
+            <div><dt>Частота GPU</dt><dd>{node?.gpu?.sm_clock_mhz == null ? "—" : `${node.gpu.sm_clock_mhz} МГц`}</dd></div>
+            <div><dt>Частота памяти GPU</dt><dd>{node?.gpu?.memory_clock_mhz == null ? "—" : `${node.gpu.memory_clock_mhz} МГц`}</dd></div>
            <div><dt>Мощность</dt><dd>{
              typeof node?.gpu?.power_watts === "number"
                ? `${node.gpu.power_watts.toFixed(1)} Вт`
@@ -214,7 +221,7 @@ export function ComputeModulesWorkspace() {
          <div>
            <span className="section-eyebrow">PROCESSING RUNTIME</span>
            <h3>Контейнеры Mission Core</h3>
-            <p>Два ограниченных runtime: inference server и прикладной perception pipeline.</p>
+            <p>Состояние контейнера и готовность вычислительного профиля проверяются отдельно.</p>
          </div>
          <StatusBadge tone={node?.triton.ready ? "success" : "danger"}>
            {node?.triton.ready ? "Triton ready" : "Triton недоступен"}
@@ -233,19 +240,31 @@ export function ComputeModulesWorkspace() {
            <span className="section-eyebrow">ТЕКУЩАЯ ЗАДАЧА</span>
            <h3>{pipelineStateLabel(telemetry?.pipeline.service_state ?? "unavailable")}</h3>
            <p>
+              {telemetry?.pipeline.profile_name ?? "Perception"}
+              {" · "}
              {telemetry?.pipeline.active_request_id
                ? `Run ${telemetry.pipeline.active_request_id}`
-                : "Очередь свободна; модели остаются загруженными в persistent worker."}
+                : telemetry?.pipeline.service_state === "ready"
+                  ? "Готов к приёму данных."
+                  : "Готовность моделей не подтверждена."}
            </p>
          </div>
          <StatusBadge tone={
-            telemetry?.pipeline.service_state === "busy" ? "warning"
+            ["busy", "running", "waiting", "synchronizing", "starting"].includes(telemetry?.pipeline.service_state ?? "") ? "warning"
              : telemetry?.pipeline.service_state === "ready" ? "success"
                : "danger"
          }>
-            {telemetry?.pipeline.service_state ?? "unavailable"}
+            {pipelineStateLabel(telemetry?.pipeline.service_state ?? "unavailable")}
          </StatusBadge>
        </header>
+        {telemetry?.pipeline.profile_name ? (
+          <div className="worker-pipeline__summary">
+            <div><span>Процессы профиля</span><strong>{telemetry.pipeline.live_children ?? "—"}</strong></div>
+            <div><span>Ожиданий потока</span><strong>{telemetry.pipeline.input_pauses ?? "—"}</strong></div>
+            <div><span>Пакетов в очереди</span><strong>{telemetry.pipeline.pending_bundles ?? "—"}</strong></div>
+            <div><span>Входные буферы</span><strong>{formatBytes(telemetry.pipeline.buffer_bytes)}</strong></div>
+          </div>
+        ) : null}
        <div className="worker-pipeline__summary">
          <div><span>Завершено запусков</span><strong>{telemetry?.pipeline.completed_runs ?? "—"}</strong></div>
          <div><span>Ошибок запусков</span><strong>{telemetry?.pipeline.failed_runs ?? "—"}</strong></div>
@@ -11,6 +11,7 @@ let fetchM49TgsAnchorSpatial;
 let AdvancedLaboratoryContractError;
 let buildLaboratoryCatalog;
 let buildLaboratoryProfiles;
+let isLegacyPublishedLaboratoryWork;
 let experimentOptionsForProfile;
 let freshestLaboratorySelection;
 let workOptionsForExperiment;
@@ -928,6 +929,7 @@ before(async () => {
  ({
    buildLaboratoryCatalog,
    buildLaboratoryProfiles,
+    isLegacyPublishedLaboratoryWork,
    experimentOptionsForProfile,
    freshestLaboratorySelection,
    workOptionsForExperiment,
@@ -962,6 +964,31 @@ after(async () => {
  await server?.close();
 });

+test("capability-owned projections never enter the legacy LAB catalog", () => {
+  const legacy = {
+    status: "ready",
+    replayable: true,
+    modalities: ["point-cloud", "trajectory"],
+    lab: { replayCapability: null },
+  };
+  const capabilityProjection = {
+    ...legacy,
+    lab: {
+      replayCapability: {
+        schemaVersion: "missioncore.observation-lab-replay-capability/v1",
+        kind: "canonical-recorded-rerun",
+        viewerProfile: "recorded-session",
+        timeline: "session_time",
+        activation: "explicit",
+        commandsEnabled: false,
+      },
+    },
+  };
+
+  assert.equal(isLegacyPublishedLaboratoryWork(legacy), true);
+  assert.equal(isLegacyPublishedLaboratoryWork(capabilityProjection), false);
+});
+
 test("LAB catalog is pipeline-scoped and ordered by real run time", () => {
  const catalog = buildLaboratoryCatalog({
    rigLabel: "K1",
@@ -105,23 +105,52 @@ test("laboratory UI is a bounded feature slice, not a central workspace branch",
  assert.match(e30HumanReviewCss, /\.e30-human-review/);
 });

-test("central composition files cannot silently become monoliths again", async () => {
-  const ratchets = [
-    ["App.tsx", 1_250],
-    ["workspaces/Workspaces.tsx", 1_200],
-    ["workspaces/laboratory/LaboratoryArchiveWorkspace.tsx", 1_000],
-    ["core/laboratory/advancedResults.ts", 1_000],
-    ["core/laboratory/e40ProductGate.ts", 500],
-    ["styles/workspaces.css", 4_350],
-    ["styles/laboratory.css", 900],
-    ["styles/laboratory-reporting.css", 100],
-  ];
+test("Observatory owns a bounded explicit-open lifecycle around the shared recorded viewer", async () => {
+  const workspaceHub = await read("workspaces/Workspaces.tsx");
+  const observatory = await read("workspaces/observatory/ObservatoryWorkspace.tsx");
+  const observatoryCore = await read("core/observatory/catalog.ts");
+  const recordedRun = await read("core/observatory/recordedRun.ts");
+  const sharedReplay = await read(
+    "components/laboratory/CanonicalResultRerunReplay.tsx",
+  );
+  const workspaceCss = await read("styles/workspaces.css");
+  const observatoryCss = await read("styles/observatory.css");

-  for (const [relativePath, maximumLines] of ratchets) {
-    const lineCount = (await read(relativePath)).split("\n").length;
-    assert.ok(
-      lineCount <= maximumLines,
-      `${relativePath} has ${lineCount} lines; split the feature instead of raising ${maximumLines}`,
-    );
+  assert.match(
+    workspaceHub,
+    /case "observatory":[\s\S]*<ObservatoryWorkspace definition=\{props\.definition\} \/>/,
+  );
+  assert.match(observatory, /export function ObservatoryWorkspace/);
+  assert.match(observatory, /useObservatoryCatalog/);
+  assert.match(observatory, /data-observatory-authority="observation-only"/);
+  assert.match(
+    observatory,
+    /data-observatory-viewer={replay\.kind === "ready" \|\| replay\.kind === "composition" \? "attached" : "detached"}/,
+  );
+  assert.doesNotMatch(
+    `${observatory}\n${observatoryCore}`,
+    /(?:core|workspaces)\/laboratory|\/api\/v1\/laboratory|RerunViewport|ObservationSessionSelect/,
+  );
+  assert.match(observatory, /replay\.kind === "ready"[\s\S]*<CanonicalVegetationRerunReplay/);
+  assert.match(observatory, /closeReplay\(\);[\s\S]*setSelectedSessionId/);
+  assert.doesNotMatch(
+    observatory,
+    /replayObservationSession|deleteObservationSession|useObservationSessions|useAdvancedLaboratoryCatalog/,
+  );
+  assert.match(recordedRun, /fetchVegetationShadowResultMetadata/);
+  assert.doesNotMatch(
+    recordedRun,
+    /advanced-index|resolveObservationSessionReplay|resolveCanonicalLabReplay|RerunViewport/,
+  );
+  assert.equal(sharedReplay.match(/<RerunViewport\b/g)?.length, 1);
+  assert.match(sharedReplay, /recordedSessionRerunProfile/);
+  assert.match(sharedReplay, /useState<0 \| 1>\(hasTgs \? 1 : 0\)/);
+  assert.match(sharedReplay, /hasTgs \? 0\.000001 : 0/);
+  for (const adapter of ["CanonicalVegetationRerunReplay", "PortableResultReplay"]) {
+    const source = await read(`components/laboratory/${adapter}.tsx`);
+    assert.match(source, /<CanonicalResultRerunReplay/);
+    assert.doesNotMatch(source, /<RerunViewport|<video|setInterval|Canvas|THREE\./);
  }
+  assert.doesNotMatch(workspaceCss, /\.observatory-/);
+  assert.match(observatoryCss, /\.observatory-workspace/);
 });
@@ -8,6 +8,7 @@ let server;
 let canonicalMapGravityLocalPointToBodyGround;
 let canonicalRecordedLabPackedTgsCells;
 let canonicalRecordedLabTgsIsCurrent;
+let resolveCanonicalLabReplay;

 before(async () => {
  server = await createServer({
@@ -20,6 +21,9 @@ before(async () => {
    canonicalRecordedLabPackedTgsCells,
    canonicalRecordedLabTgsIsCurrent,
  } = await server.ssrLoadModule("/src/core/laboratory/canonicalRecordedLab.ts"));
+  ({ resolveCanonicalLabReplay } = await server.ssrLoadModule(
+    "/src/core/laboratory/canonicalLabReplay.ts",
+  ));
 });

 after(async () => {
@@ -76,3 +80,84 @@ test("recorded LAB spatial loading is shared, profile-bound and experiment-neutr
  assert.doesNotMatch(scheduler, /RAVNOVES|vegetation|DDRNet/);
  assert.doesNotMatch(vegetation, /fetchCanonicalRecordedLabSpatialFrame|CanonicalRecordedLabSpatialFrame/);
 });
+
+test("canonical LAB resolves one generation-bound merged RRD", async () => {
+  const baseGeneration = "a".repeat(64);
+  const replayGeneration = "b".repeat(64);
+  const resultId = `lab-v1-vegetation-shadow-${"c".repeat(64)}`;
+  let request;
+  const replay = await resolveCanonicalLabReplay(resultId, {
+    kind: "rerun-recording",
+    sessionId: "session-001",
+    sourceUrl: "/api/v1/observation-sessions/session-001/recording.rrd",
+    viewerSourceUrl:
+      `/api/v1/observation-sessions/session-001/recording.rrd?generation=${baseGeneration}`,
+    mediaType: "application/vnd.rerun.rrd",
+    timeline: "session_time",
+    timelineStartSeconds: 0,
+    timelineEndSeconds: 10,
+    seekable: true,
+    byteLength: 100,
+    sha256: baseGeneration,
+    playback: { speed: 1, loop: false },
+    mediaSources: [],
+  }, {
+    origin: "http://mission-core.test",
+    fetcher: async (url, options) => {
+      request = { url, options };
+      return new Response(null, {
+        status: 200,
+        headers: {
+          "Content-Type": "application/vnd.rerun.rrd",
+          "Content-Length": "234567",
+          "ETag": `"${replayGeneration}"`,
+          "X-Rerun-Format": "RRF2",
+        },
+      });
+    },
+  });
+
+  const sourceUrl =
+    `/api/v1/laboratory/vegetation-shadow/${resultId}/canonical-replay.rrd`;
+  assert.equal(
+    request.url,
+    `http://mission-core.test${sourceUrl}?base_generation=${baseGeneration}`,
+  );
+  assert.equal(request.options.method, "HEAD");
+  assert.deepEqual(replay, {
+    sourceUrl,
+    viewerSourceUrl: `${sourceUrl}?generation=${replayGeneration}`,
+    byteLength: 234567,
+    sha256: replayGeneration,
+    blueprintSourceUrl: "/api/v1/observation-sessions/session-001/blueprint.rrd",
+  });
+});
+
+for (const [prefix, sourceKind] of [
+  ["m49-tgs-portable-review", "portable-tgs"],
+  ["lab-v1-eomt-ddrnet", "portable-semantic"],
+]) test(`${sourceKind} resolves Core cache for the exact result and base, never a legacy LAB`, async () => {
+  const base = "a".repeat(64), generation = "b".repeat(64);
+  const resultId = `${prefix}-${"c".repeat(64)}`;
+  const launch = { sourceUrl: "/api/v1/observation-sessions/source/recording.rrd",
+    viewerSourceUrl: `/api/v1/observation-sessions/source/recording.rrd?generation=${base}`,
+    sha256: base };
+  let calls = 0;
+  const fetcher = async (url, options) => {
+    calls++;
+    assert.equal(url, `http://mission-core.test/api/v1/observatory/portable-results/${resultId}/replays/${base}/recording.rrd`);
+    assert.equal(options.method, "HEAD");
+    return new Response(null, { headers: { "Content-Type": "application/vnd.rerun.rrd",
+      "Content-Length": "100", "ETag": `"${generation}"`, "X-Rerun-Format": "RRF2" } });
+  };
+  const options = { sourceKind, origin: "http://mission-core.test", fetcher };
+  const replay = await resolveCanonicalLabReplay(resultId, launch, options);
+  assert.equal(replay.viewerSourceUrl, `${replay.sourceUrl}?generation=${generation}`);
+  assert.equal(replay.blueprintSourceUrl, "/api/v1/observation-sessions/source/blueprint.rrd");
+  await assert.rejects(resolveCanonicalLabReplay(`lab-v1-vegetation-shadow-${"c".repeat(64)}`, launch, options));
+  await assert.rejects(resolveCanonicalLabReplay(resultId, launch, {
+    ...options, sourceKind: sourceKind === "portable-tgs" ? "portable-semantic" : "portable-tgs",
+  }));
+  await assert.rejects(resolveCanonicalLabReplay(resultId, { ...launch, sha256: "d".repeat(64) }, options));
+  assert.equal(calls, 1);
+});
@@ -0,0 +1,97 @@
+import assert from "node:assert/strict";
+import { after, before, test } from "node:test";
+import { createServer } from "vite";
+
+let server, fetchLabViewProfile, saveLabViewProfile, normalizeLabSceneSettings;
+
+before(async () => {
+  server = await createServer({ appType: "custom", logLevel: "silent",
+    server: { middlewareMode: true } });
+  ({ fetchLabViewProfile, saveLabViewProfile } = await server.ssrLoadModule(
+    "/src/core/observatory/labViewProfile.ts"));
+  ({ normalizeLabSceneSettings } = await server.ssrLoadModule(
+    "/src/components/laboratory/CanonicalResultRerunReplay.tsx"));
+});
+
+after(async () => { await server?.close(); });
+
+const serverProfile = {
+  schema_version: "missioncore.observatory-lab-view-profile/v1",
+  result_id: "result-1",
+  scene_settings: {
+    point_size: 4.7,
+    accumulation_seconds: 8,
+    color_mode: "height",
+    palette: "viridis",
+    show_grid: false,
+    show_labels: true,
+    show_camera_frustums: false,
+  },
+  updated_at_utc: "2026-09-04T09:30:00.000Z",
+};
+
+test("LAB view profile round-trips through the result-scoped server endpoint", async () => {
+  const originalFetch = globalThis.fetch;
+  const requests = [];
+  globalThis.fetch = async (url, init = {}) => {
+    requests.push({ url, init });
+    return new Response(JSON.stringify(serverProfile), {
+      status: 200, headers: { "Content-Type": "application/json" },
+    });
+  };
+  try {
+    const settings = await fetchLabViewProfile("result-1");
+    assert.equal(settings.pointSize, 4.7);
+    assert.equal(settings.palette, "viridis");
+    const saved = await saveLabViewProfile("result-1", settings);
+    assert.equal(saved.accumulationSeconds, 8);
+    assert.equal(requests[0].url, "/api/v1/observatory/lab-view-profiles/result-1");
+    assert.equal(requests[1].init.method, "PUT");
+    assert.deepEqual(JSON.parse(requests[1].init.body).scene_settings, serverProfile.scene_settings);
+  } finally {
+    globalThis.fetch = originalFetch;
+  }
+});
+
+test("LAB view profile fails closed on a foreign result identity", async () => {
+  const originalFetch = globalThis.fetch;
+  globalThis.fetch = async () => new Response(JSON.stringify({
+    ...serverProfile, result_id: "foreign-result",
+  }), { status: 200, headers: { "Content-Type": "application/json" } });
+  try {
+    await assert.rejects(fetchLabViewProfile("result-1"), /другой LAB/);
+  } finally {
+    globalThis.fetch = originalFetch;
+  }
+});
+
+test("LAB scene settings normalize typed values before persistence", () => {
+  assert.deepEqual(
+    normalizeLabSceneSettings({
+      pointSize: 28,
+      accumulationSeconds: 305,
+      colorMode: "height",
+      palette: "viridis",
+      customColor: "#ffffff",
+      showGrid: false,
+      showPoints: true,
+      showTrajectory: true,
+      showLabels: true,
+      showCameraFrustums: false,
+      projection: "3d",
+    }),
+    {
+      pointSize: 28,
+      accumulationSeconds: 305,
+      colorMode: "height",
+      palette: "viridis",
+      customColor: "#ffffff",
+      showGrid: false,
+      showPoints: true,
+      showTrajectory: true,
+      showLabels: true,
+      showCameraFrustums: false,
+      projection: "3d",
+    },
+  );
+});
@@ -887,7 +887,7 @@ test("M4.6 viewer keeps media and spatial panes on one playback clock", async ()
  assert.match(canonical, /secondary=\{spatialPane/);
  assert.match(canonical, /primarySize=\{splitView \? splitPrimarySize : mediaMode !== "none" \? 100 : 0\}/);
  assert.match(canonical, /resizable=\{splitView\}/);
-  assert.match(canonical, /separatorLabel="Изменить размер VIDEO\/CAMERA и 3D\/PLAN"/);
+  assert.match(canonical, /separatorLabel="Изменить размер видео\/камеры и 3D\/плана"/);
  assert.match(canonical, /secondaryMode=\{\{/);
  assert.match(visual, /playback=\{playbackController\.playback\}/);
  assert.match(visual, /clock: "external"/);
@@ -77,6 +77,70 @@ function session(overrides = {}) {
  };
 }

+function canonicalLab(overrides = {}) {
+  const resultId = `lab-v1-vegetation-shadow-${"8".repeat(64)}`;
+  return {
+    lab_id: "LAB V1",
+    source_session_id: "20260828T130511Z_viewer_live",
+    result_kind: "recorded-perception-qualification",
+    result_id: resultId,
+    source_result_id: `lab-v1-vegetation-shadow-${"9".repeat(64)}`,
+    config_sha256: null,
+    run_created_at_utc: "2026-08-29T18:05:11.329061+00:00",
+    published_at_utc: "2026-08-30T12:00:00.000Z",
+    replay_capability: {
+      schema_version: "missioncore.observation-lab-replay-capability/v1",
+      kind: "canonical-recorded-rerun",
+      viewer_profile: "recorded-session",
+      timeline: "session_time",
+      activation: "explicit",
+      commands_enabled: false,
+    },
+    provenance: {},
+    ...overrides,
+  };
+}
+
+function legacyCalculationProfile(overrides = {}) {
+  return {
+    schema_version: "missioncore.observatory-calculation-profile/v1",
+    setup_id: "lab-v1-ravnoves004tree-final",
+    display_name: "LAB V1 · EoMT Cityscapes Large 1024 + DDRNet-39",
+    origin: "existing-result",
+    definition_id: null,
+    definition_version: null,
+    definition_sha256: null,
+    ...overrides,
+  };
+}
+
+function canonicalProjectionProvenance(resultId, replayCapability) {
+  return {
+    schema_version: "missioncore.canonical-recorded-lab-projection/v1",
+    evidence_identity_sha256: resultId.slice("lab-v1-vegetation-shadow-".length),
+    result_document_sha256: "a".repeat(64),
+    replay_capability: replayCapability,
+    authority: {
+      commands_enabled: false,
+      navigation_or_safety_accepted: false,
+      actuation_accepted: false,
+    },
+    method: {
+      schema_version: "missioncore.laboratory-method/v1",
+      completeness: "legacy-partial",
+      execution_class: "ai-inference",
+      pipeline_id: "ravnoves004tree-full-eomt-ddrnet-recorded-review/v1",
+      components: [{
+        kind: "source",
+        name: "sealed full-route LAB result",
+        version: "missioncore.lab-v1-vegetation-shadow/v1",
+        role: "immutable Session catalog projection",
+        identity_sha256: resultId.slice("lab-v1-vegetation-shadow-".length),
+      }],
+    },
+  };
+}
+
 function replay(overrides = {}) {
  const sessionId = overrides.session_id ?? "session-20260716T205632Z";
  const sourceUrl = overrides.source_url ??
@@ -134,6 +198,7 @@ test("session catalog decodes canonical snake_case into a path-free camelCase mo
    modalities: ["point-cloud", "pose"],
    durationSeconds: 1_450.744,
    replayable: true,
+    captureAttestation: null,
    preparation: null,
    lab: null,
  }]);
@@ -141,6 +206,137 @@ test("session catalog decodes canonical snake_case into a path-free camelCase mo
  assert.equal("path" in catalog.items[0], false);
 });

+test("session catalog strictly decodes the explicit recorded LAB replay capability", () => {
+  const resultId = `lab-v1-vegetation-shadow-${"8".repeat(64)}`;
+  const decoded = decodeObservationSessionCatalog({
+    items: [session({ id: resultId, lab: canonicalLab() })],
+  }).items[0].lab;
+
+  assert.deepEqual(decoded.replayCapability, {
+    schemaVersion: "missioncore.observation-lab-replay-capability/v1",
+    kind: "canonical-recorded-rerun",
+    viewerProfile: "recorded-session",
+    timeline: "session_time",
+    activation: "explicit",
+    commandsEnabled: false,
+  });
+  const rollingUpgradeLab = canonicalLab();
+  rollingUpgradeLab.provenance = canonicalProjectionProvenance(
+    resultId,
+    rollingUpgradeLab.replay_capability,
+  );
+  delete rollingUpgradeLab.replay_capability;
+  assert.deepEqual(
+    decodeObservationSessionCatalog({
+      items: [session({ id: resultId, lab: rollingUpgradeLab })],
+    }).items[0].lab.replayCapability,
+    decoded.replayCapability,
+  );
+  const invalidComponents = [
+    { kind: "tool" },
+    { name: "unsealed result" },
+    { version: "missioncore.lab-v1-vegetation-shadow/v0" },
+    { role: "mutable projection" },
+    { identity_sha256: "0".repeat(64) },
+    { unexpected: true },
+  ];
+  for (const componentOverride of invalidComponents) {
+    const invalidRollingUpgradeLab = canonicalLab();
+    invalidRollingUpgradeLab.provenance = canonicalProjectionProvenance(
+      resultId,
+      invalidRollingUpgradeLab.replay_capability,
+    );
+    invalidRollingUpgradeLab.provenance.method.components = [{
+      ...invalidRollingUpgradeLab.provenance.method.components[0],
+      ...componentOverride,
+    }];
+    delete invalidRollingUpgradeLab.replay_capability;
+    assert.throws(
+      () => decodeObservationSessionCatalog({
+        items: [session({ id: resultId, lab: invalidRollingUpgradeLab })],
+      }),
+      ObservationSessionContractError,
+    );
+  }
+  assert.throws(
+    () => decodeObservationSessionCatalog({
+      items: [session({
+        id: resultId,
+        lab: canonicalLab({
+          replay_capability: {
+            ...canonicalLab().replay_capability,
+            commands_enabled: true,
+          },
+        }),
+      })],
+    }),
+    ObservationSessionContractError,
+  );
+});
+
+test("session catalog decodes a typed calculation profile without inferring unknown results", () => {
+  const resultId = `lab-v1-vegetation-shadow-${"8".repeat(64)}`;
+  const decoded = decodeObservationSessionCatalog({
+    items: [session({
+      id: resultId,
+      lab: canonicalLab({ calculation_profile: legacyCalculationProfile() }),
+    })],
+  }).items[0].lab;
+
+  assert.deepEqual(decoded.calculationProfile, {
+    schemaVersion: "missioncore.observatory-calculation-profile/v1",
+    setupId: "lab-v1-ravnoves004tree-final",
+    displayName: "LAB V1 · EoMT Cityscapes Large 1024 + DDRNet-39",
+    origin: "existing-result",
+    definitionId: null,
+    definitionVersion: null,
+    definitionSha256: null,
+  });
+  assert.equal(
+    decodeObservationSessionCatalog({
+      items: [session({ id: resultId, lab: canonicalLab() })],
+    }).items[0].lab.calculationProfile,
+    null,
+  );
+  assert.equal(
+    decodeObservationSessionCatalog({
+      items: [session({
+        id: resultId,
+        lab: canonicalLab({ calculation_profile: null }),
+      })],
+    }).items[0].lab.calculationProfile,
+    null,
+  );
+  assert.throws(
+    () => decodeObservationSessionCatalog({
+      items: [session({
+        id: resultId,
+        lab: canonicalLab({
+          calculation_profile: legacyCalculationProfile({
+            origin: "archived-definition",
+            definition_id: "lab-v1-portable",
+          }),
+        }),
+      })],
+    }),
+    ObservationSessionContractError,
+  );
+  assert.throws(
+    () => decodeObservationSessionCatalog({
+      items: [session({
+        id: resultId,
+        lab: canonicalLab({
+          calculation_profile: {
+            ...legacyCalculationProfile(),
+            guessed_from_provenance: true,
+          },
+        }),
+      })],
+    }),
+    ObservationSessionContractError,
+  );
+});
+
 test("opened archive is named in the scene header and trash hover has no pill", async () => {
  const appSource = await readFile(new URL("../src/App.tsx", import.meta.url), "utf8");
  const styles = await readFile(
@@ -246,7 +442,7 @@ test("source and laboratory catalogs are requested as disjoint backend projectio

  assert.deepEqual(calls, [
    "/api/v1/observation-sessions?limit=100&scope=source",
-    "/api/v1/observation-sessions?limit=100&scope=laboratory",
+    "/api/v1/observation-sessions?limit=100&scope=laboratory&lab_contract=v3",
  ]);
 });

@@ -40,8 +40,11 @@ let formatAccumulationDuration;
 let resolveRerunSourceUrl;
 let resolveRecordedBlueprintUrl;
 let fetchRecordedBlueprintRrd;
+let recordedCameraJournalContract;
 let resolveRecordedPerceptionUrl;
 let fetchRecordedPerceptionRrd;
+let resolveRecordedPerceptionViewerSourceUrl;
+let probeRecordedPerceptionViewerSource;
 let resolveRecordedPointColorsUrl;
 let fetchRecordedPointColorsRrd;
 let recordedPointColorKey;
@@ -108,13 +111,16 @@ before(async () => {
    resolveRerunSourceUrl,
    resolveRecordedBlueprintUrl,
    fetchRecordedBlueprintRrd,
+    recordedCameraJournalContract,
    resolveRecordedPerceptionUrl,
    fetchRecordedPerceptionRrd,
+    resolveRecordedPerceptionViewerSourceUrl,
+    probeRecordedPerceptionViewerSource,
    resolveRecordedPointColorsUrl,
    fetchRecordedPointColorsRrd,
    recordedPointColorKey,
    isRecordedPlaybackFullyBuffered,
-  } = await server.ssrLoadModule(
+} = await server.ssrLoadModule(
    "/src/components/RerunViewport.tsx",
  ));
  ({ recordedObservationSources } = await server.ssrLoadModule(
@@ -125,6 +131,25 @@ before(async () => {
  ));
 });

+test("follow toggles retain the current recorded camera journal", () => {
+  const before = recordedCameraJournalContract({
+    activeView: "spatial", viewResetGeneration: 0, planView: false, followTrajectory: false,
+  });
+  const afterFollowToggle = recordedCameraJournalContract({
+    activeView: "spatial", viewResetGeneration: 0, planView: false, followTrajectory: true,
+  });
+  const afterPlanToggle = recordedCameraJournalContract({
+    activeView: "spatial", viewResetGeneration: 0, planView: true, followTrajectory: true,
+  });
+  const afterReset = recordedCameraJournalContract({
+    activeView: "spatial", viewResetGeneration: 1, planView: false, followTrajectory: false,
+  });
+
+  assert.equal(afterFollowToggle, before);
+  assert.notEqual(afterPlanToggle, before);
+  assert.notEqual(afterReset, before);
+});
+
 test("observation camera windows tile from the bottom-right above the live timeline", () => {
  const bounds = { width: 1280, height: 720 };
  const left = initialObservationWindowRect(0, 2, bounds);
@@ -407,6 +432,15 @@ test("recorded blueprint endpoint is derived only from canonical same-origin RRD
    ),
    null,
  );
+  assert.equal(
+    resolveRecordedBlueprintUrl(
+      `/api/v1/laboratory/vegetation-shadow/lab-v1-vegetation-shadow-${"a".repeat(64)}`
+        + "/canonical-replay.rrd",
+      "http://127.0.0.1:5174",
+      "/api/v1/observation-sessions/session-1/blueprint.rrd",
+    ),
+    "http://127.0.0.1:5174/api/v1/observation-sessions/session-1/blueprint.rrd",
+  );
 });

 test("recorded replay becomes ready only after the complete declared timeline is buffered", () => {
@@ -431,6 +465,7 @@ test("recorded replay becomes ready only after the complete declared timeline is

 test("recorded blueprint fetch is bounded, strict and sends only display settings", async () => {
  const calls = [];
+  const cameraLimits = [];
  const payload = Uint8Array.from([0x52, 0x52, 0x46, 0x32, 0x01]);
  const result = await fetchRecordedBlueprintRrd(
    "http://127.0.0.1:5174/api/v1/observation-sessions/session-1/blueprint.rrd",
@@ -451,6 +486,15 @@ test("recorded blueprint fetch is bounded, strict and sends only display setting
      activeView: "perception3d",
      viewResetGeneration: 1,
      followTrajectory: true,
+      cameraEye: {
+        position: [3, 4, 5],
+        lookTarget: [1, 2, 0],
+        eyeUp: [0, 0, 1],
+      },
+      eyeRelativeToTracking: true,
+      currentTimeNs: 39_215_263_458,
+      onCameraMaxOrbitalRadius: value => cameraLimits.push(value),
+      unifiedCameraShare: 0.73,
      perceptionLayers: {
        enabled: true,
        detections2d: true,
@@ -461,7 +505,10 @@ test("recorded blueprint fetch is bounded, strict and sends only display setting
        calls.push({ input: String(input), init, body: JSON.parse(String(init.body)) });
        return new Response(payload, {
          status: 200,
-          headers: { "Content-Type": "application/vnd.rerun.rrd" },
+          headers: {
+            "Content-Type": "application/vnd.rerun.rrd",
+            "X-MissionCore-Camera-Max-Orbital-Radius": "686.024231",
+          },
        });
      },
    },
@@ -484,11 +531,21 @@ test("recorded blueprint fetch is bounded, strict and sends only display setting
    active_view: "perception3d",
    view_reset_generation: 1,
    follow_trajectory: true,
+    current_time_ns: 39_215_263_458,
    unified_perception: true,
+    unified_camera_share: 0.73,
+    semantic_layer: null,
+    plan_view: false,
+    eye_position: [3, 4, 5],
+    eye_look_target: [1, 2, 0],
+    eye_up: [0, 0, 1],
+    eye_relative_to_tracking: true,
+    show_camera_image: true,
    show_detections_2d: true,
    show_segmentation: false,
    show_cuboids_3d: true,
  });
+  assert.deepEqual(cameraLimits, [686.024231]);

  await fetchRecordedBlueprintRrd(
    "http://127.0.0.1:5174/api/v1/observation-sessions/session-1/blueprint.rrd",
@@ -522,6 +579,7 @@ test("recorded blueprint fetch is bounded, strict and sends only display setting
    },
  );
  assert.equal(calls[1].body.unified_perception, false);
+  assert.equal(calls[1].body.unified_camera_share, 0.46);
  assert.equal(calls[1].body.show_cuboids_3d, true);

  await assert.rejects(
@@ -664,6 +722,74 @@ test("recorded perception fetch admits one complete same-origin RRD or no layer"
  assert.equal(absent, null);
 });

+test("LAB perception sidecar is streamed by native Rerun from one generation-bound URL", async () => {
+  const endpoint =
+    `http://127.0.0.1:5174/api/v1/laboratory/vegetation-shadow/` +
+    `lab-v1-vegetation-shadow-${"a".repeat(64)}/canonical-overlay.rrd`;
+  const sourceUrl = resolveRecordedPerceptionViewerSourceUrl(
+    endpoint,
+    { applicationId: "nodedc_mission_core_recorded", recordingId: "recording-001" },
+    "b".repeat(64),
+    "http://127.0.0.1:5174",
+  );
+  assert.equal(
+    sourceUrl,
+    `${endpoint}?application_id=nodedc_mission_core_recorded` +
+      `&recording_id=recording-001&generation=${"b".repeat(64)}`,
+  );
+
+  const overlayGeneration = "c".repeat(64);
+  const probe = await probeRecordedPerceptionViewerSource(sourceUrl, {
+    origin: "http://127.0.0.1:5174",
+    fetcher: async (input, init) => {
+      assert.equal(String(input), sourceUrl);
+      assert.equal(init.method, "HEAD");
+      assert.equal(new Headers(init.headers).get("Range"), null);
+      return new Response(null, {
+        status: 200,
+        headers: {
+          "Content-Type": "application/vnd.rerun.rrd",
+          "Content-Length": "186058411",
+          "ETag": `"${overlayGeneration}"`,
+          "X-Rerun-Format": "RRF2",
+        },
+      });
+    },
+  });
+  assert.deepEqual(probe, {
+    sourceUrl: `${sourceUrl}&overlay_generation=${overlayGeneration}`,
+    byteLength: 186_058_411,
+  });
+});
+
+test("LAB native source rejects an unsealed overlay descriptor", async () => {
+  const endpoint =
+    `http://127.0.0.1:5174/api/v1/laboratory/vegetation-shadow/` +
+    `lab-v1-vegetation-shadow-${"a".repeat(64)}/canonical-overlay.rrd`;
+  const sourceUrl = resolveRecordedPerceptionViewerSourceUrl(
+    endpoint,
+    { applicationId: "nodedc_mission_core_recorded", recordingId: "recording-001" },
+    "b".repeat(64),
+    "http://127.0.0.1:5174",
+  );
+
+  await assert.rejects(
+    probeRecordedPerceptionViewerSource(sourceUrl, {
+      origin: "http://127.0.0.1:5174",
+      fetcher: async () => new Response(null, {
+        status: 200,
+        headers: {
+          "Content-Type": "application/vnd.rerun.rrd",
+          "Content-Length": "186058411",
+          "ETag": `"${"c".repeat(64)}"`,
+          "X-Rerun-Format": "RRF1",
+        },
+      }),
+    }),
+    /Invalid recorded perception viewer response/,
+  );
+});
+
 test("recorded replay creates an isolated source catalog without live device bindings", () => {
  const sources = recordedObservationSources({
    kind: "rerun-recording",
@@ -0,0 +1,518 @@
+import assert from "node:assert/strict";
+import { after, before, test } from "node:test";
+
+import { createServer } from "vite";
+
+let server;
+let applyObservatoryCatalogMutationOverlay;
+let buildObservatoryCatalog;
+let fetchObservatoryCatalog;
+let findObservatoryEvidence;
+let observatoryCatalogConfirmsEvidenceDeletion;
+let reconcileObservatoryCatalogMutationOverlay;
+let ObservatoryCatalogContractError;
+
+before(async () => {
+  server = await createServer({
+    appType: "custom",
+    logLevel: "silent",
+    server: { middlewareMode: true },
+  });
+  ({
+    applyObservatoryCatalogMutationOverlay,
+    buildObservatoryCatalog,
+    fetchObservatoryCatalog,
+    findObservatoryEvidence,
+    observatoryCatalogConfirmsEvidenceDeletion,
+    reconcileObservatoryCatalogMutationOverlay,
+    ObservatoryCatalogContractError,
+  } = await server.ssrLoadModule("/src/core/observatory/catalog.ts"));
+});
+
+after(async () => {
+  await server?.close();
+});
+
+function source(id, startedAtUtc) {
+  return {
+    id,
+    label: `Источник ${id}`,
+    startedAtUtc,
+    completedAtUtc: startedAtUtc,
+    status: "ready",
+    modalities: ["point-cloud", "video"],
+    durationSeconds: 42,
+    replayable: true,
+    preparation: null,
+    lab: null,
+  };
+}
+
+function evidence(id, sourceSessionId, publishedAtUtc) {
+  return {
+    id,
+    label: `Результат ${id}`,
+    startedAtUtc: publishedAtUtc,
+    completedAtUtc: publishedAtUtc,
+    status: "ready",
+    modalities: ["video"],
+    durationSeconds: 12,
+    replayable: true,
+    preparation: null,
+    lab: {
+      labId: `LAB-${id}`,
+      sourceSessionId,
+      resultKind: "recorded-evidence",
+      resultId: id,
+      sourceResultId: null,
+      configSha256: "a".repeat(64),
+      runCreatedAtUtc: publishedAtUtc,
+      publishedAtUtc,
+      replayCapability: {
+        schemaVersion: "missioncore.observation-lab-replay-capability/v2",
+        kind: "portable-result-review", viewerProfile: "portable-result",
+        timeline: "result-defined", activation: "explicit", commandsEnabled: false,
+      },
+      calculationProfile: null,
+      provenance: {
+        schema_version: "missioncore.observatory-portable-result-publication/v1",
+        authority: { commands_enabled: false },
+        calculation_profile: null, calculation_profile_sha256: "1".repeat(64),
+        job: {}, method: {}, storage: {},
+        source: { session_id: sourceSessionId },
+        run_definition: { definition_sha256: "a".repeat(64) },
+        result_package: { manifest_sha256: "b".repeat(64), artifact_manifest_id: "c".repeat(64) },
+        replay_capability: {
+          schema_version: "missioncore.observation-lab-replay-capability/v2",
+          kind: "portable-result-review", viewer_profile: "portable-result",
+          timeline: "result-defined", activation: "explicit", commands_enabled: false,
+        },
+      },
+    },
+  };
+}
+
+function canonicalProvenance(resultId) {
+  const identitySha256 = resultId.slice("lab-v1-vegetation-shadow-".length);
+  return {
+    schema_version: "missioncore.canonical-recorded-lab-projection/v1",
+    evidence_identity_sha256: identitySha256,
+    result_document_sha256: "a".repeat(64),
+    replay_capability: {
+      schema_version: "missioncore.observation-lab-replay-capability/v1",
+      kind: "canonical-recorded-rerun",
+      viewer_profile: "recorded-session",
+      timeline: "session_time",
+      activation: "explicit",
+      commands_enabled: false,
+    },
+    authority: {
+      commands_enabled: false,
+      navigation_or_safety_accepted: false,
+      actuation_accepted: false,
+    },
+    method: {
+      schema_version: "missioncore.laboratory-method/v1",
+      completeness: "legacy-partial",
+      execution_class: "ai-inference",
+      pipeline_id: "ravnoves004tree-full-eomt-ddrnet-recorded-review/v1",
+      components: [{
+        kind: "source",
+        name: "sealed full-route LAB result",
+        version: "missioncore.lab-v1-vegetation-shadow/v1",
+        role: "immutable Session catalog projection",
+        identity_sha256: identitySha256,
+      }],
+    },
+  };
+}
+
+test("Observatory joins evidence only by sourceSessionId and keeps deterministic order", () => {
+  const catalog = buildObservatoryCatalog(
+    [
+      source("older", "2026-08-28T10:00:00Z"),
+      source("newer", "2026-08-29T10:00:00Z"),
+    ],
+    [
+      evidence("old-result", "newer", "2026-08-29T11:00:00Z"),
+      evidence("new-result", "newer", "2026-08-29T12:00:00Z"),
+      evidence("orphan", "missing", "2026-08-29T13:00:00Z"),
+    ],
+  );
+
+  assert.deepEqual(catalog.items.map(({ source: item }) => item.id), ["newer", "older"]);
+  assert.deepEqual(
+    catalog.items[0].evidence.map((item) => item.sessionId),
+    ["new-result", "old-result"],
+  );
+  assert.deepEqual(catalog.unresolvedEvidence.map((item) => item.sessionId), ["orphan"]);
+  assert.deepEqual(catalog.window, {
+    limit: 100,
+    sourceCount: 2,
+    laboratoryCount: 3,
+    sourceLimitReached: false,
+    laboratoryLimitReached: false,
+  });
+  assert.equal("verdict" in catalog.items[0].evidence[0], false);
+  assert.equal(catalog.items[1].evidence.length, 0);
+});
+
+test("Observatory fails visibly when the laboratory projection loses its typed link", () => {
+  assert.throws(
+    () => buildObservatoryCatalog(
+      [source("source", "2026-08-29T10:00:00Z")],
+      [source("not-lab", "2026-08-29T11:00:00Z")],
+    ),
+    ObservatoryCatalogContractError,
+  );
+});
+
+test("Observatory fetches disjoint read-only source and laboratory projections", async () => {
+  const calls = [];
+  const fetcher = async (input, init) => {
+    calls.push({ input: String(input), method: init?.method });
+    return new Response(JSON.stringify({
+      schema_version: "missioncore.observation-session-page/v1", items: [], next_cursor: null,
+    }), {
+      status: 200,
+      headers: { "Content-Type": "application/json" },
+    });
+  };
+
+  const catalog = await fetchObservatoryCatalog({ fetcher, limit: 50 });
+  assert.deepEqual(catalog, {
+    items: [],
+    unresolvedEvidence: [],
+    window: {
+      limit: 50,
+      sourceCount: 0,
+      laboratoryCount: 0,
+      sourceLimitReached: false,
+      laboratoryLimitReached: false,
+    },
+  });
+  assert.deepEqual(
+    calls.map(({ input }) => input).sort(),
+    [
+      "/api/v1/observation-sessions?limit=50&scope=laboratory&lab_contract=v3&pagination=cursor-v1",
+      "/api/v1/observation-sessions?limit=50&scope=source&pagination=cursor-v1",
+    ],
+  );
+  assert.deepEqual(new Set(calls.map(({ method }) => method)), new Set(["GET"]));
+});
+
+test("Observatory exposes bounded-window uncertainty without inventing a broken link", () => {
+  const catalog = buildObservatoryCatalog(
+    [
+      source("newer", "2026-08-29T10:00:00Z"),
+      source("older", "2026-08-28T10:00:00Z"),
+    ],
+    [
+      evidence("linked", "newer", "2026-08-29T11:00:00Z"),
+      evidence("outside-window", "older-than-window", "2026-08-29T12:00:00Z"),
+    ],
+    2,
+  );
+
+  assert.equal(catalog.window.sourceLimitReached, true);
+  assert.equal(catalog.window.laboratoryLimitReached, true);
+  assert.deepEqual(
+    catalog.unresolvedEvidence.map((item) => item.sessionId),
+    ["outside-window"],
+  );
+});
+
+test("historical canonical replay stays out of Observatory without modifying its archive record", () => {
+  const canonicalResultId = `lab-v1-vegetation-shadow-${"8".repeat(64)}`;
+  const canonical = evidence(
+    canonicalResultId,
+    "20260828T130511Z_viewer_live",
+    "2026-08-29T18:05:11Z",
+  );
+  canonical.lab = {
+    ...canonical.lab,
+    labId: "LAB V1",
+    resultKind: "recorded-perception-qualification",
+    resultId: canonicalResultId,
+    sourceResultId: `lab-v1-vegetation-shadow-${"9".repeat(64)}`,
+    configSha256: null,
+    provenance: canonicalProvenance(canonicalResultId),
+    replayCapability: {
+      schemaVersion: "missioncore.observation-lab-replay-capability/v1",
+      kind: "canonical-recorded-rerun",
+      viewerProfile: "recorded-session",
+      timeline: "session_time",
+      activation: "explicit",
+      commandsEnabled: false,
+    },
+  };
+  const before = structuredClone(canonical);
+  const catalog = buildObservatoryCatalog(
+    [source("20260828T130511Z_viewer_live", "2026-08-28T13:05:11Z")],
+    [canonical],
+  );
+
+  assert.deepEqual(catalog.items[0].evidence, []);
+  assert.equal(catalog.window.laboratoryCount, 0);
+  assert.deepEqual(canonical, before);
+});
+
+test("only admitted portable evidence is visible regardless of LAB label, age or installed version", () => {
+  const legacy = evidence("legacy", "source", "2026-09-03T13:00:00Z");
+  legacy.lab.labId = "LAB M4.9T5";
+  legacy.lab.replayCapability = null;
+  const historical = evidence("old-portable", "source", "2026-07-20T10:00:00Z");
+  historical.lab.labId = "LAB E24"; // Labels must never become an allow/deny list.
+  const current = evidence("new-portable", "source", "2026-09-03T12:00:00Z");
+  const catalog = buildObservatoryCatalog(
+    [source("source", "2026-07-19T10:00:00Z")], [legacy, historical, current],
+  );
+  assert.deepEqual(catalog.items[0].evidence.map((item) => item.sessionId), ["new-portable", "old-portable"]);
+  assert.equal(catalog.window.laboratoryCount, 2);
+  assert.equal(findObservatoryEvidence(catalog, "legacy"), null);
+});
+
+test("a malformed portable binding errors instead of silently disappearing as legacy", () => {
+  const broken = evidence("broken", "source", "2026-09-03T12:00:00Z");
+  broken.lab.provenance.source.session_id = "another-source";
+  assert.throws(() => buildObservatoryCatalog(
+    [source("source", "2026-07-19T10:00:00Z")], [broken],
+  ), /identity/);
+});
+
+function wire(item) {
+  const lab = item.lab;
+  return {
+    id: item.id, label: item.label, started_at_utc: item.startedAtUtc,
+    completed_at_utc: item.completedAtUtc, status: item.status,
+    modalities: item.modalities, duration_seconds: item.durationSeconds, replayable: item.replayable,
+    ...(lab ? { lab: {
+      lab_id: "LAB M4.9T5", source_session_id: lab.sourceSessionId, result_kind: lab.resultKind,
+      result_id: lab.resultId, source_result_id: lab.sourceResultId, config_sha256: lab.configSha256,
+      run_created_at_utc: lab.runCreatedAtUtc, published_at_utc: lab.publishedAtUtc,
+      provenance: lab.provenance, replay_capability: lab.replayCapability ? lab.provenance.replay_capability : null,
+      calculation_profile: null,
+    } } : {}),
+  };
+}
+
+function pageResponse(items, nextCursor = null) {
+  return new Response(JSON.stringify({
+    schema_version: "missioncore.observation-session-page/v1",
+    items: items.map(wire), next_cursor: nextCursor,
+  }), { headers: { "Content-Type": "application/json" } });
+}
+
+test("500 sources and later-page results are searchable metadata, with no archive or viewer requests", async () => {
+  const sources = Array.from({ length: 500 }, (_, index) => source(`source-${index}`, "2026-08-29T10:00:00Z"));
+  const labs = Array.from({ length: 101 }, (_, index) => {
+    const item = evidence(`legacy-${index}`, sources[0].id, "2026-08-29T11:00:00Z");
+    item.lab.replayCapability = null;
+    return item;
+  });
+  labs.push(evidence("portable-after-legacy", sources[499].id, "2026-08-29T12:00:00Z"));
+  const calls = [];
+  const catalog = await fetchObservatoryCatalog({ fetcher: async (input, init) => {
+    const url = new URL(String(input), "http://localhost");
+    calls.push(url);
+    assert.equal(init.method, "GET");
+    assert.equal(url.pathname, "/api/v1/observation-sessions");
+    const rows = url.searchParams.get("scope") === "source" ? sources : labs;
+    const cursor = url.searchParams.get("cursor");
+    const start = cursor === null ? 0 : rows.findIndex((item) => item.id === cursor) + 1;
+    const page = rows.slice(start, start + 100);
+    return pageResponse(page, start + page.length < rows.length ? page.at(-1).id : null);
+  } });
+  assert.equal(calls.length, 7);
+  assert.equal(catalog.items.length, 500);
+  assert.equal(catalog.window.laboratoryCount, 1);
+  assert.equal(catalog.window.sourceLimitReached, false);
+  assert.equal(catalog.window.laboratoryLimitReached, false);
+  assert.equal(catalog.items.find((item) => item.source.id === "source-499").evidence[0].sessionId, "portable-after-legacy");
+  assert.deepEqual(catalog.unresolvedEvidence, []);
+});
+
+test("exactly one full page with no cursor is complete, not a guessed truncated window", async () => {
+  const catalog = await fetchObservatoryCatalog({ limit: 1, fetcher: async (url) =>
+    String(url).includes("scope=source")
+      ? pageResponse([source("source", "2026-08-29T10:00:00Z")])
+      : pageResponse([evidence("result", "source", "2026-08-29T11:00:00Z")]),
+  });
+  assert.equal(catalog.window.sourceLimitReached, false);
+  assert.equal(catalog.window.laboratoryLimitReached, false);
+});
+
+test("paging rejects repeated records, cursor cycles, unsafe cursors and unversioned responses", async () => {
+  for (const failure of ["duplicate", "cycle", "unsafe", "unversioned", "too-large"]) {
+    let index = 0;
+    await assert.rejects(fetchObservatoryCatalog({ limit: 1, fetcher: async (url) => {
+      if (String(url).includes("scope=laboratory")) return pageResponse([]);
+      index += 1;
+      if (failure === "unversioned") return new Response(JSON.stringify({ items: [] }));
+      if (failure === "unsafe") return pageResponse([], "../../private");
+      const id = failure === "duplicate" ? "same" : `source-${index}`;
+      const rows = [source(id, "2026-08-29T10:00:00Z")];
+      if (failure === "too-large") rows.push(source("extra", "2026-08-29T10:00:00Z"));
+      return pageResponse(rows, failure === "cycle" ? "cycle" : id);
+    } }));
+    assert.ok(index <= 2);
+  }
+});
+
+test("the traversal cap is explicit and cannot confirm absence of a result", async () => {
+  let count = 0;
+  const catalog = await fetchObservatoryCatalog({ limit: 1, fetcher: async (url) => {
+    if (String(url).includes("scope=source")) return pageResponse([]);
+    count += 1;
+    return pageResponse([], `cursor-${count}`);
+  } });
+  assert.equal(count, 256);
+  assert.equal(catalog.window.laboratoryLimitReached, true);
+  assert.equal(observatoryCatalogConfirmsEvidenceDeletion(catalog, "missing"), false);
+});
+
+test("failure aborts the sibling traversal and an already aborted caller starts no requests", async () => {
+  const signals = [];
+  await assert.rejects(fetchObservatoryCatalog({ fetcher: async (url, init) => {
+    signals.push(init.signal);
+    if (String(url).includes("scope=source")) return new Response("unavailable", { status: 503 });
+    return pageResponse([]);
+  } }), /503/);
+  assert.ok(signals.every((signal) => signal.aborted));
+  const request = new AbortController();
+  request.abort();
+  await assert.rejects(fetchObservatoryCatalog({ signal: request.signal, fetcher: async () => {
+    assert.fail("aborted catalog cannot start a request");
+  } }), { name: "AbortError" });
+});
+
+test("Observatory applies an exact rename locally without mutating canonical identity", () => {
+  const catalog = buildObservatoryCatalog(
+    [source("source", "2026-08-29T10:00:00Z")],
+    [evidence("result", "source", "2026-08-29T11:00:00Z")],
+  );
+  const original = catalog.items[0].evidence[0];
+  const projected = applyObservatoryCatalogMutationOverlay(
+    catalog,
+    new Map([["result", {
+      kind: "rename",
+      displayName: "Операторское имя",
+      revision: 1,
+    }]]),
+  );
+  const renamed = findObservatoryEvidence(projected, "result");
+
+  assert.equal(renamed.label, "Операторское имя");
+  assert.equal(renamed.sessionId, original.sessionId);
+  assert.equal(renamed.lab, original.lab);
+  assert.equal(renamed.recordedRun, original.recordedRun);
+  assert.equal(projected.items[0].source, catalog.items[0].source);
+  assert.equal(projected.window.laboratoryCount, 1);
+});
+
+test("Observatory tombstone removes only its catalog evidence projection", () => {
+  const catalog = buildObservatoryCatalog(
+    [source("source", "2026-08-29T10:00:00Z")],
+    [
+      evidence("remove", "source", "2026-08-29T12:00:00Z"),
+      evidence("keep", "source", "2026-08-29T11:00:00Z"),
+    ],
+  );
+  const projected = applyObservatoryCatalogMutationOverlay(
+    catalog,
+    new Map([["remove", { kind: "delete", revision: 1 }]]),
+  );
+
+  assert.equal(projected.items.length, 1);
+  assert.equal(projected.items[0].source, catalog.items[0].source);
+  assert.deepEqual(
+    projected.items[0].evidence.map(({ sessionId }) => sessionId),
+    ["keep"],
+  );
+  assert.equal(projected.window.sourceCount, 1);
+  assert.equal(projected.window.laboratoryCount, 1);
+});
+
+test("Observatory confirms an ambiguous delete only from a complete LAB window", () => {
+  const bounded = buildObservatoryCatalog(
+    [source("source", "2026-08-29T10:00:00Z")],
+    [evidence("other", "source", "2026-08-29T11:00:00Z")],
+    1,
+  );
+  const complete = buildObservatoryCatalog(
+    [source("source", "2026-08-29T10:00:00Z")],
+    [],
+  );
+
+  assert.equal(observatoryCatalogConfirmsEvidenceDeletion(bounded, "result"), false);
+  assert.equal(observatoryCatalogConfirmsEvidenceDeletion(complete, "result"), true);
+});
+
+test("Observatory reconciliation cannot let a stale in-flight fetch undo a local mutation", () => {
+  const oldCatalog = buildObservatoryCatalog(
+    [source("source", "2026-08-29T10:00:00Z")],
+    [evidence("result", "source", "2026-08-29T11:00:00Z")],
+  );
+  const renameOverlay = new Map([["result", {
+    kind: "rename",
+    displayName: "Новое имя",
+    revision: 1,
+  }]]);
+
+  const staleRename = reconcileObservatoryCatalogMutationOverlay(
+    oldCatalog,
+    renameOverlay,
+    0,
+  );
+  assert.equal(findObservatoryEvidence(staleRename.catalog, "result").label, "Новое имя");
+  assert.equal(staleRename.overlay.has("result"), true);
+
+  const reconciledOldRename = reconcileObservatoryCatalogMutationOverlay(
+    oldCatalog,
+    renameOverlay,
+    1,
+  );
+  assert.equal(findObservatoryEvidence(reconciledOldRename.catalog, "result").label, "Новое имя");
+  assert.equal(reconciledOldRename.overlay.has("result"), true);
+
+  const renamedEvidence = evidence("result", "source", "2026-08-29T11:00:00Z");
+  renamedEvidence.label = "Новое имя";
+  const confirmedRename = reconcileObservatoryCatalogMutationOverlay(
+    buildObservatoryCatalog(
+      [source("source", "2026-08-29T10:00:00Z")],
+      [renamedEvidence],
+    ),
+    staleRename.overlay,
+    1,
+  );
+  assert.equal(findObservatoryEvidence(confirmedRename.catalog, "result").label, "Новое имя");
+  assert.equal(confirmedRename.overlay.size, 0);
+
+  const deleteOverlay = new Map([["result", { kind: "delete", revision: 2 }]]);
+  const staleDelete = reconcileObservatoryCatalogMutationOverlay(
+    oldCatalog,
+    deleteOverlay,
+    1,
+  );
+  assert.equal(findObservatoryEvidence(staleDelete.catalog, "result"), null);
+  assert.equal(staleDelete.overlay.has("result"), true);
+
+  const reconciledOldDelete = reconcileObservatoryCatalogMutationOverlay(
+    oldCatalog,
+    deleteOverlay,
+    2,
+  );
+  assert.equal(findObservatoryEvidence(reconciledOldDelete.catalog, "result"), null);
+  assert.equal(reconciledOldDelete.overlay.has("result"), true);
+
+  const confirmedDelete = reconcileObservatoryCatalogMutationOverlay(
+    buildObservatoryCatalog(
+      [source("source", "2026-08-29T10:00:00Z")],
+      [],
+    ),
+    staleDelete.overlay,
+    2,
+  );
+  assert.equal(findObservatoryEvidence(confirmedDelete.catalog, "result"), null);
+  assert.equal(confirmedDelete.overlay.size, 0);
+});
@@ -0,0 +1,123 @@
+import assert from "node:assert/strict";
+import { after, before, test } from "node:test";
+
+import { createServer } from "vite";
+
+let server;
+let deleteObservatoryLabProjection;
+let renameObservatoryLabProjection;
+let ObservatoryCatalogMutationError;
+
+before(async () => {
+  server = await createServer({
+    appType: "custom",
+    logLevel: "silent",
+    server: { middlewareMode: true },
+  });
+  ({
+    deleteObservatoryLabProjection,
+    renameObservatoryLabProjection,
+    ObservatoryCatalogMutationError,
+  } = await server.ssrLoadModule("/src/core/observatory/catalogMutations.ts"));
+});
+
+after(async () => {
+  await server?.close();
+});
+
+const sessionId = `lab-v1-vegetation-shadow-${"8".repeat(64)}`;
+const binding = {
+  kind: "canonical-recorded-rerun",
+  evidenceSessionId: sessionId,
+  sourceSessionId: "20260828T130511Z_viewer_live",
+  resultId: sessionId,
+  viewerProfile: "recorded-session",
+  timeline: "session_time",
+  activation: "explicit",
+};
+
+test("Observatory rename sends the closed projection-only contract", async () => {
+  const calls = [];
+  const result = await renameObservatoryLabProjection(binding, "  Новый разбор  ", {
+    fetcher: async (input, init) => {
+      calls.push({ input, init });
+      return Response.json({
+        schema_version: "missioncore.observatory-lab-projection/v1",
+        session_id: sessionId,
+        display_name: "Новый разбор",
+      });
+    },
+  });
+  assert.deepEqual(result, {
+    schemaVersion: "missioncore.observatory-lab-projection/v1",
+    sessionId,
+    displayName: "Новый разбор",
+  });
+  assert.equal(calls.length, 1);
+  assert.equal(calls[0].input, `/api/v1/observatory/lab-projections/${sessionId}`);
+  assert.equal(calls[0].init.method, "PATCH");
+  assert.equal(calls[0].init.headers.Accept, "application/json");
+  assert.equal(calls[0].init.headers["Content-Type"], "application/json");
+  assert.deepEqual(JSON.parse(calls[0].init.body), {
+    schema_version: "missioncore.observatory-lab-projection-rename/v1",
+    display_name: "Новый разбор",
+  });
+});
+
+test("Observatory delete accepts only an empty 204 response", async () => {
+  const calls = [];
+  await deleteObservatoryLabProjection(binding, {
+    fetcher: async (input, init) => {
+      calls.push({ input, init });
+      return new Response(null, { status: 204 });
+    },
+  });
+  assert.equal(calls.length, 1);
+  assert.equal(calls[0].input, `/api/v1/observatory/lab-projections/${sessionId}`);
+  assert.equal(calls[0].init.method, "DELETE");
+  await assert.rejects(
+    deleteObservatoryLabProjection(binding, {
+      fetcher: async () => new Response("unexpected", { status: 200 }),
+    }),
+    ObservatoryCatalogMutationError,
+  );
+});
+
+test("Observatory mutations fail closed before network access", async () => {
+  let calls = 0;
+  const fetcher = async () => {
+    calls += 1;
+    return new Response(null, { status: 204 });
+  };
+  await assert.rejects(
+    renameObservatoryLabProjection(binding, " ", { fetcher }),
+    /от 1 до 160/,
+  );
+  await assert.rejects(
+    deleteObservatoryLabProjection({ ...binding, resultId: "different" }, { fetcher }),
+    /не допущен/,
+  );
+  assert.equal(calls, 0);
+});
+
+test("Observatory mutations reject response drift and preserve API detail", async () => {
+  await assert.rejects(
+    renameObservatoryLabProjection(binding, "Разбор", {
+      fetcher: async () => Response.json({
+        schema_version: "missioncore.observatory-lab-projection/v1",
+        session_id: sessionId,
+        display_name: "Разбор",
+        unexpected: true,
+      }),
+    }),
+    /неизвестные поля/,
+  );
+  await assert.rejects(
+    deleteObservatoryLabProjection(binding, {
+      fetcher: async () => Response.json({ detail: "Проекция не принадлежит Обсерватории." }, { status: 409 }),
+    }),
+    (error) => error instanceof ObservatoryCatalogMutationError
+      && error.status === 409
+      && error.message === "Проекция не принадлежит Обсерватории.",
+  );
+});
@@ -0,0 +1,96 @@
+import assert from "node:assert/strict";
+import React from "react";
+import { after, before, test } from "node:test";
+import { createServer } from "vite";
+
+let server;
+let useObservatoryRecordedJobs;
+let useObservatoryLaboratorySetups;
+
+before(async () => {
+  server = await createServer({
+    appType: "custom", logLevel: "silent", server: { middlewareMode: true },
+  });
+  ({ useObservatoryRecordedJobs } = await server.ssrLoadModule("/src/core/observatory/useObservatoryRecordedJobs.ts"));
+  ({ useObservatoryLaboratorySetups } = await server.ssrLoadModule("/src/core/observatory/useObservatoryLaboratorySetups.ts"));
+});
+after(async () => { await server?.close(); });
+
+// Deliberately inspect the render BEFORE effects/cleanup: stale state must already be hidden.
+function renderBeforeEffects(hook, args, stateSlots) {
+  const internals = React.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE;
+  const previous = internals.H;
+  let stateIndex = 0;
+  internals.H = {
+    useState: (initial) => [
+      stateIndex < stateSlots.length ? stateSlots[stateIndex++]
+        : typeof initial === "function" ? initial() : initial,
+      () => {},
+    ],
+    useRef: (value) => ({ current: value }),
+    useMemo: (factory) => factory(),
+    useCallback: (fn) => fn,
+    useEffect: () => {},
+  };
+  try { return hook(...args); } finally { internals.H = previous; }
+}
+
+test("queue data and errors cannot survive a source/setup/version change for one render", () => {
+  const original = ["source-a", "profile-a", "a".repeat(64)];
+  const activeJob = { state: "running", publication: { state: "not-required" } };
+  const snapshot = {
+    selectionKey: JSON.stringify(original), jobs: [activeJob], state: "ready", error: "old error",
+  };
+  assert.equal(renderBeforeEffects(useObservatoryRecordedJobs, original, [snapshot]).activeJob, activeJob);
+  for (const next of [
+    ["source-b", original[1], original[2]],
+    [original[0], "profile-b", original[2]],
+    [original[0], original[1], "b".repeat(64)],
+    ["", "", ""],
+  ]) {
+    const view = renderBeforeEffects(useObservatoryRecordedJobs, next, [snapshot]);
+    assert.deepEqual(view.jobs, []);
+    assert.equal(view.activeJob, null);
+    assert.equal(view.latestJob, null);
+    assert.equal(view.error, null);
+    assert.notEqual(view.state, "ready");
+  }
+});
+
+test("published, incompatible and previous-source profiles have no effective selection", () => {
+  const profile = {
+    setupId: "profile-a", origin: "portable-definition",
+    compatibility: { compatible: true },
+    runDefinition: { definitionSha256: "a".repeat(64) },
+    preflight: { outcome: "ready" },
+  };
+  function render(sourceId, setups) {
+    return renderBeforeEffects(useObservatoryLaboratorySetups, [sourceId], [
+      { sourceSessionId: "source-a", setups }, "ready", null, "profile-a", 0, { kind: "idle" },
+    ]);
+  }
+  assert.equal(render("source-a", [profile]).selectedSetupId, "profile-a");
+  for (const view of [
+    render("source-b", [profile]),
+    render("source-a", [{ ...profile, preflight: { outcome: "existing" } }]),
+    render("source-a", [{ ...profile, compatibility: { compatible: false } }]),
+    render("source-a", []),
+  ]) {
+    assert.equal(view.selectedSetupId, "");
+    assert.equal(view.selectedSetup, null);
+    assert.deepEqual(view.selectableSetups, []);
+  }
+});
+
+test("historical failures are not presented as errors of a new operator action", () => {
+  const selection = ["source-a", "profile-a", "a".repeat(64)];
+  const snapshot = {
+    selectionKey: JSON.stringify(selection),
+    jobs: [{ jobId: "old-run", state: "failed", publication: { state: "not-required" } }],
+    state: "ready", error: null,
+  };
+  const view = renderBeforeEffects(useObservatoryRecordedJobs, selection, [snapshot]);
+  assert.equal(view.computationFailed, false);
+  assert.equal(view.error, null);
+  assert.equal(view.activeJob, null);
+});
@@ -0,0 +1,591 @@
+import assert from "node:assert/strict";
+import { after, before, test } from "node:test";
+
+import { createServer } from "vite";
+
+let server;
+let fetchObservatoryLaboratorySetups;
+let fetchObservatoryPortableLaboratorySetups;
+let preflightObservatoryLaboratorySetup;
+let selectableObservatorySetups;
+let ObservatoryLaboratorySetupContractError;
+
+const authority = {
+  commands_enabled: false,
+  actuation_allowed: false,
+  navigation_or_safety_accepted: false,
+  production_accepted: false,
+};
+
+function definition() {
+  return {
+    schema_version: "missioncore.observatory-run-definition/v1",
+    definition_id: "m49-tgs-full-shadow",
+    version: 1,
+    work_id: "m49-tgs-full-shadow",
+    source: {
+      session_id: "source-a",
+      label: "RAVNOVES00",
+      required_modalities: ["point-cloud", "trajectory", "video"],
+    },
+    configuration: [{ role: "primary-profile", sha256: "a".repeat(64) }],
+    authority,
+    definition_sha256: "b".repeat(64),
+  };
+}
+
+function setup() {
+  return {
+    setup_id: "m49-tgs-full-shadow-v1",
+    display_name: "M4.9T5",
+    description: "Сохранённый полный source-paced shadow.",
+    origin: "archived-definition",
+    source: {
+      session_id: "source-a",
+      label: "RAVNOVES00",
+      required_modalities: ["point-cloud", "trajectory", "video"],
+    },
+    run_definition: definition(),
+    compatibility: { compatible: true, reasons: [] },
+    executor: {
+      contour_id: "worker-006",
+      state: "not-installed",
+      reason_code: "laboratory-runner-adapter-not-installed",
+      reason: "Адаптер не установлен.",
+    },
+    preserved_results: [{
+      result_id: `m49-tgs-full-shadow-${"c".repeat(64)}`,
+      result_kind: "recorded-source-paced-tgs-shadow",
+      relation: "primary-visual",
+      access: "legacy-lab",
+      created_at_utc: "2026-08-26T20:27:19Z",
+      observatory_projection_available: false,
+    }],
+    preflight: {
+      outcome: "blocked",
+      action: "open-legacy",
+      reason: "Точный результат сохранён в legacy LAB.",
+      submission_allowed: false,
+      existing_result_ids: [],
+    },
+    authority,
+  };
+}
+
+function portableSetup() {
+  return {
+    setup_id: "lab-v1-eomt-ddrnet-portable-v1",
+    display_name: "LAB V1 · EoMT Cityscapes Large 1024 + DDRNet-39",
+    description: "Проверка записанной K1-сессии моделями EoMT и DDRNet; только наблюдение.",
+    origin: "portable-definition",
+    source_requirements: {
+      plugin_id: "nodedc.device.xgrids-lixelkity-k1",
+      archive_id: "xgrids-k1.viewer-live.evidence",
+      required_modalities: ["point-cloud", "trajectory", "video"],
+      camera_source_id: "sensor.camera.right",
+      camera_semantic_channel_id: "camera.video.recorded",
+      recorded_media_type: 'video/mp4; codecs="avc1.641028"',
+      recorded_media_init_sha256: "1".repeat(64),
+      camera_width: 800,
+      camera_height: 600,
+      calibration_slot: "camera_1",
+      calibration_identity_sha256: "2".repeat(64),
+      exactly_one_media_epoch: true,
+      seekable: true,
+    },
+    run_definition: {
+      definition_id: "lab-v1-eomt-ddrnet-portable",
+      version: 1,
+      definition_sha256: "3".repeat(64),
+      result_schema: "missioncore.recorded-eomt-ddrnet-review/v2",
+      result_kind: "recorded-perception-qualification",
+      models: [
+        {
+          name: "EoMT Cityscapes Large 1024",
+          release_id: "eomt-cityscapes-large-1024-v1",
+          model_id: "tue-mps/cityscapes_semantic_eomt_large_1024",
+          architecture: "EomtForUniversalSegmentation",
+        },
+        {
+          name: "DDRNet-39",
+          release_id: "lab-v1-ddrnet-39-goose-fine-64-v1",
+          model_id: "goose-ddrnet-class-512",
+          architecture: "ddrnet_39",
+        },
+      ],
+    },
+    source_compatibility: {
+      outcome: "pass",
+      compatible: true,
+      reason_code: "source-compatible",
+      reason: "Запись соответствует требованиям EoMT + DDRNet.",
+    },
+    executor: {
+      contour_id: "worker-006",
+      state: "not-installed",
+      ready: false,
+      reason_code: "eomt-executor-release-unsealed",
+      reason: "Immutable executor release не установлен.",
+    },
+    existing_results: [],
+    preflight: {
+      outcome: "blocked",
+      action: "blocked",
+      reason: "Вычислительный контур LAB V1 пока недоступен.",
+      submission_allowed: false,
+      existing_result_ids: [],
+    },
+    authority,
+  };
+}
+
+function portableM49Setup() {
+  const profile = portableSetup();
+  profile.setup_id = "m49-tgs-portable-v2";
+  profile.display_name = "M4.9T5 · TRAVEL TGS · CPU-only, без ML";
+  profile.description = "Динамический TGS-разбор записанной K1-сессии без ML; только наблюдение.";
+  profile.run_definition = {
+    definition_id: "m49-tgs-portable",
+    version: 2,
+    definition_sha256: "4".repeat(64),
+    result_schema: "missioncore.recorded-travel-tgs-review/v2",
+    result_kind: "recorded-source-paced-tgs-shadow",
+    models: [],
+  };
+  profile.source_compatibility.reason = "Запись соответствует требованиям TRAVEL TGS.";
+  profile.executor.reason_code = "m49-executor-release-unsealed";
+  profile.executor.reason = "Immutable executor release не установлен.";
+  profile.preflight.reason = "Переносимый вычислительный контур M4.9T5 пока недоступен.";
+  return profile;
+}
+
+before(async () => {
+  server = await createServer({
+    appType: "custom",
+    logLevel: "silent",
+    server: { middlewareMode: true },
+  });
+  ({
+    fetchObservatoryLaboratorySetups,
+    fetchObservatoryPortableLaboratorySetups,
+    preflightObservatoryLaboratorySetup,
+    selectableObservatorySetups,
+    ObservatoryLaboratorySetupContractError,
+  } = await server.ssrLoadModule("/src/core/observatory/laboratorySetups.ts"));
+});
+
+after(async () => {
+  await server?.close();
+});
+
+test("Observatory setup catalog keeps definition identity separate from executor availability", async () => {
+  const calls = [];
+  const fetcher = async (input, init) => {
+    calls.push({ input: String(input), init });
+    return new Response(JSON.stringify({
+      schema_version: "missioncore.observatory-laboratory-setup-catalog/v1",
+      source_session_id: "source-a",
+      setups: [setup()],
+      authority,
+    }), { status: 200, headers: { "Content-Type": "application/json" } });
+  };
+
+  const catalog = await fetchObservatoryLaboratorySetups("source-a", { fetcher });
+  assert.equal(catalog.setups[0].runDefinition.definitionSha256, "b".repeat(64));
+  assert.equal(catalog.setups[0].executor.state, "not-installed");
+  assert.equal(catalog.setups[0].preflight.submissionAllowed, false);
+  assert.equal(catalog.setups[0].preservedResults[0].access, "legacy-lab");
+  assert.equal(
+    calls[0].input,
+    "/api/v1/observatory/laboratory-setups?source_session_id=source-a",
+  );
+  assert.equal(calls[0].init.method, "GET");
+});
+
+test("portable profiles report compatible source separately from unavailable Worker", async () => {
+  const calls = [];
+  const selected = (await fetchObservatoryPortableLaboratorySetups("source-a", {
+    fetcher: async (input, init) => {
+      calls.push({ input: String(input), init });
+      return new Response(JSON.stringify({
+        schema_version: "missioncore.observatory-portable-setup-catalog/v2",
+        source_session_id: "source-a",
+        setups: [portableSetup(), portableM49Setup()],
+        authority,
+      }), { status: 200 });
+    },
+  })).setups[0];
+
+  assert.equal(selected.origin, "portable-definition");
+  assert.equal(selected.compatibility.compatible, true);
+  assert.equal(selected.executor.state, "not-installed");
+  assert.equal(selected.preflight.submissionAllowed, false);
+  assert.deepEqual(selected.runDefinition.models.map((model) => model.name), [
+    "EoMT Cityscapes Large 1024",
+    "DDRNet-39",
+  ]);
+  const m49 = (await fetchObservatoryPortableLaboratorySetups("source-a", {
+    fetcher: async () => new Response(JSON.stringify({
+      schema_version: "missioncore.observatory-portable-setup-catalog/v2",
+      source_session_id: "source-a",
+      setups: [portableSetup(), portableM49Setup()],
+      authority,
+    }), { status: 200 }),
+  })).setups[1];
+  assert.equal(m49.displayName, "M4.9T5 · TRAVEL TGS · CPU-only, без ML");
+  assert.deepEqual(m49.runDefinition.models, []);
+  assert.equal(
+    calls[0].input,
+    "/api/v1/observatory/portable-laboratory-setups?source_session_id=source-a",
+  );
+
+  let preflightRequest;
+  const preflight = await preflightObservatoryLaboratorySetup("source-a", selected, {
+    fetcher: async (input, init) => {
+      preflightRequest = { input: String(input), init };
+      return new Response(JSON.stringify({
+        schema_version: "missioncore.observatory-run-preflight/v1",
+        source_session_id: "source-a",
+        setup_id: selected.setupId,
+        definition_sha256: "3".repeat(64),
+        check_sha256: null,
+        outcome: "blocked",
+        submission_allowed: false,
+        checks: [{
+          check_id: "executor",
+          outcome: "fail",
+          reason_code: "eomt-executor-release-unsealed",
+          message: "Immutable executor release не установлен.",
+        }],
+        existing_result_ids: [],
+        executor: portableSetup().executor,
+        authority,
+      }), { status: 200 });
+    },
+  });
+  assert.equal(preflightRequest.input, "/api/v1/observatory/run-preflights");
+  assert.equal(preflightRequest.init.method, "POST");
+  assert.equal(preflight.outcome, "blocked");
+  assert.equal(preflight.submissionAllowed, false);
+  assert.equal(preflight.checkSha256, null);
+  assert.equal(preflight.checks[0].outcome, "fail");
+});
+
+test("portable profile accepts a consistent ready projection", async () => {
+  const ready = portableSetup();
+  ready.executor = {
+    contour_id: "worker-006",
+    state: "ready",
+    ready: true,
+    reason_code: null,
+    reason: null,
+  };
+  ready.preflight = {
+    outcome: "ready",
+    action: "check",
+    reason: "Запись готова к постановке в очередь.",
+    submission_allowed: true,
+    existing_result_ids: [],
+  };
+
+  const catalog = await fetchObservatoryPortableLaboratorySetups("source-a", {
+    fetcher: async () => new Response(JSON.stringify({
+      schema_version: "missioncore.observatory-portable-setup-catalog/v2",
+      source_session_id: "source-a",
+      setups: [ready],
+      authority,
+    }), { status: 200 }),
+  });
+  assert.equal(catalog.setups[0].executor.state, "ready");
+  assert.equal(catalog.setups[0].preflight.outcome, "ready");
+  assert.equal(catalog.setups[0].preflight.submissionAllowed, true);
+});
+
+test("portable LAB V1 rejects an unbound existing result projection", async () => {
+  const spoofed = portableSetup();
+  spoofed.existing_results = [{
+    result_id: `legacy-vegetation-${"4".repeat(64)}`,
+    result_kind: "recorded-perception-qualification",
+    created_at_utc: "2026-08-30T18:16:00Z",
+  }];
+  spoofed.preflight = {
+    outcome: "existing",
+    action: "open-existing",
+    reason: "Результат якобы готов.",
+    submission_allowed: false,
+    existing_result_ids: [spoofed.existing_results[0].result_id],
+  };
+
+  await assert.rejects(
+    fetchObservatoryPortableLaboratorySetups("source-a", {
+      fetcher: async () => new Response(JSON.stringify({
+        schema_version: "missioncore.observatory-portable-setup-catalog/v2",
+        source_session_id: "source-a",
+        setups: [spoofed],
+        authority,
+      }), { status: 200 }),
+    }),
+    /значение изменилось|значение не поддерживается|обнаружены неизвестные поля/,
+  );
+});
+
+test("portable LAB V1 rejects heavyweight compatibility evidence", async () => {
+  const heavyweight = portableSetup();
+  heavyweight.source_compatibility.evidence = {
+    frame_count: 6830,
+    timeline_start_seconds: 0,
+    timeline_end_seconds: 819,
+  };
+
+  await assert.rejects(
+    fetchObservatoryPortableLaboratorySetups("source-a", {
+      fetcher: async () => new Response(JSON.stringify({
+        schema_version: "missioncore.observatory-portable-setup-catalog/v2",
+        source_session_id: "source-a",
+        setups: [heavyweight],
+        authority,
+      }), { status: 200 }),
+    }),
+    /неизвестные поля/,
+  );
+});
+
+function cachedPortableSetup() {
+  const setup = portableSetup();
+  setup.existing_results = [{
+    result_id: "portable-result-001",
+    result_kind: setup.run_definition.result_kind,
+    relation: "exact-recorded-computation",
+    access: "observatory",
+    created_at_utc: "2026-09-03T00:00:00Z",
+    observatory_projection_available: true,
+    identity: {
+      job_id: "observatory-run-001",
+      source_session_id: "source-a",
+      source_catalog_sha256: "a".repeat(64),
+      source_bundle_sha256: "b".repeat(64),
+      source_capability_manifest_sha256: "c".repeat(64),
+      setup_id: setup.setup_id,
+      definition_sha256: setup.run_definition.definition_sha256,
+      package_sha256: "d".repeat(64),
+      artifact_manifest_id: "e".repeat(64),
+    },
+  }];
+  setup.preflight = {
+    outcome: "existing", action: "open-existing",
+    reason: "Точный результат проверен.", submission_allowed: false,
+    existing_result_ids: [setup.existing_results[0].result_id],
+  };
+  return setup;
+}
+
+function fetchCachedPortable(setup) {
+  return fetchObservatoryPortableLaboratorySetups("source-a", {
+    fetcher: async () => new Response(JSON.stringify({
+      schema_version: "missioncore.observatory-portable-setup-catalog/v2",
+      source_session_id: "source-a", setups: [setup], authority,
+    }), { status: 200 }),
+  });
+}
+
+test("portable exact cached result is readable without an installed executor", async () => {
+  const catalog = await fetchCachedPortable(cachedPortableSetup());
+  const setup = catalog.setups[0];
+  assert.equal(setup.executor.state, "not-installed");
+  assert.equal(setup.preflight.outcome, "existing");
+  assert.equal(setup.preflight.submissionAllowed, false);
+  assert.deepEqual(setup.preflight.existingResultIds, ["portable-result-001"]);
+  assert.equal(setup.preservedResults[0].access, "observatory");
+});
+
+test("selector contains only compatible uncalculated portable definitions", async () => {
+  const uncached = (await fetchCachedPortable(portableSetup())).setups[0];
+  const cached = (await fetchCachedPortable(cachedPortableSetup())).setups[0];
+  const currentVersion = {
+    ...uncached,
+    runDefinition: { ...uncached.runDefinition, version: 2, definitionSha256: "f".repeat(64) },
+  };
+  const catalog = (setups) => ({ sourceSessionId: "source-a", setups });
+  assert.deepEqual(selectableObservatorySetups(null), []);
+  assert.deepEqual(selectableObservatorySetups(catalog([])), []);
+  assert.deepEqual(selectableObservatorySetups(catalog([cached])), []);
+  // Same display label and setup ID, but no verified cache hit for the new definition.
+  assert.deepEqual(selectableObservatorySetups(catalog([currentVersion])), [currentVersion]);
+  assert.deepEqual(selectableObservatorySetups(catalog([
+    cached,
+    { ...uncached, setupId: "remaining-profile" },
+  ])).map((s) => s.setupId), ["remaining-profile"]);
+  assert.deepEqual(selectableObservatorySetups(catalog([
+    { ...uncached, compatibility: { compatible: false, reasons: [] } },
+    { ...uncached, origin: "archived-definition" },
+    { ...uncached, origin: "existing-result" },
+    { ...uncached, runDefinition: null },
+  ])), []);
+  // Worker availability does not masquerade as completed computation.
+  assert.equal(uncached.executor.state, "not-installed");
+  assert.deepEqual(selectableObservatorySetups(catalog([uncached])), [uncached]);
+  // A missing/deleted/unpublished projection is not a completed result.
+  assert.deepEqual(selectableObservatorySetups(catalog([{
+    ...uncached, preservedResults: cached.preservedResults,
+  }])).map((s) => s.setupId), [uncached.setupId]);
+});
+
+for (const [label, change] of [
+  ["another source", (s) => { s.existing_results[0].identity.source_session_id = "source-b"; }],
+  ["another setup", (s) => { s.existing_results[0].identity.setup_id = "another-profile"; }],
+  ["another version", (s) => { s.existing_results[0].identity.definition_sha256 = "f".repeat(64); }],
+  ["bad package digest", (s) => { s.existing_results[0].identity.package_sha256 = "not-a-digest"; }],
+  ["unavailable artifact", (s) => { s.existing_results[0].observatory_projection_available = false; }],
+  ["missing binding", (s) => { delete s.existing_results[0].identity; }],
+  ["unrelated result ID", (s) => { s.preflight.existing_result_ids = ["different-result"]; }],
+  ["duplicate result", (s) => {
+    s.existing_results.push(s.existing_results[0]);
+    s.preflight.existing_result_ids.push(s.preflight.existing_result_ids[0]);
+  }],
+  ["contradictory action", (s) => { s.preflight.action = "check"; }],
+  ["cached but queueable", (s) => { s.preflight.submission_allowed = true; }],
+]) {
+  test(`portable cached result rejects ${label}`, async () => {
+    const setup = cachedPortableSetup();
+    change(setup);
+    await assert.rejects(fetchCachedPortable(setup));
+  });
+}
+
+test("Observatory preflight sends the exact selected definition and never submits a run", async () => {
+  const selected = (await fetchObservatoryLaboratorySetups("source-a", {
+    fetcher: async () => new Response(JSON.stringify({
+      schema_version: "missioncore.observatory-laboratory-setup-catalog/v1",
+      source_session_id: "source-a",
+      setups: [setup()],
+      authority,
+    }), { status: 200 }),
+  })).setups[0];
+  let request;
+  const preflight = await preflightObservatoryLaboratorySetup("source-a", selected, {
+    fetcher: async (input, init) => {
+      request = { input: String(input), init };
+      return new Response(JSON.stringify({
+        schema_version: "missioncore.observatory-run-preflight/v1",
+        source_session_id: "source-a",
+        setup_id: selected.setupId,
+        definition_sha256: "b".repeat(64),
+        check_sha256: null,
+        outcome: "blocked",
+        submission_allowed: false,
+        checks: [{
+          check_id: "executor",
+          outcome: "fail",
+          reason_code: "laboratory-runner-adapter-not-installed",
+          message: "Адаптер не установлен.",
+        }],
+        existing_result_ids: [],
+        executor: setup().executor,
+        authority,
+      }), { status: 200 });
+    },
+  });
+
+  assert.equal(request.input, "/api/v1/observatory/run-preflights");
+  assert.equal(request.init.method, "POST");
+  assert.deepEqual(JSON.parse(request.init.body), {
+    schema_version: "missioncore.observatory-run-preflight-request/v1",
+    source_session_id: "source-a",
+    setup_id: "m49-tgs-full-shadow-v1",
+    definition_sha256: "b".repeat(64),
+  });
+  assert.equal(preflight.outcome, "blocked");
+  assert.equal(preflight.submissionAllowed, false);
+  assert.equal(preflight.checkSha256, null);
+});
+
+test("Observatory dynamic preflight admits only an explicit queueable response", async () => {
+  const selected = (await fetchObservatoryLaboratorySetups("source-a", {
+    fetcher: async () => new Response(JSON.stringify({
+      schema_version: "missioncore.observatory-laboratory-setup-catalog/v1",
+      source_session_id: "source-a",
+      setups: [setup()],
+      authority,
+    }), { status: 200 }),
+  })).setups[0];
+
+  const preflight = await preflightObservatoryLaboratorySetup("source-a", selected, {
+    fetcher: async () => new Response(JSON.stringify({
+      schema_version: "missioncore.observatory-run-preflight/v1",
+      source_session_id: "source-a",
+      setup_id: selected.setupId,
+      definition_sha256: "b".repeat(64),
+      outcome: "queueable",
+      submission_allowed: true,
+      checks: [{
+        check_id: "durable-queue",
+        outcome: "pass",
+        reason_code: "exact-binding-ready",
+        message: "Точный источник и очередь готовы.",
+      }],
+      existing_result_ids: [],
+      executor: setup().executor,
+      authority,
+    }), { status: 200 }),
+  });
+
+  assert.equal(preflight.outcome, "queueable");
+  assert.equal(preflight.submissionAllowed, true);
+  assert.equal(preflight.checkSha256, null);
+});
+
+test("Observatory setup contract rejects authority escalation and response drift", async () => {
+  const escalated = setup();
+  escalated.authority = { ...authority, commands_enabled: true };
+  await assert.rejects(
+    fetchObservatoryLaboratorySetups("source-a", {
+      fetcher: async () => new Response(JSON.stringify({
+        schema_version: "missioncore.observatory-laboratory-setup-catalog/v1",
+        source_session_id: "source-a",
+        setups: [escalated],
+        authority,
+      }), { status: 200 }),
+    }),
+    ObservatoryLaboratorySetupContractError,
+  );
+
+  const drifted = setup();
+  drifted.unexpected = true;
+  await assert.rejects(
+    fetchObservatoryLaboratorySetups("source-a", {
+      fetcher: async () => new Response(JSON.stringify({
+        schema_version: "missioncore.observatory-laboratory-setup-catalog/v1",
+        source_session_id: "source-a",
+        setups: [drifted],
+        authority,
+      }), { status: 200 }),
+    }),
+    ObservatoryLaboratorySetupContractError,
+  );
+
+  const selected = (await fetchObservatoryLaboratorySetups("source-a", {
+    fetcher: async () => new Response(JSON.stringify({
+      schema_version: "missioncore.observatory-laboratory-setup-catalog/v1",
+      source_session_id: "source-a",
+      setups: [setup()],
+      authority,
+    }), { status: 200 }),
+  })).setups[0];
+  await assert.rejects(
+    preflightObservatoryLaboratorySetup("source-a", selected, {
+      fetcher: async () => new Response(JSON.stringify({
+        schema_version: "missioncore.observatory-run-preflight/v1",
+        source_session_id: "source-a",
+        setup_id: selected.setupId,
+        definition_sha256: "c".repeat(64),
+        outcome: "blocked",
+        submission_allowed: false,
+        checks: [],
+        existing_result_ids: [],
+        executor: setup().executor,
+        authority,
+      }), { status: 200 }),
+    }),
+    ObservatoryLaboratorySetupContractError,
+  );
+});
@@ -0,0 +1,277 @@
+import assert from "node:assert/strict";
+import { after, before, test } from "node:test";
+
+import { createServer } from "vite";
+
+let server;
+let fetchObservatoryRecordedJobs;
+let retryObservatoryRecordedJobPublication;
+let submitObservatoryRecordedJob;
+let ObservatoryRecordedJobContractError;
+
+const authority = {
+  commands_enabled: false,
+  actuation_allowed: false,
+  navigation_or_safety_accepted: false,
+  production_accepted: false,
+};
+
+function job(state = "queued") {
+  return {
+    schema_version: "missioncore.observatory-recorded-job/v1",
+    job_id: "observatory-run-0123456789abcdef0123456789abcdef",
+    idempotency_key: "observatory-ui:source-a:m49-tgs:request-a",
+    request_sha256: "1".repeat(64),
+    identity_sha256: "2".repeat(64),
+    submission_receipt_sha256: "3".repeat(64),
+    source: {
+      session_id: "source-a",
+      catalog_sha256: "4".repeat(64),
+      bundle_sha256: "5".repeat(64),
+      capability_manifest_sha256: "6".repeat(64),
+      adapter: {
+        adapter_id: "ravnoves00-m49-source-pack",
+        version: 1,
+        adapter_sha256: "7".repeat(64),
+      },
+    },
+    setup: {
+      setup_id: "m49-tgs",
+      definition_id: "m49-tgs",
+      definition_version: 1,
+      definition_sha256: "8".repeat(64),
+    },
+    executor: {
+      release_id: "m49-tgs-release",
+      release_sha256: "9".repeat(64),
+      image_sha256: "a".repeat(64),
+      model_release_ids: [],
+      learned_models: [],
+      model_manifest_sha256: "b".repeat(64),
+      resource_profile_id: "m49-tgs-cpu",
+      resource_profile_sha256: "c".repeat(64),
+    },
+    checkpoint_policy: {
+      mode: "non-checkpointable",
+      allowed_checkpoints: [],
+      last_checkpoint_id: null,
+    },
+    priority: { class: "recorded", rank: 100, server_owned: true },
+    state,
+    preemption_requested: state === "preemption-pending",
+    restart_from_zero: state === "paused",
+    preemption_receipt_sha256: null,
+    claim_generation: 0,
+    claim_lease: null,
+    result: state === "succeeded"
+      ? { result_id: "m49-result", sha256: "d".repeat(64) }
+      : null,
+    publication: {
+      state: "not-required",
+      attempts: 0,
+      error: null,
+      published_at_utc: null,
+    },
+    terminal: state === "failed"
+      ? { code: "worker-failed", message: "Worker завершил расчёт с ошибкой." }
+      : null,
+    created_at_utc: "2026-08-31T10:00:00Z",
+    updated_at_utc: "2026-08-31T10:00:01Z",
+    authority,
+  };
+}
+
+before(async () => {
+  server = await createServer({
+    appType: "custom",
+    logLevel: "silent",
+    server: { middlewareMode: true },
+  });
+  ({
+    fetchObservatoryRecordedJobs,
+    retryObservatoryRecordedJobPublication,
+    submitObservatoryRecordedJob,
+    ObservatoryRecordedJobContractError,
+  } = await server.ssrLoadModule("/src/core/observatory/recordedJobs.ts"));
+});
+
+after(async () => {
+  await server?.close();
+});
+
+test("Observatory reads the exact session/setup queue without polling", async () => {
+  const calls = [];
+  const jobs = await fetchObservatoryRecordedJobs("source-a", "m49-tgs", {
+    fetcher: async (input, init) => {
+      calls.push({ input: String(input), init });
+      return new Response(JSON.stringify({
+        schema_version: "missioncore.observatory-recorded-job-list/v1",
+        items: [job("running")],
+        authority,
+      }), { status: 200 });
+    },
+  });
+
+  assert.equal(calls.length, 1);
+  assert.equal(
+    calls[0].input,
+    "/api/v1/observatory/runs?source_session_id=source-a&setup_id=m49-tgs&limit=20",
+  );
+  assert.equal(calls[0].init.method, "GET");
+  assert.equal(jobs[0].state, "running");
+  assert.equal(jobs[0].definitionSha256, "8".repeat(64));
+});
+
+test("Observatory submits only public identities and accepts every durable state", async () => {
+  const states = [
+    "accepted",
+    "queued",
+    "claimed",
+    "running",
+    "paused",
+    "preemption-pending",
+    "succeeded",
+    "failed",
+    "reconciliation-required",
+  ];
+
+  for (const state of states) {
+    let request;
+    const result = await submitObservatoryRecordedJob(
+      "source-a",
+      "m49-tgs",
+      "observatory-ui:source-a:m49-tgs:request-a",
+      null,
+      {
+        fetcher: async (input, init) => {
+          request = { input: String(input), init };
+          return new Response(JSON.stringify(job(state)), { status: 200 });
+        },
+      },
+    );
+    assert.equal(result.state, state);
+    assert.equal(request.input, "/api/v1/observatory/runs");
+    assert.equal(request.init.method, "POST");
+    assert.deepEqual(JSON.parse(request.init.body), {
+      schema_version: "missioncore.observatory-recorded-run-submit/v1",
+      idempotency_key: "observatory-ui:source-a:m49-tgs:request-a",
+      source_session_id: "source-a",
+      setup_id: "m49-tgs",
+    });
+  }
+});
+
+test("Observatory queue contract rejects authority escalation and response drift", async () => {
+  const escalated = job();
+  escalated.authority = { ...authority, commands_enabled: true };
+  await assert.rejects(
+    fetchObservatoryRecordedJobs("source-a", "m49-tgs", {
+      fetcher: async () => new Response(JSON.stringify({
+        schema_version: "missioncore.observatory-recorded-job-list/v1",
+        items: [escalated],
+        authority,
+      }), { status: 200 }),
+    }),
+    ObservatoryRecordedJobContractError,
+  );
+
+  const drifted = job();
+  drifted.worker_command = "forbidden";
+  await assert.rejects(
+    submitObservatoryRecordedJob(
+      "source-a",
+      "m49-tgs",
+      "observatory-ui:source-a:m49-tgs:request-a",
+      null,
+      { fetcher: async () => new Response(JSON.stringify(drifted), { status: 200 }) },
+    ),
+    ObservatoryRecordedJobContractError,
+  );
+});
+
+test("portable submission carries the exact definition/check fence", async () => {
+  let request;
+  await submitObservatoryRecordedJob(
+    "source-a",
+    "lab-v1-eomt-ddrnet-portable-v1",
+    "observatory-ui:source-a:lab-v1:request-a",
+    {
+      definitionSha256: "e".repeat(64),
+      checkSha256: "f".repeat(64),
+    },
+    {
+      fetcher: async (input, init) => {
+        request = { input: String(input), init };
+        const response = job("queued");
+        response.setup.setup_id = "lab-v1-eomt-ddrnet-portable-v1";
+        response.setup.definition_sha256 = "e".repeat(64);
+        response.source.session_id = "source-a";
+        return new Response(JSON.stringify(response), { status: 202 });
+      },
+    },
+  );
+
+  assert.deepEqual(JSON.parse(request.init.body), {
+    schema_version: "missioncore.observatory-recorded-run-submit/v1",
+    idempotency_key: "observatory-ui:source-a:lab-v1:request-a",
+    source_session_id: "source-a",
+    setup_id: "lab-v1-eomt-ddrnet-portable-v1",
+    definition_sha256: "e".repeat(64),
+    check_sha256: "f".repeat(64),
+  });
+});
+
+test("publication retry never submits a second compute request", async () => {
+  let request;
+  const response = job("succeeded");
+  response.publication = {
+    state: "published",
+    attempts: 2,
+    error: null,
+    published_at_utc: "2026-09-01T12:00:00Z",
+  };
+  const retried = await retryObservatoryRecordedJobPublication(response.job_id, {
+    fetcher: async (input, init) => {
+      request = { input: String(input), init };
+      return new Response(JSON.stringify(response), { status: 200 });
+    },
+  });
+
+  assert.equal(
+    request.input,
+    `/api/v1/observatory/runs/${response.job_id}/publication/retry`,
+  );
+  assert.equal(request.init.method, "POST");
+  assert.equal(request.init.body, undefined);
+  assert.equal(retried.publication.state, "published");
+});
+
+test("queue query and response are fenced to the selected definition", async () => {
+  const oldVersion = job("succeeded");
+  oldVersion.setup.definition_sha256 = "f".repeat(64);
+  const otherSource = job("running");
+  otherSource.source.session_id = "source-b";
+  const otherSetup = job("running");
+  otherSetup.setup.setup_id = "other-setup";
+  let url;
+  const jobs = await fetchObservatoryRecordedJobs("source-a", "m49-tgs", {
+    definitionSha256: "8".repeat(64),
+    fetcher: async (input) => {
+      url = new URL(String(input), "http://localhost");
+      return new Response(JSON.stringify({
+        schema_version: "missioncore.observatory-recorded-job-list/v1",
+        items: [oldVersion, otherSource, otherSetup, job("queued")], authority,
+      }));
+    },
+  });
+  assert.equal(url.searchParams.get("definition_sha256"), "8".repeat(64));
+  assert.deepEqual(jobs.map((j) => j.state), ["queued"]);
+});
+
+test("portable submit rejects a successful response for an old definition", async () => {
+  await assert.rejects(submitObservatoryRecordedJob(
+    "source-a", "m49-tgs", "test-request",
+    { definitionSha256: "f".repeat(64), checkSha256: "e".repeat(64) },
+    { fetcher: async () => new Response(JSON.stringify(job("succeeded"))) },
+  ), ObservatoryRecordedJobContractError);
+});
@@ -0,0 +1,83 @@
+import assert from "node:assert/strict";
+import { after, before, test } from "node:test";
+import { createServer } from "vite";
+
+let server;
+let decode;
+let label;
+let fetchProgress;
+const job = {
+  jobId: "observatory-run-" + "1".repeat(32),
+  sourceSessionId: "source-a", setupId: "m49-tgs",
+  definitionSha256: "a".repeat(64), claimGeneration: 2, state: "running",
+  publication: { state: "not-required" },
+};
+function view() {
+  return {
+    schema_version: "missioncore.observatory-recorded-progress-view/v1",
+    job_id: job.jobId, source_session_id: job.sourceSessionId, setup_id: job.setupId,
+    definition_sha256: job.definitionSha256, claim_generation: 2, state: "running",
+    received_at_utc: "2026-09-03T12:00:00Z", age_seconds: 0.5,
+    progress: {
+      schema_version: "missioncore.observatory-recorded-progress/v1",
+      claim_generation: 2, sequence: 4, phase_index: 2,
+      phase: "computing", unit: "frames", completed: 3, total: 10,
+      elapsed_seconds: 8, phase_elapsed_seconds: 5,
+    },
+  };
+}
+before(async () => {
+  server = await createServer({ configFile: false, logLevel: "silent", server: { middlewareMode: true } });
+  const module = await server.ssrLoadModule("/src/core/observatory/recordedProgress.ts");
+  decode = module.decodeRecordedProgress;
+  label = module.recordedProgressLabel;
+  fetchProgress = module.fetchRecordedProgress;
+});
+after(async () => { await server?.close(); });
+
+test("actual frame count is separate from completion and publication", () => {
+  const progress = decode(view(), job);
+  assert.equal(label(job, progress), "Обрабатываем запись · 3 / 10 кадров");
+  assert.equal(label({ ...job, publication: { state: "pending" } }, progress), "Сохраняем результат");
+  assert.doesNotMatch(label(job, progress), /%|завершён|FPS|ETA/);
+});
+test("unknown total never becomes a synthetic percentage", () => {
+  const value = view();
+  value.progress.total = null;
+  assert.equal(label(job, decode(value, job)), "Обрабатываем запись · 3 кадров");
+  value.progress.completed = 0;
+  assert.equal(label(job, decode(value, job)), "Обрабатываем запись");
+});
+test("old source definition or attempt cannot flash as current progress", () => {
+  for (const delta of [
+    { job_id: "other" }, { source_session_id: "other" }, { setup_id: "other" },
+    { definition_sha256: "b".repeat(64) }, { claim_generation: 1 },
+  ]) assert.throws(() => decode({ ...view(), ...delta }, job));
+  assert.equal(decode({ ...view(), state: "succeeded" }, job), null);
+  assert.equal(label({ ...job, claimGeneration: 3 }, decode(view(), job)), "Ожидаем данные расчёта");
+});
+test("invalid counters, invented phase and extra fields fail closed", () => {
+  for (const delta of [
+    { completed: true }, { completed: 11 }, { completed: -1 }, { total: 0 },
+    { completed: Number.MAX_SAFE_INTEGER + 1 }, { phase: "done" }, { path: "/private" },
+    { phase_elapsed_seconds: 9 }, { claim_generation: 3 },
+  ]) assert.throws(() => decode({ ...view(), progress: { ...view().progress, ...delta } }, job));
+});
+test("missing and stale telemetry show no fabricated advancement", () => {
+  assert.equal(decode({ ...view(), progress: null, age_seconds: null, received_at_utc: null }, job), null);
+  assert.equal(label(job, null), "Ожидаем данные расчёта");
+  assert.equal(label(job, decode({ ...view(), age_seconds: 30 }, job)), "Ожидаем обновление прогресса");
+});
+test("terminal jobs keep their real state when progress telemetry is absent", () => {
+  assert.equal(label({ ...job, state: "failed" }, null), "Ошибка расчёта");
+  assert.equal(label({ ...job, state: "succeeded" }, null), "Расчёт завершён");
+});
+test("progress is a read-only request bound to the active job", async () => {
+  const calls = [];
+  const progress = await fetchProgress(job, { fetcher: async (path, init) => {
+    calls.push([path, init.method ?? "GET"]);
+    return new Response(JSON.stringify(view()));
+  } });
+  assert.deepEqual(calls, [[`/api/v1/observatory/runs/${job.jobId}/progress`, "GET"]]);
+  assert.equal(progress.completed, 3);
+});
@@ -0,0 +1,292 @@
+import assert from "node:assert/strict";
+import { readFile } from "node:fs/promises";
+import { after, before, test } from "node:test";
+
+import { createServer } from "vite";
+
+let server;
+let admitObservatoryRecordedRunReview;
+let fetchObservatoryRecordedRunReview;
+let observatoryRecordedRunBinding;
+let ObservatoryRecordedRunContractError;
+
+before(async () => {
+  server = await createServer({
+    appType: "custom",
+    logLevel: "silent",
+    server: { middlewareMode: true },
+  });
+  ({
+    admitObservatoryRecordedRunReview,
+    fetchObservatoryRecordedRunReview,
+    observatoryRecordedRunBinding,
+    ObservatoryRecordedRunContractError,
+  } = await server.ssrLoadModule("/src/core/observatory/recordedRun.ts"));
+});
+
+after(async () => {
+  await server?.close();
+});
+
+const sourceSessionId = "20260828T130511Z_viewer_live";
+const resultId = `lab-v1-vegetation-shadow-${"8".repeat(64)}`;
+
+function canonicalProvenance() {
+  const identitySha256 = resultId.slice("lab-v1-vegetation-shadow-".length);
+  return {
+    schema_version: "missioncore.canonical-recorded-lab-projection/v1",
+    evidence_identity_sha256: identitySha256,
+    result_document_sha256: "a".repeat(64),
+    replay_capability: {
+      schema_version: "missioncore.observation-lab-replay-capability/v1",
+      kind: "canonical-recorded-rerun",
+      viewer_profile: "recorded-session",
+      timeline: "session_time",
+      activation: "explicit",
+      commands_enabled: false,
+    },
+    authority: {
+      commands_enabled: false,
+      navigation_or_safety_accepted: false,
+      actuation_accepted: false,
+    },
+    method: {
+      schema_version: "missioncore.laboratory-method/v1",
+      completeness: "legacy-partial",
+      execution_class: "ai-inference",
+      pipeline_id: "ravnoves004tree-full-eomt-ddrnet-recorded-review/v1",
+      components: [{
+        kind: "source",
+        name: "sealed full-route LAB result",
+        version: "missioncore.lab-v1-vegetation-shadow/v1",
+        role: "immutable Session catalog projection",
+        identity_sha256: identitySha256,
+      }],
+    },
+  };
+}
+
+function lab(overrides = {}) {
+  return {
+    labId: "LAB V1",
+    sourceSessionId,
+    resultKind: "recorded-perception-qualification",
+    resultId,
+    sourceResultId: `lab-v1-vegetation-shadow-${"9".repeat(64)}`,
+    configSha256: null,
+    runCreatedAtUtc: "2026-08-29T18:05:11.329061+00:00",
+    publishedAtUtc: "2026-08-30T12:00:00.000Z",
+    replayCapability: {
+      schemaVersion: "missioncore.observation-lab-replay-capability/v1",
+      kind: "canonical-recorded-rerun",
+      viewerProfile: "recorded-session",
+      timeline: "session_time",
+      activation: "explicit",
+      commandsEnabled: false,
+    },
+    provenance: canonicalProvenance(),
+    ...overrides,
+  };
+}
+
+function portableCapability() {
+  return {
+    schemaVersion: "missioncore.observation-lab-replay-capability/v2",
+    kind: "portable-result-review",
+    viewerProfile: "portable-result",
+    timeline: "result-defined",
+    activation: "explicit",
+    commandsEnabled: false,
+  };
+}
+
+function portableCapabilityDocument() {
+  return {
+    schema_version: "missioncore.observation-lab-replay-capability/v2",
+    kind: "portable-result-review",
+    viewer_profile: "portable-result",
+    timeline: "result-defined",
+    activation: "explicit",
+    commands_enabled: false,
+  };
+}
+
+function portableLab(portableResultId, definitionSha256) {
+  return lab({
+    labId: "M4.9",
+    resultId: portableResultId,
+    resultKind: "recorded-route-analysis",
+    sourceResultId: null,
+    configSha256: definitionSha256,
+    replayCapability: portableCapability(),
+    provenance: {
+      schema_version: "missioncore.observatory-portable-result-publication/v1",
+      authority: {},
+      calculation_profile: {},
+      calculation_profile_sha256: "b".repeat(64),
+      job: {},
+      source: { session_id: sourceSessionId },
+      run_definition: { definition_sha256: definitionSha256 },
+      result_package: {
+        manifest_sha256: "c".repeat(64),
+        artifact_manifest_id: "d".repeat(64),
+      },
+      replay_capability: portableCapabilityDocument(),
+      storage: {},
+      method: {},
+    },
+  });
+}
+
+test("Observatory admits only the exact typed canonical recorded run", () => {
+  const binding = observatoryRecordedRunBinding(resultId, lab());
+  assert.deepEqual(binding, {
+    kind: "canonical-recorded-rerun",
+    evidenceSessionId: resultId,
+    sourceSessionId,
+    resultId,
+    viewerProfile: "recorded-session",
+    timeline: "session_time",
+    activation: "explicit",
+  });
+  assert.equal(
+    observatoryRecordedRunBinding(resultId, lab({ replayCapability: null })),
+    null,
+  );
+  assert.throws(
+    () => observatoryRecordedRunBinding("different-session", lab()),
+    ObservatoryRecordedRunContractError,
+  );
+  assert.throws(
+    () => observatoryRecordedRunBinding(
+      resultId,
+      lab({ sourceSessionId: "RAVNOVES004TREE" }),
+    ),
+    ObservatoryRecordedRunContractError,
+  );
+  assert.throws(
+    () => observatoryRecordedRunBinding(
+      resultId,
+      lab({ configSha256: "a".repeat(64) }),
+    ),
+    ObservatoryRecordedRunContractError,
+  );
+  assert.throws(
+    () => observatoryRecordedRunBinding(
+      resultId,
+      lab({ sourceResultId: "legacy-result" }),
+    ),
+    ObservatoryRecordedRunContractError,
+  );
+  const invalidProvenance = canonicalProvenance();
+  invalidProvenance.method.components[0].identity_sha256 = "0".repeat(64);
+  assert.throws(
+    () => observatoryRecordedRunBinding(
+      resultId,
+      lab({ provenance: invalidProvenance }),
+    ),
+    ObservatoryRecordedRunContractError,
+  );
+});
+
+test("Observatory rechecks the selected source and sealed review before mounting replay", () => {
+  const binding = observatoryRecordedRunBinding(resultId, lab());
+  const review = { sessionId: sourceSessionId, frameCount: 6830 };
+  assert.equal(
+    admitObservatoryRecordedRunReview(
+      binding,
+      sourceSessionId,
+      { resultId, routeFullReview: review },
+    ),
+    review,
+  );
+  assert.throws(
+    () => admitObservatoryRecordedRunReview(
+      binding,
+      "another-session",
+      { resultId, routeFullReview: review },
+    ),
+    ObservatoryRecordedRunContractError,
+  );
+  assert.throws(
+    () => admitObservatoryRecordedRunReview(
+      binding,
+      sourceSessionId,
+      { resultId, routeFullReview: { ...review, sessionId: "another-session" } },
+    ),
+    ObservatoryRecordedRunContractError,
+  );
+});
+
+test("Observatory selects and strictly decodes a portable result viewer by capability", async () => {
+  const portableResultId = "portable-result-a";
+  const definitionSha256 = "e".repeat(64);
+  const binding = observatoryRecordedRunBinding(
+    portableResultId,
+    portableLab(portableResultId, definitionSha256),
+  );
+  assert.deepEqual(binding, {
+    kind: "portable-result-review",
+    evidenceSessionId: portableResultId,
+    sourceSessionId,
+    resultId: portableResultId,
+    viewerProfile: "portable-result",
+    timeline: "result-defined",
+    activation: "explicit",
+    definitionSha256,
+  });
+
+  let requestedUrl = null;
+  const review = await fetchObservatoryRecordedRunReview(binding, {
+    selectedSourceSessionId: sourceSessionId,
+    fetcher: async (url) => {
+      requestedUrl = url;
+      return {
+        ok: true,
+        status: 200,
+        json: async () => ({
+          schema_version: "missioncore.observatory-portable-result-view/v1",
+          result_id: portableResultId,
+          source_session_id: sourceSessionId,
+          result_kind: "recorded-route-analysis",
+          definition_sha256: definitionSha256,
+          viewer_capability: portableCapabilityDocument(),
+          calculation_profile: { name: "M4.9" },
+          artifact_manifest_id: "d".repeat(64),
+          artifacts: [{
+            role: "result-document",
+            media_type: "application/json",
+            sha256: "f".repeat(64),
+            byte_length: 42,
+          }],
+          result_document: { verdict: "reviewed" },
+        }),
+      };
+    },
+  });
+
+  assert.equal(
+    requestedUrl,
+    `/api/v1/observatory/portable-results/${portableResultId}`,
+  );
+  assert.equal(review.kind, "portable-result");
+  assert.deepEqual(review.resultDocument, { verdict: "reviewed" });
+  assert.deepEqual(review.artifacts, [{
+    role: "result-document",
+    mediaType: "application/json",
+    sha256: "f".repeat(64),
+    byteLength: 42,
+  }]);
+});
+
+test("Observatory run admission remains metadata-only until explicit UI activation", async () => {
+  const source = await readFile(
+    new URL("../src/core/observatory/recordedRun.ts", import.meta.url),
+    "utf8",
+  );
+  assert.match(source, /fetchVegetationShadowResultMetadata/);
+  assert.doesNotMatch(
+    source,
+    /fetchVegetationShadowResult\(|advanced-index|resolveObservationSessionReplay|resolveCanonicalLabReplay|RerunViewport|recording\.rrd/,
+  );
+});
@@ -0,0 +1,369 @@
+import assert from "node:assert/strict";
+import { readFile } from "node:fs/promises";
+import { after, before, test } from "node:test";
+
+import { createServer } from "vite";
+
+let server;
+let productModel;
+
+before(async () => {
+  server = await createServer({
+    appType: "custom",
+    logLevel: "silent",
+    server: { middlewareMode: true },
+  });
+  productModel = await server.ssrLoadModule("/src/productModel.ts");
+});
+
+after(async () => {
+  await server?.close();
+});
+
+async function read(relativePath) {
+  return readFile(new URL(`../src/${relativePath}`, import.meta.url), "utf8");
+}
+
+test("Observatory is the third independent Polygon workspace", () => {
+  assert.deepEqual(
+    productModel.workspacesForRoot("polygon").map(({ id }) => id),
+    ["lab-archive", "simulations", "observatory"],
+  );
+  assert.deepEqual(
+    productModel.workspaceById("observatory"),
+    {
+      id: "observatory",
+      root: "polygon",
+      label: "Обсерватория",
+      title: "AI inference",
+      eyebrow: "ТЕСТОВЫЙ КОНТУР / ОБСЕРВАТОРИЯ",
+      description: "Сессии и квалификация без доступа к управлению.",
+      icon: "eye",
+      kind: "observatory",
+      groups: [],
+    },
+  );
+  assert.equal(productModel.workspaceById("lab-archive").kind, "lab-archive");
+});
+
+test("Observatory mounts the one shared canonical replay only after explicit admission", async () => {
+  const [
+    app,
+    workspaceHub,
+    workspace,
+    hook,
+    recordedRun,
+    sharedReplay,
+    legacyReplayWrapper,
+    viewerProfiles,
+    styles,
+  ] = await Promise.all([
+    read("App.tsx"),
+    read("workspaces/Workspaces.tsx"),
+    read("workspaces/observatory/ObservatoryWorkspace.tsx"),
+    read("core/observatory/useObservatoryCatalog.ts"),
+    read("core/observatory/recordedRun.ts"),
+    read("components/laboratory/CanonicalResultRerunReplay.tsx"),
+    read("workspaces/laboratory/CanonicalVegetationRerunReplay.tsx"),
+    read("core/observation/viewerProfile.ts"),
+    read("styles/observatory.css"),
+  ]);
+
+  assert.match(app, /activeDefinition\.kind === "observatory"[\s\S]*Только наблюдение/);
+  assert.doesNotMatch(app, /\["recordings", "lab-archive", "observatory"\]/);
+  assert.match(workspaceHub, /case "observatory":[\s\S]*<ObservatoryWorkspace/);
+  assert.match(workspace, /useObservatoryCatalog/);
+  assert.doesNotMatch(workspace, /observatory-lead/);
+  assert.doesNotMatch(workspace, /Расчёт записанных маршрутов выбранными профилями/);
+  assert.match(workspace, /Связанных результатов нет/);
+  assert.match(workspace, /не является выводом о качестве/);
+  assert.match(workspace, /function compositionProducedEvidence\(/);
+  assert.match(workspace, /publishedAt >= compositionCreatedAt/);
+  assert.match(workspace, /const presentedCompositionRuns = aiJobsController\.runs/);
+  assert.match(workspace, /presentedEvidence = \(selectedSession\?\.evidence \?\? \[\]\)\.filter/);
+  assert.match(workspace, /!presentedCompositionRuns\.some\([\s\S]*compositionProducedEvidence\(run, evidence\)/);
+  assert.doesNotMatch(workspace, /MAX_PRESENTED_EVIDENCE|\.evidence\.slice\(/);
+  assert.match(workspace, /Полнота исторических/);
+  assert.match(workspace, /вне текущего загруженного среза/);
+  assert.match(workspace, /observatory-notice__copy/);
+  assert.match(workspace, /observatory-evidence-card/);
+  assert.match(workspace, /observatory-session-stack/);
+  assert.match(workspace, /observatory-session-summary__facts/);
+  assert.match(workspace, /observatory-evidence-card__copy/);
+  assert.match(
+    workspace,
+    /function evidenceConfigurationLabel[\s\S]*calculationProfile\?\.displayName[\s\S]*return profileName \?\? evidence\.label/,
+  );
+  assert.match(
+    workspace,
+    /<strong>\{evidenceConfigurationLabel\([\s\S]*evidence,[\s\S]*aiJobsController\.moduleLabelsBySetup,[\s\S]*aiJobsController\.jobs,[\s\S]*\)\}<\/strong>/,
+  );
+  assert.doesNotMatch(workspace, /evidenceConfigurationLabel\([^)]*,\s*selectedSession\.source\.label/);
+  assert.match(
+    workspace,
+    /evidence\.recordedRun \? \([\s\S]*name="trash"[\s\S]*name="edit"[\s\S]*Открыть визуальный разбор:[\s\S]*name="eye"/,
+  );
+  assert.doesNotMatch(workspace, /observatory-evidence-card[^>]*tone="soft"/);
+  assert.match(workspace, /Открыть визуальный разбор/);
+  assert.match(workspace, /replay\.kind === "ready"[\s\S]*<CanonicalVegetationRerunReplay/);
+  assert.match(workspace, /<PortableResultReplay review=\{replay\.review\}/);
+  const portable = await read("components/laboratory/PortableResultReplay.tsx");
+  assert.doesNotMatch(portable, /Документ результата|JSON.stringify|StatusBadge/);
+  assert.match(portable, /missioncore.recorded-eomt-ddrnet-review\/v2/);
+  assert.match(portable, /sourceKind: "portable-semantic"/);
+  assert.match(portable, /sourceKind: "portable-objects"/);
+  assert.match(portable, /costmap=\{tgs\} semantics=\{semantics\}/);
+  assert.match(portable, /detections=\{objects\}/);
+  assert.match(portable, /<CanonicalResultRerunReplay/);
+  assert.doesNotMatch(workspace, /UNIVERSAL VIEWER|content-addressed artifacts/);
+  assert.doesNotMatch(workspace, /evidence\.lab\.resultKind|без запуска тяжёлого/);
+  assert.match(workspace, /Проверяем точную связь результата/);
+  assert.match(workspace, /role="alert"/);
+  assert.match(workspace, /Повторить/);
+  assert.match(workspace, /Закрыть разбор/);
+  assert.match(
+    workspace,
+    /const returnToOverview[\s\S]*closeReplay\(\);[\s\S]*scrollIntoView\(\{ block: "start" \}\)/,
+  );
+  assert.match(
+    workspace,
+    /<h3>\{replayEvidence && selectedSession[\s\S]*evidenceConfigurationLabel\([\s\S]*replayEvidence,[\s\S]*aiJobsController\.moduleLabelsBySetup,[\s\S]*aiJobsController\.jobs,[\s\S]*\)[\s\S]*replay\.binding\.resultId\}<\/h3>/,
+  );
+  assert.doesNotMatch(workspace, /RAVNOVES004TREE · полный маршрут восприятия/);
+  assert.match(workspace, /const selectSession[\s\S]*closeReplay\(\);[\s\S]*setSelectedSessionId/);
+  assert.match(workspace, /data-observatory-authority="observation-only"/);
+  assert.doesNotMatch(workspace, /Нарушена связь|compactIdentity/);
+  assert.doesNotMatch(
+    `${workspace}\n${hook}`,
+    /RerunViewport|ObservationSessionSelect|resolveObservationSessionReplay|resolveCanonicalLabReplay|deleteObservationSession|setInterval|setTimeout|useObservationSessions|useAdvancedLaboratoryCatalog|advanced-index|prefetch|preload/,
+  );
+  assert.equal(sharedReplay.match(/<RerunViewport\b/g)?.length, 1);
+  assert.match(sharedReplay, /recordedSessionRerunProfile/);
+  assert.match(sharedReplay, /timelineStartSeconds/);
+  assert.doesNotMatch(sharedReplay, /live-acquisition|lab-recorded-evidence/);
+  assert.match(
+    legacyReplayWrapper,
+    /export \{ CanonicalVegetationRerunReplay \} from "\.\.\/\.\.\/components\/laboratory\/CanonicalVegetationRerunReplay"/,
+  );
+  assert.match(recordedRun, /fetchVegetationShadowResultMetadata/);
+  assert.doesNotMatch(recordedRun, /advanced-index|recording\.rrd|canonical-replay\.rrd/);
+  assert.doesNotMatch(workspace, /workspaces\/laboratory|LaboratoryRecordedClipPlayer|SimulationViewport/);
+  assert.match(viewerProfiles, /kind: "live-acquisition"/);
+  assert.match(viewerProfiles, /kind: "recorded-session"/);
+  assert.match(viewerProfiles, /kind: "lab-recorded-evidence"/);
+  assert.match(
+    styles,
+    /@container observatory-workspace \(max-width: 920px\)[\s\S]*\.observatory-catalog-bar__controls \.nodedc-select-anchor \{[\s\S]*flex: 0 0 auto;/,
+  );
+  assert.match(
+    styles,
+    /\.observatory-session-summary \{[\s\S]*grid-template-columns:[\s\S]*\.observatory-evidence-card \{[\s\S]*background: var\(--nodedc-glass-control-bg\);/,
+  );
+  assert.match(
+    styles,
+    /\.observatory-session-stack \{[\s\S]*container-name: observatory-session;[\s\S]*container-type: inline-size;/,
+  );
+  assert.match(
+    styles,
+    /\.observatory-workspace \{[\s\S]*grid-auto-rows: max-content;[\s\S]*align-content: start;/,
+  );
+  assert.match(
+    styles,
+    /\.observatory-session-summary__facts dd \{[\s\S]*font-size: var\(--nodedc-font-size-sm\);/,
+  );
+  assert.match(
+    styles,
+    /\.observatory-catalog-bar h3,[\s\S]*\.observatory-session-summary h3,[\s\S]*\.observatory-evidence h3 \{[\s\S]*font-size: var\(--nodedc-font-size-lg\);/,
+  );
+  assert.match(
+    styles,
+    /@container observatory-session \(max-width: 46rem\) \{[\s\S]*\.observatory-session-summary \{[\s\S]*grid-template-columns: minmax\(0, 1fr\);/,
+  );
+  assert.match(
+    styles,
+    /@container observatory-session \(max-width: 38rem\) \{[\s\S]*\.observatory-session-summary__facts \{[\s\S]*grid-template-columns: minmax\(0, 1fr\);/,
+  );
+  assert.doesNotMatch(styles, /\.observatory-evidence-card[\s\S]*background:\s*(?:#0{3,6}|black|rgb\(0[ ,])/i);
+  assert.doesNotMatch(styles, /nodedc-glass-surface|nodedc-status-badge/);
+});
+
+test("Observatory rename and delete use admitted projection mutations and canonical windows", async () => {
+  const [workspace, hook] = await Promise.all([
+    read("workspaces/observatory/ObservatoryWorkspace.tsx"),
+    read("core/observatory/useObservatoryCatalog.ts"),
+  ]);
+
+  assert.match(
+    workspace,
+    /deleteObservatoryLabProjection,[\s\S]*renameObservatoryLabProjection,[\s\S]*from "\.\.\/\.\.\/core\/observatory\/catalogMutations"/,
+  );
+  assert.match(workspace, /<Window[\s\S]*title="Переименовать лабораторный результат"/);
+  assert.match(workspace, /<TextField[\s\S]*label="Название"[\s\S]*maxLength=\{160\}/);
+  assert.match(workspace, /<WindowFooterActions>[\s\S]*Сохранить/);
+  assert.match(workspace, /<ConfirmationModal[\s\S]*title="Удалить результат из Обсерватории\?"/);
+  assert.match(workspace, /Исходная сессия, запечатанный лабораторный результат и файлы доказательств/);
+  assert.match(workspace, /renameAICompositionRunProjection/);
+  assert.match(workspace, /deleteAICompositionRunProjection/);
+  assert.match(workspace, /openCompositionRename\(run\)/);
+  assert.match(workspace, /openCompositionDelete\(run\)/);
+  assert.match(
+    workspace,
+    /const result = await renameObservatoryLabProjection\([\s\S]*controller\.applyEvidenceRename\(result\.sessionId, result\.displayName\);[\s\S]*setRenameTarget\(null\);[\s\S]*void controller\.refresh\(\);/,
+  );
+  assert.match(
+    workspace,
+    /catch \(error\) \{[\s\S]*const reconciled = await controller\.refresh\(\);[\s\S]*evidence\?\.label === reconciliation\.displayName[\s\S]*setRenameTarget\(null\);/,
+  );
+
+  const deleteFlowStart = workspace.indexOf("const confirmDelete = useCallback");
+  const deleteFlowEnd = workspace.indexOf("}, [aiJobsController, closeReplay", deleteFlowStart);
+  assert.ok(deleteFlowStart >= 0 && deleteFlowEnd > deleteFlowStart);
+  const wholeDeleteFlow = workspace.slice(deleteFlowStart, deleteFlowEnd);
+  const evidenceFlowStart = wholeDeleteFlow.indexOf("if (!deleteTarget?.recordedRun");
+  assert.ok(evidenceFlowStart >= 0);
+  const deleteFlow = wholeDeleteFlow.slice(evidenceFlowStart);
+  const teardown = deleteFlow.indexOf("closeReplay();");
+  const remove = deleteFlow.indexOf("await deleteObservatoryLabProjection");
+  const tombstone = deleteFlow.indexOf("controller.applyEvidenceDeletion");
+  const refresh = deleteFlow.indexOf("void controller.refresh();");
+  assert.ok(teardown >= 0 && teardown < remove, "active replay must unmount before projection delete");
+  assert.ok(remove < tombstone, "local tombstone must follow the exact empty 204");
+  assert.ok(tombstone < refresh, "reconciliation refresh must follow the local tombstone");
+  assert.match(deleteFlow, /flushSync\(\(\) => \{[\s\S]*closeReplay\(\);[\s\S]*\}\);/);
+  assert.match(
+    deleteFlow,
+    /catch \(error\) \{[\s\S]*const reconciled = await controller\.refresh\(\);[\s\S]*observatoryCatalogConfirmsEvidenceDeletion\([\s\S]*setDeleteTarget\(null\);/,
+  );
+  assert.match(workspace, /mutationError[\s\S]*role="alert"/);
+  assert.match(hook, /activeRequestRef\.current\?\.controller\.abort\(\)/);
+  assert.match(hook, /requestSequenceRef\.current !== id/);
+  assert.match(hook, /const requestMutationRevision = mutationRevisionRef\.current/);
+  assert.match(hook, /reconcileObservatoryCatalogMutationOverlay\(/);
+  assert.match(hook, /applyObservatoryCatalogMutationOverlay\(/);
+});
+
+test("Observatory configures independent AI modules and shows queued evidence progress", async () => {
+  const [workspace, styles, configWindow, jobsHook, sharedReplay] = await Promise.all([
+    read("workspaces/observatory/ObservatoryWorkspace.tsx"),
+    read("styles/observatory.css"),
+    read("components/observatory/AIConfigurationWindow.tsx"),
+    read("core/observatory/useAICompositionJobs.ts"),
+    read("components/laboratory/CanonicalResultRerunReplay.tsx"),
+  ]);
+
+  assert.match(workspace, /className="observatory-catalog-bar" padding="sm"/);
+  assert.match(workspace, /label="Выбрать сохранённую сессию"/);
+  assert.match(workspace, />\s*Сконфигурировать AI-слой\s*<\/Button>/);
+  assert.doesNotMatch(workspace, /label="Выбрать сетап лаборатории"/);
+  assert.doesNotMatch(workspace, />\s*Обновить\s*<\/Button>/);
+  assert.doesNotMatch(workspace, /Выбор меняет только читаемую карточку/);
+  assert.doesNotMatch(workspace, /ObservatorySetupDetail|observatory-setup-detail/);
+  assert.doesNotMatch(styles, /observatory-setup-detail|observatory-setup-results/);
+  assert.doesNotMatch(workspace, /useObservatoryRecordedJobs|useObservatoryLaboratorySetups/);
+  assert.match(configWindow, /title="Сконфигурировать AI-слой"/);
+  assert.match(configWindow, /label: "Сегментация"/);
+  assert.match(configWindow, /Зависимые блоки подключаются явно/);
+  assert.match(configWindow, /label: "Облако точек \/ TGS"/);
+  assert.match(configWindow, /label: "Дистанция"/);
+  assert.match(configWindow, /Дистанция использует рамки детектора и синхронное облако точек/);
+  assert.match(configWindow, /TGS обрабатывает LiDAR независимо от сегментации и детектора/);
+  assert.match(configWindow, /providers\.length === 1/);
+  assert.match(
+    configWindow,
+    /<WindowFooterActions>[\s\S]*"Отправляем на Worker…" : "Рассчитать"/,
+  );
+  assert.match(configWindow, /className=\{state === "saving" \? "observatory-ai-config__calculate--saving"/);
+  assert.match(configWindow, /aria-busy=\{state === "saving"\}/);
+  assert.match(styles, /@keyframes observatory-ai-calculate-pulse/);
+  assert.match(
+    styles,
+    /\.observatory-ai-config__calculate--saving:disabled \{[\s\S]*animation: observatory-ai-calculate-pulse 1\.8s ease-in-out infinite;[\s\S]*opacity: 1;/,
+  );
+  assert.match(workspace, /useAICompositionJobs\(selectedSessionId\)/);
+  assert.match(workspace, /observatory-evidence-card--progress/);
+  assert.match(workspace, /const active = run\.state === "running"/);
+  assert.match(workspace, /\{active \? \([\s\S]*observatory-evidence-card__progress/);
+  assert.match(workspace, /run\.state === "ready" \? <Icon name="clipboard"/);
+  assert.match(workspace, /function aiJobStage\(/);
+  assert.match(workspace, /return "Инициализация"/);
+  assert.match(workspace, /return "Передача на сервер"/);
+  assert.match(workspace, /return "Просчёт"/);
+  assert.match(workspace, /Собираем видеоряд для модели/);
+  assert.match(workspace, /измеренная скорость Worker 006: 17–18 FPS/);
+  assert.doesNotMatch(workspace, /phaseElapsedSeconds \/ progress\.completed/);
+  assert.match(workspace, /AI_PROGRESS_PHASE_RANGES/);
+  assert.match(workspace, /"source-preparation": \[5, 25\]/);
+  assert.match(workspace, /computing: \[25, 90\]/);
+  assert.match(workspace, /Подготавливаем камеру и LiDAR/);
+  assert.match(workspace, /прошло.*formatDuration\(progress\.elapsedSeconds\)/s);
+  assert.match(workspace, /Не удалось запустить модель/);
+  assert.doesNotMatch(workspace, /job\.terminalMessage|job\.publication\.error/);
+  assert.doesNotMatch(workspace, /function aiModuleLabel\(/);
+  assert.match(workspace, /aiJobsController\.moduleLabelsBySetup\[job\.setupId\] \?\? job\.setupId/);
+  assert.match(jobsHook, /fetchAIModuleCatalog\(request\.signal\)/);
+  assert.match(jobsHook, /AI_MODULE_SETUP_IDS\[module\.moduleId\]/);
+  assert.match(jobsHook, /run\.presentation\.modules\.flatMap/);
+  assert.match(jobsHook, /Object\.fromEntries\(\[\.\.\.catalogLabels, \.\.\.projectedLabels\]\)/);
+  assert.match(workspace, /<strong>\{moduleLabel\}<\/strong>/);
+  assert.match(workspace, /<strong>\{run\.displayName \?\? run\.presentation\.configurationLabel\}<\/strong>/);
+  assert.doesNotMatch(workspace, /<strong>\{selectedSession\.source\.label\} ·/);
+  assert.match(workspace, /type EvidenceSortDirection = "newest" \| "oldest"/);
+  assert.match(workspace, /const presentedRows = useMemo<readonly ObservatoryEvidenceRow\[]>/);
+  assert.match(workspace, /direction \* \(Date\.parse\(left\.timestamp\) - Date\.parse\(right\.timestamp\)\)/);
+  assert.match(workspace, /className="observatory-evidence__sort"/);
+  assert.match(workspace, /data-direction=\{evidenceSortDirection\}/);
+  assert.match(workspace, /formatTimestamp\(row\.timestamp\)/);
+  assert.match(styles, /\.observatory-evidence-card\s*\{[\s\S]*grid-template-columns:\s*auto minmax\(0, 1fr\) auto auto/);
+  assert.match(styles, /\.observatory-evidence__sort\s*\{[\s\S]*border:\s*0;[\s\S]*outline:\s*0/);
+  assert.match(
+    styles,
+    /\.observatory-evidence-card__copy strong \{[\s\S]*font-size: var\(--nodedc-font-size-sm\);/,
+  );
+  assert.match(sharedReplay, /LAB_SCENE_SETTINGS_STORAGE_PREFIX/);
+  assert.match(sharedReplay, /window\.localStorage\.getItem/);
+  assert.match(sharedReplay, /window\.localStorage\.setItem/);
+  assert.match(sharedReplay, /unifiedCameraShare: blueprintSplitPrimarySize \/ 100/);
+  assert.match(sharedReplay, /setSettingsOpen\(false\);[\s\S]*void saveLabViewProfile/);
+  assert.match(
+    sharedReplay,
+    /showPoints: spatialMode !== null && \(showSourcePoints \|\| showLocalSlam\)/,
+  );
+  assert.match(sharedReplay, /showTrajectory: spatialMode !== null && showLocalSlam/);
+  assert.match(
+    sharedReplay,
+    /accumulationSeconds: showLocalSlam \? sceneDraft\.accumulationSeconds : 0/,
+  );
+  assert.match(workspace, /<AICompositionReplay run=\{replay\.run\} \/>/);
+  assert.match(workspace, /function presentAIJob\(job: ObservatoryRecordedJob\)/);
+  assert.match(workspace, /if \(job\.state === "failed"\) return true/);
+  assert.match(workspace, /return job\.state !== "succeeded"/);
+  assert.match(workspace, /function presentLatestAIJobs/);
+  assert.match(workspace, /seenSetups\.has\(job\.setupId\)/);
+  assert.match(configWindow, /fetchAICompositionJobs\(sourceSessionId, request\.signal\)/);
+  assert.match(
+    configWindow,
+    /if \(job\.state === "failed" \|\| job\.publication\.state === "failed"\) continue;/,
+  );
+  assert.match(configWindow, /Текущая конфигурация уже рассчитана/);
+  assert.match(configWindow, /configurationAlreadyExists/);
+  assert.match(configWindow, /Готовый результат будет использован без повторного расчёта/);
+  assert.doesNotMatch(configWindow, /disabled: existingByModule\.has\(module\.moduleId\)/);
+  assert.doesNotMatch(configWindow, /selections\.some\(\(\{ module \}\) => existingByModule/);
+  assert.match(jobsHook, /const OPEN = new Set/);
+  assert.match(jobsHook, /1_500/);
+  assert.match(jobsHook, /globalThis\.setTimeout/);
+  assert.doesNotMatch(jobsHook, /setInterval/);
+  assert.match(workspace, /job\.publication\.state === "published"/);
+  assert.match(workspace, /onCalculated=\{\(\) => aiJobsController\.refresh\(\)\}/);
+  assert.match(
+    styles,
+    /\.observatory-catalog-bar__controls \{[\s\S]*min-width: 0;[\s\S]*flex: 1 1 auto;[\s\S]*flex-wrap: nowrap;[\s\S]*justify-content: flex-end;/,
+  );
+  assert.match(styles, /\.observatory-evidence-card__progress \{/);
+  assert.match(styles, /\.observatory-ai-module-group > header \{/);
+  assert.match(styles, /\.observatory-ai-module-group \{[\s\S]*border: 0;[\s\S]*outline: 0;/);
+  assert.match(
+    styles,
+    /@container observatory-workspace \(max-width: 920px\)[\s\S]*\.observatory-catalog-bar,[\s\S]*\.observatory-catalog-bar__controls,[\s\S]*flex-direction: column;/,
+  );
+});
@@ -324,7 +324,7 @@ test("Polygon exposes one dataset surface and keeps legacy links compatible", ()
  assert.equal(workspaceById("datasets").kind, "datasets");
  assert.deepEqual(
    workspacesForRoot("polygon").map(({ id }) => id),
-    ["lab-archive", "simulations"],
+    ["lab-archive", "simulations", "observatory"],
  );
  assert.equal(
    workspacesForRoot("system").some(({ id }) => id === "polygon-run"),
@@ -27,6 +27,19 @@ test("top navigation has no Center and Park owns contour health first", () => {
  );
  assert.equal(productModel.workspacesForRoot("fleet")[0]?.id, "contour-health");
  assert.equal(productModel.workspaceById("contour-health")?.root, "fleet");
+  assert.deepEqual(
+    productModel.workspacesForRoot("polygon").map(({ id }) => id),
+    ["lab-archive", "simulations", "observatory"],
+  );
+  assert.equal(productModel.workspaceById("lab-archive")?.kind, "lab-archive");
+  assert.deepEqual(
+    {
+      root: productModel.workspaceById("observatory")?.root,
+      kind: productModel.workspaceById("observatory")?.kind,
+      icon: productModel.workspaceById("observatory")?.icon,
+    },
+    { root: "polygon", kind: "observatory", icon: "eye" },
+  );
 });

 test("every laboratory result uses the shared evidence template", async () => {
@@ -0,0 +1,101 @@
+import assert from "node:assert/strict";
+import { after, before, test } from "node:test";
+import { createServer } from "vite";
+
+let server, createRecordedRerunCameraJournal, initialEye;
+before(async () => {
+  server = await createServer({ appType: "custom", logLevel: "silent",
+    server: { middlewareMode: true } });
+  const module = await server.ssrLoadModule(
+    "/src/components/rerun/recordedRerunCameraJournal.ts");
+  createRecordedRerunCameraJournal = module.createRecordedRerunCameraJournal;
+  initialEye = module.RECORDED_RERUN_ORBITAL_EYE;
+});
+after(async () => { await server?.close(); });
+
+class FakeEvent {
+  constructor(type, init = {}) { this.type = type; Object.assign(this, init); }
+}
+
+class FakeTarget {
+  listeners = new Map();
+  emitted = [];
+  addEventListener(type, listener) {
+    const listeners = this.listeners.get(type) ?? [];
+    listeners.push(listener); this.listeners.set(type, listeners);
+  }
+  removeEventListener(type, listener) {
+    this.listeners.set(type, (this.listeners.get(type) ?? []).filter(item => item !== listener));
+  }
+  dispatchEvent(event) {
+    this.emitted.push(event);
+    for (const listener of this.listeners.get(event.type) ?? []) listener(event);
+    return true;
+  }
+}
+
+const radius = (eye) => Math.hypot(
+  eye.position[0] - eye.lookTarget[0],
+  eye.position[1] - eye.lookTarget[1],
+  eye.position[2] - eye.lookTarget[2],
+);
+
+test("recorded orbital eye tracks only 3D viewport navigation", () => {
+  const scope = new FakeTarget();
+  const timers = [];
+  Object.assign(scope, {
+    WheelEvent: FakeEvent,
+    requestAnimationFrame(callback) { callback(); return 1; },
+    setTimeout(callback) { timers.push(callback); return timers.length; },
+  });
+  const canvas = new FakeTarget();
+  Object.assign(canvas, {
+    clientHeight: 200,
+    isConnected: true,
+    getBoundingClientRect: () => ({
+      left: 100, right: 500, top: 50, bottom: 250, width: 400, height: 200,
+    }),
+  });
+  const journal = createRecordedRerunCameraJournal(canvas, scope);
+  journal.configure(initialEye, 0.46);
+  const pointer = (type, x, y, buttons) => new FakeEvent(type, {
+    clientX: x, clientY: y, button: 0, buttons, pointerId: 7, pointerType: "mouse",
+    altKey: false, ctrlKey: false, metaKey: false, shiftKey: false,
+  });
+
+  canvas.dispatchEvent(pointer("pointerdown", 200, 100, 1));
+  scope.dispatchEvent(pointer("pointermove", 240, 120, 1));
+  scope.dispatchEvent(pointer("pointerup", 240, 120, 0));
+  assert.deepEqual(journal.current(), initialEye);
+
+  canvas.dispatchEvent(pointer("pointerdown", 380, 100, 1));
+  scope.dispatchEvent(pointer("pointermove", 420, 120, 1));
+  scope.dispatchEvent(pointer("pointerup", 420, 120, 0));
+  const rotated = journal.current();
+  assert.notDeepEqual(rotated.position, initialEye.position);
+  assert.ok(Math.abs(radius(rotated) - radius(initialEye)) < 1e-9);
+
+  journal.setMaxOrbitalRadius(40);
+  scope.dispatchEvent(new FakeEvent("wheel", {
+    clientX: 380, clientY: 130, deltaX: 0, deltaY: 2_000, deltaMode: 0,
+    altKey: false, ctrlKey: false, metaKey: false, shiftKey: false,
+  }));
+  assert.ok(Math.abs(radius(journal.current()) - 40) < 1e-9);
+
+  journal.configure(rotated, 0.46);
+
+  scope.dispatchEvent(new FakeEvent("wheel", {
+    clientX: 0, clientY: 0, deltaX: 0, deltaY: -20, deltaMode: 0,
+    altKey: false, ctrlKey: false, metaKey: false, shiftKey: false,
+  }));
+  const zoomed = journal.current();
+  assert.ok(Math.abs(radius(zoomed) - radius(rotated) * Math.exp(-20 / 200)) < 1e-9);
+
+  const snapshot = journal.current();
+  journal.setSpatialViewportStart(0.8);
+  scope.dispatchEvent(new FakeEvent("wheel", {
+    clientX: 380, clientY: 130, deltaX: 0, deltaY: -20, deltaMode: 0,
+  }));
+  assert.deepEqual(journal.current(), snapshot);
+  journal.dispose();
+});
@@ -0,0 +1,261 @@
+import assert from "node:assert/strict";
+import { after, before, test } from "node:test";
+import { createServer } from "vite";
+
+let server, createIsolatedRerunHost, keepRecordedBlueprintSession, createRecordedRerunFacade, createRecordedRerunOwner, relayIsolatedRerunInput;
+before(async () => {
+  server = await createServer({ appType: "custom", logLevel: "silent",
+    server: { middlewareMode: true } });
+  ({ createIsolatedRerunHost } = await server.ssrLoadModule(
+    "/src/components/rerun/isolatedRerunHost.ts"));
+  ({ keepRecordedBlueprintSession } = await server.ssrLoadModule(
+    "/src/core/observation/recordedBlueprintLifecycle.ts"));
+  ({ createRecordedRerunFacade } = await server.ssrLoadModule(
+    "/src/components/rerun/recordedRerunFacade.ts"));
+  ({ createRecordedRerunOwner } = await server.ssrLoadModule(
+    "/src/components/rerun/recordedRerunOwner.ts"));
+  ({ relayIsolatedRerunInput } = await server.ssrLoadModule(
+    "/src/components/rerun/isolatedRerunInput.ts"));
+});
+after(async () => { await server?.close(); });
+
+function fixture(t, { stopFails = false } = {}) {
+  const timers = new Map();
+  let timerId = 0, creates = 0, stops = 0, removals = 0;
+  t.mock.method(globalThis, "setTimeout", (fn) => {
+    timers.set(++timerId, fn); return timerId;
+  });
+  t.mock.method(globalThis, "clearTimeout", (id) => timers.delete(id));
+  const listeners = new Map();
+  const viewer = { stop() { stops++; if (stopFails) throw new Error("partial start"); } };
+  const mount = {};
+  const frame = {
+    contentWindow: {
+      missionCoreRerun: createRecordedRerunOwner(() => { creates++; return viewer; }, mount),
+      addEventListener: (name, fn) => listeners.set(name, fn),
+      removeEventListener: (name) => listeners.delete(name),
+    },
+    remove() { removals++; },
+  };
+  const host = { dataset: {}, ownerDocument: { createElement(name) {
+    assert.equal(name, "iframe"); return frame;
+  } }, append(child) { assert.equal(child, frame); } };
+  return { host, frame, viewer, mount, timers, listeners,
+    counts: () => ({ creates, stops, removals }) };
+}
+
+function bridge(native, mount = {}) {
+  const child = createRecordedRerunOwner(() => native, mount);
+  const parent = createRecordedRerunFacade((request, bytes) => {
+    assert.equal(typeof request, "string");
+    const result = child.invoke(request, bytes);
+    assert.equal(typeof result, "string");
+    return result;
+  });
+  child.connect(message => {
+    assert.equal(typeof message, "string");
+    parent.notify(message);
+  });
+  return parent;
+}
+
+test("recorded realm terminates on close even if upstream stop throws", async (t) => {
+  const f = fixture(t, { stopFails: true });
+  const scope = createIsolatedRerunHost(f.host);
+  assert.equal(f.frame.src, "/rerun-runtime.html");
+  f.frame.onload();
+  const ready = await scope.ready;
+  assert.notEqual(ready.viewer, f.viewer);
+  assert.equal(ready.mount, f.host);
+  assert.equal(f.timers.size, 0);
+  assert.equal(f.listeners.size, 1);
+  scope.dispose(); scope.dispose();
+  assert.deepEqual(f.counts(), { creates: 1, stops: 1, removals: 1 });
+  assert.equal(f.listeners.size, 0);
+  assert.equal(f.frame.onload, null);
+  assert.equal(ready.viewer.ready, false);
+});
+
+test("native frame input relays Escape and leaves pointer ownership inside Rerun", () => {
+  const listeners = new Map(), events = [];
+  class ParentEvent { constructor(type, init) { this.type = type; Object.assign(this, init); } }
+  const host = { dataset: {}, ownerDocument: { defaultView: {
+    KeyboardEvent: ParentEvent, PointerEvent: ParentEvent,
+  } }, dispatchEvent: event => events.push(event) };
+  const child = {
+    addEventListener: (name, fn) => listeners.set(name, fn),
+    removeEventListener: name => listeners.delete(name),
+  };
+  const release = relayIsolatedRerunInput(host, child, null);
+  assert.equal(listeners.has("pointerdown"), false);
+  listeners.get("keydown")({ key: "Escape", defaultPrevented: false });
+  assert.equal(events[0].key, "Escape");
+  release(); release();
+  assert.equal(listeners.size, 0); assert.equal(events.length, 1);
+});
+
+test("disposed facade, channel and unsubscribe reject native use and copy event values", async () => {
+  let eventCallback, unsubscribed = 0, sends = 0, starts = 0;
+  const range = { min: 1, max: 2 }, mount = {};
+  const native = {
+    ready: true, stop() {},
+    async start(source, parent) { assert.equal(parent, mount); starts++; },
+    get_time_range: () => range,
+    on(event, callback) { eventCallback = callback; return () => { unsubscribed++; }; },
+    open_channel: () => ({ ready: true, send_rrd() { sends++; }, close() {} }),
+  };
+  const { facade, dispose } = bridge(native, mount);
+  await facade.start(null, {}, null);
+  assert.equal(starts, 1);
+  let event;
+  const unsubscribe = facade.on("time_update", value => { event = value; });
+  eventCallback(range);
+  assert.deepEqual(event, range); assert.notEqual(event, range);
+  assert.notEqual(facade.get_time_range(), range);
+  const channel = facade.open_channel();
+  channel.send_rrd(new Uint8Array());
+  dispose(); dispose(); unsubscribe();
+  assert.equal(unsubscribed, 1);
+  assert.equal(channel.ready, false);
+  channel.send_rrd(new Uint8Array());
+  eventCallback({ min: 3, max: 4 });
+  assert.deepEqual(event, range);
+  assert.equal(sends, 1);
+  await assert.rejects(facade.start(null, {}, null), /disposed/);
+});
+
+test("close before frame load cancels startup and cannot reopen", async (t) => {
+  const f = fixture(t);
+  const scope = createIsolatedRerunHost(f.host);
+  const lateLoad = f.frame.onload;
+  const rejected = assert.rejects(scope.ready, /disposed/);
+  scope.dispose(); lateLoad();
+  await rejected;
+  assert.deepEqual(f.counts(), { creates: 0, stops: 0, removals: 1 });
+  assert.equal(f.timers.size, 0);
+});
+
+test("closing during SDK startup also releases a late successful start", async () => {
+  let finish, stops = 0;
+  const owner = bridge({
+    start: () => new Promise(resolve => { finish = resolve; }),
+    stop() { stops++; },
+  }, {});
+  const pending = owner.facade.start(null, {}, null);
+  const rejected = assert.rejects(pending, /disposed/);
+  owner.dispose();
+  assert.equal(stops, 1);
+  finish();
+  await rejected;
+  await Promise.resolve();
+  assert.equal(stops, 2);
+  assert.equal(owner.facade.ready, false);
+});
+
+test("late failed startup cannot revive a disposed parent and still finishes cleanup", async () => {
+  let fail, stops = 0;
+  const owner = bridge({
+    start: () => new Promise((_resolve, reject) => { fail = reject; }),
+    stop() { stops++; if (stops > 1) throw new Error("already gone"); },
+  }, {});
+  const pending = owner.facade.start(null, {}, null);
+  const rejected = assert.rejects(pending, /disposed/);
+  owner.dispose();
+  fail(new Error("startup failed"));
+  await rejected;
+  await Promise.resolve();
+  assert.equal(stops, 2);
+  assert.equal(owner.facade.ready, false);
+});
+
+test("primitive bridge preserves all public clock/control arguments and errors", async () => {
+  const calls = [];
+  const methods = {
+    open: [["one.rrd", "two.rrd"]], close: ["one.rrd"],
+    override_panel_state: ["time", "hidden"],
+    get_active_recording_id: [], get_active_timeline: ["recording"],
+    get_current_time: ["recording", "session_time"], get_playing: ["recording"],
+    get_time_range: ["recording", "session_time"],
+    set_active_timeline: ["recording", "session_time"],
+    set_current_time: ["recording", "session_time", 123.456],
+    set_playing: ["recording", false],
+  };
+  const native = { stop() {}, start: async () => { throw new Error("native startup failure"); } };
+  for (const name of Object.keys(methods)) native[name] = (...args) => { calls.push([name, args]); return 1; };
+  const { facade, dispose } = bridge(native);
+  for (const [name, args] of Object.entries(methods)) facade[name](...args);
+  assert.deepEqual(calls, Object.entries(methods));
+  await assert.rejects(facade.start(null, {}, null), /native startup failure/);
+  dispose();
+});
+
+test("sync native failures become parent-owned errors and optional channel names stay undefined", () => {
+  const nativeError = new Error("native failure");
+  let channelName = "unobserved";
+  const { facade, dispose } = bridge({
+    stop() {},
+    open() { throw nativeError; },
+    open_channel(name) { channelName = name; return { close() {} }; },
+  });
+  assert.throws(() => facade.open("rrd"), error => error !== nativeError && /native failure/.test(error.message));
+  facade.open_channel();
+  assert.equal(channelName, undefined);
+  dispose();
+});
+
+test("dispose closes every auxiliary channel even if one channel fails", () => {
+  const closed = [];
+  let stops = 0;
+  const owner = bridge({
+    stop() { stops++; },
+    open_channel: name => ({ close() {
+      closed.push(name);
+      if (name === "first") throw new Error("already gone");
+    } }),
+  }, {});
+  const first = owner.facade.open_channel("first");
+  const second = owner.facade.open_channel("second");
+  owner.dispose(); owner.dispose(); first.close(); second.close();
+  assert.deepEqual(closed, ["first", "second"]);
+  assert.equal(stops, 1);
+});
+
+test("host load timeout removes the frame and clears its timer", async (t) => {
+  const f = fixture(t);
+  const scope = createIsolatedRerunHost(f.host);
+  const rejected = assert.rejects(scope.ready, /timed out/);
+  [...f.timers.values()][0]();
+  await rejected;
+  assert.equal(f.counts().removals, 1);
+  assert.equal(f.timers.size, 0);
+});
+
+test("blueprint termination cancels renewal and sends one bounded keepalive release", async () => {
+  let tick, canceled = 0;
+  const requests = [];
+  const release = keepRecordedBlueprintSession({
+    endpointUrl: "/api/v1/observation-sessions/source/blueprint.rrd",
+    origin: "http://core.test", applicationId: "nodedc_mission_core_recorded",
+    recordingId: "recording", ownerId: "a".repeat(32),
+    fetcher: async (url, init) => { requests.push({ url, ...init }); return {}; },
+    schedule(fn) { tick = fn; return 1; }, cancel() { canceled++; },
+  });
+  tick();
+  const renewal = requests[0];
+  release(); release(); tick();
+  assert.equal(canceled, 1);
+  assert.equal(requests.length, 2);
+  assert.equal(renewal.signal.aborted, true);
+  assert.equal(requests[1].keepalive, true);
+  assert.equal(requests[1].url, "http://core.test/api/v1/observation-sessions/source/blueprint-lifecycle");
+  assert.deepEqual(JSON.parse(requests[1].body), {
+    action: "release", application_id: "nodedc_mission_core_recorded",
+    recording_id: "recording", blueprint_session_id: "a".repeat(32),
+  });
+});
+
+test("blueprint lease refuses a foreign endpoint", () => {
+  assert.throws(() => keepRecordedBlueprintSession({ endpointUrl: "https://other.test/blueprint.rrd",
+    origin: "http://core.test", applicationId: "app", recordingId: "recording", ownerId: "owner",
+  }), /Unsafe/);
+});
@@ -13,8 +13,9 @@ let liveTimelineNeedsSynchronization;
 let liveRerunReceiverBindingIdentity;
 let recordedOpenWatchdogTimeoutMs;
 let rerunViewerInitialSource;
-let rerunViewerOpenOptions;
 let resolveRecordedViewerSourceUrl;
+let isRecordedRrdSource;
+let resolveRecordedBlueprintUrl;

 before(async () => {
  server = await createServer({
@@ -31,8 +32,9 @@ before(async () => {
    liveRerunReceiverBindingIdentity,
    recordedOpenWatchdogTimeoutMs,
    rerunViewerInitialSource,
-    rerunViewerOpenOptions,
    resolveRecordedViewerSourceUrl,
+    isRecordedRrdSource,
+    resolveRecordedBlueprintUrl,
  } = await server.ssrLoadModule("/src/components/RerunViewport.tsx"));
 });

@@ -71,9 +73,40 @@ test("only the canonical digest-bound generation URL reaches the native Rerun re
  }
 });

-test("only the live receiver opens on the native following edge", () => {
-  assert.deepEqual(rerunViewerOpenOptions(true), { follow_if_http: true });
-  assert.equal(rerunViewerOpenOptions(false), null);
+test("one canonical LAB replay generation reaches the same native receiver", () => {
+  const labSource =
+    `/api/v1/laboratory/vegetation-shadow/lab-v1-vegetation-shadow-${"c".repeat(64)}`
+    + "/canonical-replay.rrd";
+  const descriptor = {
+    sourceUrl: labSource,
+    viewerSourceUrl: `${labSource}?generation=${sha256}`,
+    byteLength: 300_000_000,
+    sha256,
+  };
+
+  assert.equal(
+    resolveRecordedViewerSourceUrl(descriptor, "http://mission-core.test"),
+    `http://mission-core.test${descriptor.viewerSourceUrl}`,
+  );
+});
+
+for (const prefix of [
+  "m49-tgs-portable-review",
+  "lab-v1-eomt-ddrnet",
+  "ai-layer-ddrnet",
+  "ai-layer-eomt",
+  "ai-layer-rf-detr",
+  "ai-layer-object-distance",
+]) test(`${prefix} replay uses recorded admission and the shared source blueprint`, () => {
+  const source = `/api/v1/observatory/portable-results/${prefix}-${"c".repeat(64)}/replays/${"d".repeat(64)}/recording.rrd`;
+  const blueprint = "/api/v1/observation-sessions/source/blueprint.rrd";
+  assert.equal(isRecordedRrdSource(source), true);
+  assert.equal(isRecordedRrdSource(source.replace("/replays/", "/untrusted/")), false);
+  assert.equal(resolveRecordedViewerSourceUrl({ sourceUrl: source,
+    viewerSourceUrl: `${source}?generation=${sha256}`, sha256, byteLength: 100 },
+    "http://mission-core.test"), `http://mission-core.test${source}?generation=${sha256}`);
+  assert.equal(resolveRecordedBlueprintUrl(source, "http://mission-core.test", blueprint),
+    `http://mission-core.test${blueprint}`);
 });

 test("live presentation waits for the exact receiver to expose a usable range", () => {
@@ -215,8 +248,11 @@ test("recorded RRD bytes are never split across LogChannel.send_rrd calls", asyn
  assert.doesNotMatch(source, /streamVerifiedRecordedRrd/);
  assert.doesNotMatch(source, /missioncore\/recorded-recording/);
  assert.doesNotMatch(source, /recordedChannel/);
+  assert.match(source, /recordedPerceptionLayers\.costmap,/);
+  assert.match(source, /recordedPerceptionLayers\.costmap !== undefined && status !== "ready"/);
+  assert.match(source, /perceptionLayers\.costmap === undefined \? \{\} : \{\s*show_costmap: perceptionLayers\.costmap,\s*reactivate_updates: true/s);
  assert.match(source, /viewer\.start\(\s*rerunViewerInitialSource\(resolvedSource\)/s);
-  assert.match(source, /rerunViewerOpenOptions\(followLive\)/);
+  assert.doesNotMatch(source, /rerunViewerOpenOptions/);
  assert.match(
    source,
    /recordingOpened = true;[\s\S]*diagnosticLifecycle\.markAdmitted\(\);/,
@@ -6,6 +6,7 @@ import { createServer } from "vite";
 let server;
 let canPublishRecordedPlaybackController;
 let createRecordedAutoplayGate;
+let createRecordedInitialSeekGate;
 let isRecordedPlaybackReady;
 let isRecordedPlaybackPresentationReady;
 let isUsableRecordedPlaybackRange;
@@ -22,6 +23,7 @@ before(async () => {
  ({
    canPublishRecordedPlaybackController,
    createRecordedAutoplayGate,
+    createRecordedInitialSeekGate,
    isRecordedPlaybackReady,
    isRecordedPlaybackPresentationReady,
    isUsableRecordedPlaybackRange,
@@ -159,6 +161,31 @@ test("recorded autoplay waits for the full range and then runs exactly once", ()
  assert.equal(gate.attempted(), true);
 });

+test("paused recorded replay seeks once to its first presentable frame", () => {
+  const gate = createRecordedInitialSeekGate();
+  const seeks = [];
+  const range = { min: 0, max: 535_717_620_042 };
+
+  assert.equal(gate.attempt(
+    true,
+    true,
+    true,
+    range,
+    (value) => seeks.push(value),
+    39_215_263_458,
+  ), true);
+  assert.equal(gate.attempt(
+    true,
+    true,
+    true,
+    range,
+    (value) => seeks.push(value),
+    50_000_000_000,
+  ), false);
+  assert.deepEqual(seeks, [39_215_263_458]);
+  assert.equal(gate.attempted(), true);
+});
+
 test("recorded autoplay starts at the first presentable camera frame without shrinking the range", () => {
  const gate = createRecordedAutoplayGate();
  const seeks = [];
@@ -1,81 +1,36 @@
 import assert from "node:assert/strict";
-import { createHash } from "node:crypto";
 import { readFileSync } from "node:fs";
 import { resolve } from "node:path";
 import test from "node:test";

-import makeRerunRuntime from "../vendor/rerun-web-viewer-0.34.1/re_viewer.nodedc.js";
-
 const root = resolve(import.meta.dirname, "..");
 const packageRoot = resolve(root, "node_modules/@rerun-io/web-viewer");
-const vendorRoot = resolve(root, "vendor/rerun-web-viewer-0.34.1");
+const readJson = (path) => JSON.parse(readFileSync(path, "utf8"));

-const sha256 = (path) =>
-  createHash("sha256").update(readFileSync(path)).digest("hex");
+test("Mission Core uses the exact upstream Rerun 0.36.3 web package", () => {
+  const application = readJson(resolve(root, "package.json"));
+  const installed = readJson(resolve(packageRoot, "package.json"));

-test("NODE.DC Rerun runtime is the audited 0.34.1 spatial camera build", () => {
-  const manifest = JSON.parse(readFileSync(resolve(packageRoot, "package.json"), "utf8"));
-  assert.equal(manifest.version, "0.34.1");
-
-  const expectedWasm = "ffe7543d28bb3394f289f6299de43d038767eef83d781c2b7f8f5683308a0469";
-  const expectedGlue = "0f7b76c9f24cbd8437021b5d37499894aeadc586183e422ebc82ef556d7b8339";
-
-  assert.equal(sha256(resolve(vendorRoot, "re_viewer_bg.nodedc.wasm")), expectedWasm);
-  assert.equal(sha256(resolve(vendorRoot, "re_viewer.nodedc.js")), expectedGlue);
-  assert.equal(sha256(resolve(packageRoot, "re_viewer_bg.wasm")), expectedWasm);
-  assert.equal(sha256(resolve(packageRoot, "re_viewer.js")), expectedGlue);
+  assert.equal(application.dependencies["@rerun-io/web-viewer"], "0.36.3");
+  assert.equal(installed.version, "0.36.3");
+  assert.equal(application.scripts.postinstall, undefined);
 });

-test("custom JavaScript glue references only exports present in its paired WASM", () => {
-  const wasmPath = resolve(vendorRoot, "re_viewer_bg.nodedc.wasm");
-  const gluePath = resolve(vendorRoot, "re_viewer.nodedc.js");
-  const module = new WebAssembly.Module(readFileSync(wasmPath));
-  const exports = new Set(WebAssembly.Module.exports(module).map(({ name }) => name));
-  const imports = WebAssembly.Module.imports(module);
-  const glue = readFileSync(gluePath, "utf8");
-  const referencedExports = new Set(
-    [...glue.matchAll(/\bwasm\.([A-Za-z_$][\w$]*)/g)].map((match) => match[1]),
-  );
-  const missingExports = [...referencedExports].filter((name) => !exports.has(name));
+test("the active application never imports or installs the archived vendor fork", () => {
+  const application = readFileSync(resolve(root, "package.json"), "utf8");
+  const viewport = readFileSync(resolve(root, "src/components/RerunViewport.tsx"), "utf8");

-  assert.equal(imports.length, 927);
-  assert.equal(exports.size, 79);
-  assert.deepEqual(missingExports, []);
-  assert.match(glue, /export default function\(\)/);
-  assert.match(glue, /if \(!wasm\) return;/);
+  assert.doesNotMatch(application, /patch-rerun-web-viewer/);
+  assert.doesNotMatch(application, /vendor\/rerun-web-viewer/);
+  assert.doesNotMatch(viewport, /vendor\/rerun-web-viewer/);
+  assert.doesNotMatch(viewport, /0\.34\.1/);
 });

-test("custom Rerun WASM initializes and grows its externref table", () => {
-  const runtime = makeRerunRuntime();
-  runtime.initSync({
-    module: readFileSync(resolve(vendorRoot, "re_viewer_bg.nodedc.wasm")),
-  });
+test("upstream WebViewer exposes one three-argument start contract", () => {
+  const declaration = readFileSync(resolve(packageRoot, "index.d.ts"), "utf8");

-  assert.equal(typeof runtime.WebHandle, "function");
-  runtime.deinit();
-});
-
-test("source patch carries pointer navigation, persistent follow, and camera continuity tests", () => {
-  const patch = readFileSync(resolve(vendorRoot, "NODEDC_ZOOM_TO_CURSOR.patch"), "utf8");
-
-  assert.match(patch, /fn pointer_ray_direction/);
-  assert.match(patch, /fn zoom_orbit_towards_pointer/);
-  assert.match(patch, /near_limit_hands_excess_zoom_to_cursor_directed_dolly/);
-  assert.match(patch, /crossing_near_limit_preserves_unconsumed_scene_scaled_zoom/);
-  assert.match(patch, /remaining_zoom_factor\.ln\(\) \* self\.speed/);
-  assert.match(patch, /off_center_pointer_stays_on_the_same_view_ray/);
-  assert.match(patch, /fn rotate_radians_around_anchor/);
-  assert.match(patch, /orbit_drag_anchor/);
-  assert.match(patch, /minimum_orbital_navigation_speed/);
-  assert.match(patch, /orbital_rotation_keeps_selected_anchor_on_the_same_view_ray/);
-  assert.match(patch, /orbital_navigation_speed_floor_tracks_scene_scale/);
-  assert.match(patch, /NODEDC_PERSISTENT_ORBIT_TRACKING_ENTITY/);
-  assert.match(patch, /nodedc_rig_orbit_tracking_is_persistent/);
-  assert.match(patch, /restore_persistent_orbit_eye_after_blueprint_update/);
  assert.match(
-    patch,
-    /persistent_rig_follow_restores_the_last_rendered_eye_after_blueprint_update/,
+    declaration,
+    /start\(rrd: string \| string\[\] \| null, parent: HTMLElement \| null, options: WebViewerOptions \| null\): Promise<void>/,
  );
-  assert.match(patch, /explicit_blueprint_pose_is_not_replaced_by_the_previous_eye/);
-  assert.match(patch, /previous_picking_result/);
 });
@@ -97,7 +97,7 @@ test("M4 keeps independent semantic controls in media and spatial panes", async
  assert.match(source, /aria-label="Слои 3D и плана"/);
  assert.match(canonical, /data-pane-mode="media"/);
  assert.match(canonical, /data-pane-mode="spatial"/);
-  assert.match(canonical, /modeControlsVisible=\{!splitView\}/);
+  assert.match(canonical, /modeControlsVisible=\{!splitView && !paneToolbarsAlwaysVisible\}/);
  assert.match(source, /semanticOverlay=\{mediaMode === "video" \? semanticOverlay : undefined\}/);
 });

@@ -124,6 +124,11 @@ test("Compute-contour telemetry remains a bounded system feature slice", async (
  assert.match(pollIntervalContract, /MIN_TELEMETRY_POLL_INTERVAL_SECONDS\s*=\s*1/);
  assert.match(telemetryPolling, /normalizeWorkerTelemetryPollMilliseconds/);
  assert.match(telemetryPolling, /startSequentialPolling/);
+  assert.match(telemetryPolling, /catch \(reason: unknown\)[\s\S]*?setTelemetry\(null\)/);
+  assert.match(computeWorkspace, /sm_clock_mhz/);
+  assert.match(computeWorkspace, /memory_clock_mhz/);
+  assert.match(computeWorkspace, /Ожидает восстановления данных/);
+  assert.doesNotMatch(computeWorkspace, /Очередь свободна; модели остаются загруженными/);
  assert.doesNotMatch(telemetryPolling, /if\s*\(\s*!enabled\s*\|\|\s*loading\s*\)/);
  assert.match(pollingScheduler, /A transient failure must not stop polling/);
  assert.match(styles, /system-telemetry\.css/);
@@ -451,8 +451,8 @@ test("canonical recorded LAB spatial frame keeps source, SLAM and body identity
  assert.deepEqual(frame.bodyFrame.originMapXyzM, [33, 4, 1]);
 });

-test("vegetation realtime LAB and archival benchmark use separate admitted instruments", async () => {
-  const [resultSource, benchmarkSource, m49Source, canonicalSource] = await Promise.all([
+test("vegetation realtime LAB uses one upstream Rerun clock and keeps archival review separate", async () => {
+  const [resultSource, benchmarkSource, m49Source, canonicalSource, rerunSource, replayStyles] = await Promise.all([
    readFile(
      new URL("../src/workspaces/laboratory/VegetationShadowResult.tsx", import.meta.url),
      "utf8",
@@ -469,6 +469,14 @@ test("vegetation realtime LAB and archival benchmark use separate admitted instr
      new URL("../src/components/laboratory/CanonicalRecordedLabReplay.tsx", import.meta.url),
      "utf8",
    ),
+    readFile(
+      new URL("../src/components/laboratory/CanonicalResultRerunReplay.tsx", import.meta.url),
+      "utf8",
+    ),
+    readFile(
+      new URL("../src/styles/m4-replay-threat.css", import.meta.url),
+      "utf8",
+    ),
  ]);
  assert.doesNotMatch(resultSource, /M48MaskComparisonVisual/);
  assert.match(resultSource, /M49TgsFullShadowEvidence/);
@@ -477,23 +485,49 @@ test("vegetation realtime LAB and archival benchmark use separate admitted instr
  assert.match(m49Source, /controlLabel: "SEMANTICS"/);
  assert.equal(resultSource.match(/<LaboratoryEvidence\b/g)?.length, 2);
  assert.doesNotMatch(resultSource, /RAVNOVES004TREE mixed route review/);
-  assert.match(resultSource, /CANONICAL RECORDED LAB · RAVNOVES004TREE/);
-  assert.match(resultSource, /<M4ReplayThreatVisual/);
-  assert.match(resultSource, /timelineEndpointRoot=\{VEGETATION_TIMELINE_ENDPOINT\}/);
-  assert.match(resultSource, /playbackTransport="segmented"/);
-  assert.match(resultSource, /recoverTimestampStalls/);
+  assert.match(resultSource, /КАНОНИЧЕСКАЯ ЗАПИСАННАЯ LAB · RAVNOVES004TREE/);
+  assert.match(resultSource, /<CanonicalVegetationRerunReplay/);
  assert.doesNotMatch(resultSource, /RerunViewport/);
  assert.doesNotMatch(resultSource, /cacheRef|pumpRef|desiredRef/);
  assert.doesNotMatch(resultSource, /LaboratoryRecordedClipPlayer|M48EvidenceModeRail/);
  assert.doesNotMatch(resultSource, /assets\.tgs|<img/);
-  assert.match(resultSource, /SOURCE POINTS/);
-  assert.match(resultSource, /TGS COSTMAP/);
+  assert.match(rerunSource, /<RerunViewport/);
+  assert.match(rerunSource, /ИСХ\. ТОЧКИ/);
+  assert.match(rerunSource, /ЛОК\. SLAM/);
+  assert.match(rerunSource, /resolveReplay\(resultId, value/);
+  assert.doesNotMatch(rerunSource, /canonical-overlay\.rrd/);
+  assert.match(rerunSource, /unifiedPerception: splitView/);
+  assert.match(rerunSource, /lockPerceptionCameraInteraction: false/);
+  assert.match(rerunSource, /&& !semantics[\s\S]*&& !detections[\s\S]*&& !costmap/);
+  assert.doesNotMatch(rerunSource, /trackNativeSplit|rerunNativeCursor|rerunNativeInput/);
+  assert.match(canonicalSource, /resizable=\{splitView\}/);
+  assert.match(rerunSource, /unifiedCameraShare: blueprintSplitPrimarySize \/ 100/);
+  assert.match(rerunSource, /data-split-view=\{splitView \? "true" : undefined\}/);
+  assert.match(rerunSource, /max=\{500\}/);
+  assert.match(rerunSource, /exactValueBounds=\{\{ min: 0 \}\}/);
+  assert.match(replayStyles, /m4-replay-threat-visual__pane-toolbar \{[\s\S]*flex-wrap: wrap;/);
+  assert.match(replayStyles, /m4-replay-threat-visual__spatial-toolbar-end \{[\s\S]*display: contents;/);
+  assert.match(rerunSource, /<ToastStack items=\{toasts\}/);
+  assert.match(rerunSource, /isRecordedPlaybackPresentationReady\(viewerStatus, playback\)/);
+  assert.match(rerunSource, /data-presentation-state=\{presentationState\}/);
+  assert.match(rerunSource, /<ActivityIndicator label="Загружаем синхронизированную запись"/);
+  assert.match(rerunSource, /presentationReady && playback && playbackController/);
+  assert.match(
+    replayStyles,
+    /canonical-vegetation-rerun-replay:not\(\[data-presentation-state="ready"\]\)[\s\S]*laboratory-evidence-viewer__controls/,
+  );
+  assert.match(
+    replayStyles,
+    /canonical-vegetation-rerun-replay__timeline \.observation-timeline__playback \{[\s\S]*grid-template-columns: auto auto minmax\(0, 1fr\) auto;/,
+  );
+  assert.doesNotMatch(rerunSource, /LaboratoryRecordedClipPlayer|LaboratoryMetricEvidenceScene/);
  assert.match(resultSource, /point-aligned 3D semantics пока не запечатаны/);
-  assert.match(resultSource, /cellLayerAvailable: false/);
+  assert.match(rerunSource, /hasTgs \? toggle\("TGS", showTgs/);
  assert.match(canonicalSource, /primary=\{mediaPane\}/);
  assert.match(canonicalSource, /secondary=\{spatialPane/);
  assert.match(canonicalSource, /missioncore\.canonical-recorded-lab-replay\/v1/);
-  assert.match(canonicalSource, /separatorLabel="Изменить размер VIDEO\/CAMERA и 3D\/PLAN"/);
+  assert.match(canonicalSource, /separatorLabel="Изменить размер видео\/камеры и 3D\/плана"/);
+  assert.match(canonicalSource, /resizable=\{splitView\}/);
  assert.match(resultSource, /linked canonical M4\.9 TGS evidence/);
  assert.match(resultSource, /linkedTgsResultId/);
  assert.match(benchmarkSource, /M48MaskComparisonVisual/);
@@ -75,13 +75,13 @@ test("recorded session profile owns progressive admission and on-demand layers",
  assert.equal(profile.perceptionLayers.enabled, false);
 });

-test("LAB recorded evidence remains outside native Rerun lifecycle", () => {
+test("the old LAB transport is fenced as explicit legacy comparison only", () => {
  assert.deepEqual(LABORATORY_RECORDED_EVIDENCE_VIEWER_PROFILE, {
    kind: "lab-recorded-evidence",
    clock: "source-sequence",
    cameraTransport: "generation-bound-fmp4",
    spatialTransport: "bounded-sealed-artifacts",
-    loadPolicy: "visible-evidence-only",
+    loadPolicy: "explicit-legacy-comparison-only",
    workerRequired: false,
  });
  assert.equal(Object.isFrozen(LABORATORY_RECORDED_EVIDENCE_VIEWER_PROFILE), true);
@@ -0,0 +1,10 @@
+# Archived viewer comparison source
+
+`rerun-web-viewer-0.34.1/` is retained only as rollback-era comparison evidence
+for ADR 0045. The active application neither imports it nor runs the historical
+patch scripts during install or build. Canonical Control Station routes use the
+unmodified `@rerun-io/web-viewer` dependency declared in `package.json`.
+
+Do not update or reactivate this tree. Remove it with the remaining custom
+fMP4/Three.js replay implementation after the canonical Rerun migration passes
+operator visual acceptance.
@@ -91,6 +91,12 @@ export default defineConfig(({ mode }) => {
    },
    build: {
      target: "esnext",
+      rollupOptions: {
+        input: {
+          app: fileURLToPath(new URL("./index.html", import.meta.url)),
+          rerun: fileURLToPath(new URL("./rerun-runtime.html", import.meta.url)),
+        },
+      },
    },
    server: {
      host: "127.0.0.1",
@@ -0,0 +1,161 @@
+{
+  "schema_version": "missioncore.observatory-ai-module-registry/v1",
+  "modules": [
+    {
+      "module_id": "camera-source",
+      "label": "Подготовка камеры K1",
+      "group": "preparation",
+      "image_sha256": "da926459aee0a841bbdfaf80a0eb5fbead354c56794d1f3384eeba66d0a49e00",
+      "implementation_sha256": "a0b1a74887e5f1cf78e867f81f246bae08e872fed320a2939986c17913418524",
+      "model_sha256": null,
+      "contract_sha256": "87c9e8864f9469719e69bfd750c418e077944a6260ffc6fd3ce12daf4a1da7d5",
+      "requires": [
+        "source.camera"
+      ],
+      "provides": [
+        "camera.frames"
+      ],
+      "optional_inputs": [],
+      "parameter_choices": {
+        "cadence": [
+          1
+        ]
+      },
+      "defaults": {
+        "cadence": 1
+      },
+      "state_policy": "stateless"
+    },
+    {
+      "module_id": "ddrnet",
+      "label": "DDRNet-39 · GOOSE",
+      "group": "segmentation",
+      "image_sha256": "489fc7d1157fd0f1cd1d82e06a15737b7b2aaaf72b2ddb2aca2992b91a97488e",
+      "implementation_sha256": "9a3fceb65374ccc3dccdbe02691c2b62376ff3a3a6d16439cb9f6266e73c78b0",
+      "model_sha256": "b99c2838051bcd7b092fd3970aa62a77d5c0bbb809c9b9afb2ff4b0ebdaa4ee6",
+      "contract_sha256": "197c9d7dd0f55f79992215a57e450c5442f3d1510d74083bcf123577f85da199",
+      "requires": [
+        "camera.frames"
+      ],
+      "provides": [
+        "segmentation.mask"
+      ],
+      "optional_inputs": [],
+      "parameter_choices": {
+        "cadence": [
+          1
+        ]
+      },
+      "defaults": {
+        "cadence": 1
+      },
+      "state_policy": "stateless"
+    },
+    {
+      "module_id": "eomt",
+      "label": "EoMT Large · Cityscapes",
+      "group": "segmentation",
+      "image_sha256": "5b770178e4a5c8fbe8f8ddab3b83a598973dbe103b669851110b11a0918ab846",
+      "implementation_sha256": "17ac471d5c51f70b3af6fb6046e1880c731691253c338b1626702ce4ca375d2b",
+      "model_sha256": "c265da9a74f58f5c3f4826d23ca4ca78beac0b106cca5842beca61580de5b782",
+      "contract_sha256": "09ca841400b08af0607d19d346f78ab768567256c8c58789a6ade4ede8f425a0",
+      "requires": [
+        "camera.frames"
+      ],
+      "provides": [
+        "segmentation.mask"
+      ],
+      "optional_inputs": [],
+      "parameter_choices": {
+        "cadence": [
+          1
+        ]
+      },
+      "defaults": {
+        "cadence": 1
+      },
+      "state_policy": "stateless"
+    },
+    {
+      "module_id": "tgs",
+      "label": "TRAVEL TGS · облако и карта проходимости",
+      "group": "geometry",
+      "image_sha256": "f9278ab21aa65045be993dd19bffc25f49955e19598893ac78cc4761ca63ecf3",
+      "implementation_sha256": "52813392aabd02efc5c2b8f7c22ed88e3ef4cc8ad3aafeba2792efe503e29fe9",
+      "model_sha256": null,
+      "contract_sha256": "9dd80c8e2504559d2156fca933de6eb27901e35305e6853aeb84707e1cb13892",
+      "requires": [
+        "source.calibration",
+        "source.lidar",
+        "source.pose"
+      ],
+      "provides": [
+        "geometry.costmap",
+        "geometry.ground"
+      ],
+      "optional_inputs": [],
+      "parameter_choices": {
+        "history-seconds": [
+          1
+        ]
+      },
+      "defaults": {
+        "history-seconds": 1
+      },
+      "state_policy": "causal-reset-at-source-start"
+    },
+    {
+      "module_id": "rf-detr",
+      "label": "RF-DETR Large · рамки объектов",
+      "group": "detection",
+      "image_sha256": "2b8b44be8e9ee4060aa6997fc4c025ad7120f37ecd720a9e59b5e02ac6c90f66",
+      "implementation_sha256": "4eb580eb938164bf0624e94fdc3b046aacf32fb8022c93c67fa26bab7c3d19d0",
+      "model_sha256": "b8a40b3580edff001ec9680de68707242294ff590ab296000fae371f1083f695",
+      "contract_sha256": "815d0afd24355da3a462e0423dab8284165c89cebd136d7c8584a32602178b96",
+      "requires": [
+        "camera.frames"
+      ],
+      "provides": [
+        "detections.2d"
+      ],
+      "optional_inputs": [],
+      "parameter_choices": {
+        "cadence": [
+          1
+        ]
+      },
+      "defaults": {
+        "cadence": 1
+      },
+      "state_policy": "stateless"
+    },
+    {
+      "module_id": "object-distance",
+      "label": "Дистанция до объектов · K1 LiDAR",
+      "group": "range",
+      "image_sha256": "69d68f64981b41e5bcce1e642433e3d466b88c51942a5ba3aec9180d8ed04263",
+      "implementation_sha256": "0e3e426e2f768bc019a3715a50fc77a88626869abd9fa919e1aef5763d0c53da",
+      "model_sha256": null,
+      "contract_sha256": "5a6e446f009420352587f83388331b368d00950ab2fb896c6350aaa9b31c2e2e",
+      "requires": [
+        "detections.2d",
+        "source.calibration",
+        "source.lidar",
+        "source.pose"
+      ],
+      "provides": [
+        "objects.ranged"
+      ],
+      "optional_inputs": [],
+      "parameter_choices": {
+        "cadence": [
+          1
+        ]
+      },
+      "defaults": {
+        "cadence": 1
+      },
+      "state_policy": "stateless"
+    }
+  ]
+}
@@ -0,0 +1,336 @@
+{
+  "schema_version": "missioncore.observatory-domain-ontology/v1",
+  "ontology_id": "mission-core.observatory",
+  "version": "1.3.0",
+  "owner": "NODE.DC Mission Core",
+  "lifecycle": "local-runtime-canonical",
+  "entities": [
+    {
+      "id": "mission.transport-unit",
+      "identity": "transport_id",
+      "owner": "transport registry",
+      "lifecycle": "registered-to-retired"
+    },
+    {
+      "id": "mission.equipment-unit",
+      "identity": "equipment_id",
+      "owner": "equipment registry",
+      "lifecycle": "registered-to-retired"
+    },
+    {
+      "id": "observatory.equipment-mount",
+      "identity": "mount_id",
+      "owner": "equipment capture registry",
+      "lifecycle": "time-bounded"
+    },
+    {
+      "id": "observatory.capture-profile",
+      "identity": "capture_profile_id",
+      "owner": "equipment capture registry",
+      "lifecycle": "versioned"
+    },
+    {
+      "id": "observatory.recorded-session",
+      "identity": "source_session_id",
+      "owner": "session archive",
+      "lifecycle": "recording-to-immutable"
+    },
+    {
+      "id": "observatory.module-version",
+      "identity": "module_sha256",
+      "owner": "module registry",
+      "lifecycle": "installed-or-retired"
+    },
+    {
+      "id": "observatory.container-image",
+      "identity": "image_sha256",
+      "owner": "module registry",
+      "lifecycle": "built-to-retired"
+    },
+    {
+      "id": "observatory.worker-node",
+      "identity": "worker_node_id",
+      "owner": "worker registry",
+      "lifecycle": "registered-to-retired"
+    },
+    {
+      "id": "observatory.composition",
+      "identity": "composition_sha256",
+      "owner": "composition store",
+      "lifecycle": "immutable"
+    },
+    {
+      "id": "observatory.composition-run",
+      "identity": "run_id",
+      "owner": "composition run store",
+      "lifecycle": "append-only"
+    },
+    {
+      "id": "observatory.recorded-job",
+      "identity": "job_id",
+      "owner": "recorded job queue",
+      "lifecycle": "queued-to-terminal"
+    },
+    {
+      "id": "observatory.portable-result",
+      "identity": "result_id",
+      "owner": "portable result publisher",
+      "lifecycle": "immutable"
+    },
+    {
+      "id": "observatory.lab-projection",
+      "identity": "result_id",
+      "owner": "session catalog",
+      "lifecycle": "published"
+    },
+    {
+      "id": "observatory.lab-view-profile",
+      "identity": "result_id",
+      "owner": "replay presentation",
+      "lifecycle": "mutable-per-result"
+    },
+    {
+      "id": "observatory.viewer-pane",
+      "identity": "pane_id",
+      "owner": "replay presentation",
+      "lifecycle": "versioned-contract"
+    },
+    {
+      "id": "observatory.viewer-layer",
+      "identity": "layer_id",
+      "owner": "replay presentation",
+      "lifecycle": "versioned-contract"
+    }
+  ],
+  "relations": [
+    {
+      "id": "observatory.equipment-mount.mounts_equipment",
+      "from": "observatory.equipment-mount",
+      "to": "mission.equipment-unit",
+      "cardinality": "many-to-one"
+    },
+    {
+      "id": "observatory.equipment-mount.attaches_to_transport",
+      "from": "observatory.equipment-mount",
+      "to": "mission.transport-unit",
+      "cardinality": "many-to-one"
+    },
+    {
+      "id": "observatory.recorded-session.captured_on_transport",
+      "from": "observatory.recorded-session",
+      "to": "mission.transport-unit",
+      "cardinality": "many-to-zero-or-one"
+    },
+    {
+      "id": "observatory.recorded-session.captured_with_equipment",
+      "from": "observatory.recorded-session",
+      "to": "mission.equipment-unit",
+      "cardinality": "many-to-many"
+    },
+    {
+      "id": "observatory.recorded-session.uses_equipment_mount",
+      "from": "observatory.recorded-session",
+      "to": "observatory.equipment-mount",
+      "cardinality": "many-to-many"
+    },
+    {
+      "id": "observatory.recorded-session.uses_capture_profile",
+      "from": "observatory.recorded-session",
+      "to": "observatory.capture-profile",
+      "cardinality": "many-to-one"
+    },
+    {
+      "id": "observatory.composition-run.uses_recorded_session",
+      "from": "observatory.composition-run",
+      "to": "observatory.recorded-session",
+      "cardinality": "many-to-one"
+    },
+    {
+      "id": "observatory.composition.contains_module",
+      "from": "observatory.composition",
+      "to": "observatory.module-version",
+      "cardinality": "one-to-many"
+    },
+    {
+      "id": "observatory.module-version.implemented_by_image",
+      "from": "observatory.module-version",
+      "to": "observatory.container-image",
+      "cardinality": "many-to-one"
+    },
+    {
+      "id": "observatory.container-image.installed_on_worker",
+      "from": "observatory.container-image",
+      "to": "observatory.worker-node",
+      "cardinality": "many-to-many"
+    },
+    {
+      "id": "observatory.composition-run.applies_composition",
+      "from": "observatory.composition-run",
+      "to": "observatory.composition",
+      "cardinality": "many-to-one"
+    },
+    {
+      "id": "observatory.composition-run.uses_job",
+      "from": "observatory.composition-run",
+      "to": "observatory.recorded-job",
+      "cardinality": "one-to-many"
+    },
+    {
+      "id": "observatory.recorded-job.executes_on_worker",
+      "from": "observatory.recorded-job",
+      "to": "observatory.worker-node",
+      "cardinality": "many-to-one"
+    },
+    {
+      "id": "observatory.recorded-job.publishes_result",
+      "from": "observatory.recorded-job",
+      "to": "observatory.portable-result",
+      "cardinality": "one-to-zero-or-one"
+    },
+    {
+      "id": "observatory.composition-run.projects_lab",
+      "from": "observatory.composition-run",
+      "to": "observatory.lab-projection",
+      "cardinality": "one-to-zero-or-one"
+    },
+    {
+      "id": "observatory.lab-projection.has_view_profile",
+      "from": "observatory.lab-projection",
+      "to": "observatory.lab-view-profile",
+      "cardinality": "one-to-zero-or-one"
+    },
+    {
+      "id": "observatory.module-version.exposes_layer",
+      "from": "observatory.module-version",
+      "to": "observatory.viewer-layer",
+      "cardinality": "many-to-many"
+    },
+    {
+      "id": "observatory.viewer-layer.belongs_to_pane",
+      "from": "observatory.viewer-layer",
+      "to": "observatory.viewer-pane",
+      "cardinality": "many-to-one"
+    }
+  ],
+  "panes": [
+    {
+      "pane_id": "camera",
+      "label": "Камера",
+      "order": 10
+    },
+    {
+      "pane_id": "spatial",
+      "label": "Облако точек",
+      "order": 20
+    }
+  ],
+  "layers": [
+    {
+      "layer_id": "camera.source",
+      "pane_id": "camera",
+      "label": "КАМЕРА",
+      "control": "toggle",
+      "order": 10
+    },
+    {
+      "layer_id": "camera.ddrnet",
+      "pane_id": "camera",
+      "label": "DDRNET",
+      "control": "toggle",
+      "order": 20
+    },
+    {
+      "layer_id": "camera.eomt",
+      "pane_id": "camera",
+      "label": "EOMT",
+      "control": "toggle",
+      "order": 30
+    },
+    {
+      "layer_id": "camera.detections",
+      "pane_id": "camera",
+      "label": "РАМКИ",
+      "control": "toggle",
+      "order": 40
+    },
+    {
+      "layer_id": "spatial.source-points",
+      "pane_id": "spatial",
+      "label": "ИСХ. ТОЧКИ",
+      "control": "toggle",
+      "order": 10
+    },
+    {
+      "layer_id": "spatial.local-slam",
+      "pane_id": "spatial",
+      "label": "ЛОК. SLAM",
+      "control": "toggle-with-settings",
+      "order": 20
+    },
+    {
+      "layer_id": "spatial.tgs",
+      "pane_id": "spatial",
+      "label": "TGS",
+      "control": "toggle",
+      "order": 30
+    }
+  ],
+  "module_projections": [
+    {
+      "module_id": "ddrnet",
+      "configuration_label": "DDRNet-39 · GOOSE",
+      "layers": [
+        "camera.source",
+        "camera.ddrnet"
+      ]
+    },
+    {
+      "module_id": "eomt",
+      "configuration_label": "EoMT Large · Cityscapes",
+      "layers": [
+        "camera.source",
+        "camera.eomt"
+      ]
+    },
+    {
+      "module_id": "rf-detr",
+      "configuration_label": "RF-DETR Large",
+      "layers": [
+        "camera.source",
+        "camera.detections"
+      ]
+    },
+    {
+      "module_id": "tgs",
+      "configuration_label": "TRAVEL TGS",
+      "layers": [
+        "spatial.source-points",
+        "spatial.local-slam",
+        "spatial.tgs"
+      ]
+    },
+    {
+      "module_id": "object-distance",
+      "configuration_label": "Дистанция до объектов · K1 LiDAR",
+      "layers": [
+        "camera.source",
+        "camera.detections",
+        "spatial.source-points",
+        "spatial.local-slam"
+      ]
+    }
+  ],
+  "named_queries": [
+    "recording.capture-context",
+    "composition.configuration-label",
+    "composition.member-results",
+    "composition.viewer-layers",
+    "composition.ready-state",
+    "lab.view-profile"
+  ],
+  "platform_sync": {
+    "mode": "none",
+    "promotion_gate": "stable cross-product meaning with an agreed Platform Ontology migration",
+    "platform_repository_is_runtime_dependency": false
+  }
+}
@@ -0,0 +1,22 @@
+{
+  "schema_version": "missioncore.equipment-model-registry/v1",
+  "models": [
+    {
+      "schema_version": "missioncore.equipment-model/v1",
+      "equipment_model_id": "xgrids.lixelkity-k1",
+      "equipment_model_version": 1,
+      "plugin_id": "nodedc.device.xgrids-lixelkity-k1",
+      "vendor": "XGRIDS",
+      "display_name": "XGRIDS LixelKity K1",
+      "category": "mobile-lidar-scanner",
+      "capability_ids": [
+        "recorded.camera.video",
+        "recorded.lidar.point-cloud",
+        "recorded.pose.trajectory"
+      ],
+      "authority": {
+        "commands_enabled": false
+      }
+    }
+  ]
+}
@@ -0,0 +1,97 @@
+{
+  "schema_version": "missioncore.observatory-laboratory-setup-registry/v1",
+  "setups": [
+    {
+      "setup_id": "m49-tgs-full-shadow-v1",
+      "display_name": "M4.9T5 · TRAVEL TGS · CPU-only, без ML",
+      "description": "Сохранённая конфигурация RAVNOVES00: TRAVEL TGS без ML-моделей, 4 489 кадров, causal rolling 1 s, полный визуальный разбор и отдельное доказательство integrated graph.",
+      "origin": "archived-definition",
+      "source": {
+        "session_id": "20260720T065719Z_viewer_live",
+        "label": "RAVNOVES00",
+        "required_modalities": [
+          "point-cloud",
+          "trajectory",
+          "video"
+        ]
+      },
+      "run_definition": {
+        "definition_id": "m49-tgs-full-shadow",
+        "version": 1,
+        "work_id": "m49-tgs-full-shadow",
+        "configuration": [
+          {
+            "role": "primary-profile",
+            "path": "config/perception/m49-tgs-full-shadow-v1.json",
+            "sha256": "c2e07010aaee78259d36c057962d6bfb885349251ff7356d867e5813e632881c"
+          }
+        ]
+      },
+      "executor": {
+        "contour_id": "worker-006",
+        "state": "not-installed",
+        "reason_code": "laboratory-runner-adapter-not-installed",
+        "reason": "Повторный запуск этого сетапа ещё не подключён к общему контуру расчёта."
+      },
+      "preserved_results": [
+        {
+          "result_id": "m49-tgs-full-shadow-ef98de7db7596d48e8c8c0549ce68e6704ee03e87c8c4bcf1e3e748b7ccb032e",
+          "result_kind": "recorded-source-paced-tgs-shadow",
+          "relation": "primary-visual",
+          "access": "legacy-lab",
+          "created_at_utc": "2026-08-26T20:27:19.076865Z"
+        },
+        {
+          "result_id": "m49-tgs-integrated-graph-shadow-75e48fd8acf0246be16613e087fcf26fe909f7834718d217c74785a57f494b24",
+          "result_kind": "source-paced-integrated-graph-shadow",
+          "relation": "compute-successor",
+          "access": "evidence-only",
+          "created_at_utc": "2026-08-27T08:50:05.5622153+00:00"
+        }
+      ],
+      "authority": {
+        "commands_enabled": false,
+        "actuation_allowed": false,
+        "navigation_or_safety_accepted": false,
+        "production_accepted": false
+      }
+    },
+    {
+      "setup_id": "lab-v1-ravnoves004tree-final",
+      "display_name": "LAB V1 · EoMT Cityscapes Large 1024 + DDRNet-39",
+      "description": "Точный RAVNOVES004TREE result: 6 830 кадров EoMT Cityscapes Large 1024 + DDRNet-39 и синхронный записанный replay; полный TGS и независимый YOLOX отсутствуют.",
+      "origin": "existing-result",
+      "source": {
+        "session_id": "20260828T130511Z_viewer_live",
+        "label": "RAVNOVES004TREE",
+        "required_modalities": [
+          "point-cloud",
+          "trajectory",
+          "video"
+        ]
+      },
+      "run_definition": null,
+      "executor": {
+        "contour_id": "worker-006",
+        "state": "not-installed",
+        "reason_code": "durable-dispatch-definition-unavailable",
+        "reason": "Для готового результата не сохранён повторно запускаемый сетап; доступен записанный разбор."
+      },
+      "preserved_results": [
+        {
+          "result_id": "lab-v1-vegetation-shadow-8c8f387599955dd79a16ded2c2d7cfd7f9f308d704f52c42fc26bd39d6da2d60",
+          "result_kind": "recorded-perception-qualification",
+          "relation": "canonical-projection",
+          "access": "observatory",
+          "created_at_utc": "2026-08-29T18:05:11.329061Z"
+        }
+      ],
+      "authority": {
+        "commands_enabled": false,
+        "actuation_allowed": false,
+        "navigation_or_safety_accepted": false,
+        "production_accepted": false
+      }
+    }
+  ]
+}
@@ -0,0 +1,61 @@
+{
+  "schema_version": "missioncore.observatory-m49-recorded-queue-binding/v1",
+  "binding_id": "m49-ravnoves00-recorded-queue-v1",
+  "source": {
+    "session_id": "20260720T065719Z_viewer_live",
+    "label": "RAVNOVES00",
+    "required_modalities": [
+      "point-cloud",
+      "trajectory",
+      "video"
+    ],
+    "source_pack": {
+      "artifact_id": "e10-lidar-pack-576c994a6c814e2592dd6240ace3902a5db94843312c759a73ba0c9166157d2b",
+      "sha256": "0685d24219d8236caf8b7f1685e93f6d6b59e7fd015a768d88a92bbe8b154944",
+      "byte_length": 72996000,
+      "media_type": "application/vnd.nodedc.lidar-source-pack+npz",
+      "expected_timeline_frames": 4489,
+      "expected_available_lidar_frames": 3928
+    }
+  },
+  "setup": {
+    "setup_id": "m49-tgs-full-shadow-v1",
+    "definition_id": "m49-tgs-full-shadow",
+    "definition_version": 1,
+    "definition_sha256": "836a66639e69f7ea00de2a9111c1c6c9c3c00f1abd726f1df596aeb4e3a88ae6"
+  },
+  "source_adapter": {
+    "adapter_id": "ravnoves00-m49-source-pack",
+    "version": 1
+  },
+  "executor": {
+    "release_id": "m49-tgs-full-shadow-worker-release",
+    "artifact_sha256": "5e0ea16c7a5cc760463836718b0cd8b0006ffc4b202e5f706a20a86ef2f912ab",
+    "code_revision": "40c850b167dda366d8aa45d828520168affaf9fd",
+    "service_installed": false,
+    "image_set": {
+      "schema_version": "missioncore.observatory-executor-image-set/v1",
+      "images": {
+        "travel": "7b412020f4d8392d1d1ed1b33beadc44140f0ea8f781e62dd69796042334300f",
+        "parity": "ceb13548617e4bd3f619766bfdff00af3fa5160946b367828da6d2233dcdcba0"
+      }
+    },
+    "learned_models": []
+  },
+  "resource_profile": {
+    "schema_version": "missioncore.observatory-recorded-resource-profile/v1",
+    "profile_id": "worker006-cpu-single-run-v1",
+    "contour_id": "worker-006",
+    "concurrency": 1,
+    "checkpoint_policy": "non-checkpointable",
+    "restart_from_zero": true,
+    "staging_discard_required": true,
+    "resource_release_receipt_required": true
+  },
+  "authority": {
+    "commands_enabled": false,
+    "actuation_allowed": false,
+    "navigation_or_safety_accepted": false,
+    "production_accepted": false
+  }
+}
@@ -0,0 +1,43 @@
+{
+  "schema_version": "missioncore.recorded-capture-profile-registry/v1",
+  "profiles": [
+    {
+      "schema_version": "missioncore.recorded-capture-profile/v1",
+      "capture_profile_id": "xgrids-k1.viewer-live.fw-3.0.2.v1",
+      "capture_profile_version": 1,
+      "equipment_model_id": "xgrids.lixelkity-k1",
+      "equipment_model_sha256": "c95d7183ffd2e425892fd9ddfc4cd8dcbccc0231289127ddc14db6b52bbb92aa",
+      "plugin_id": "nodedc.device.xgrids-lixelkity-k1",
+      "archive_id": "xgrids-k1.viewer-live.evidence",
+      "firmware_compatibility_profile_id": "xgrids.lixelkity-k1.fw-3.0.2.local-network.v2",
+      "modalities": [
+        "point-cloud",
+        "trajectory",
+        "video"
+      ],
+      "semantic_channels": [
+        "camera.video.recorded",
+        "spatial.point-cloud.recorded",
+        "spatial.pose.recorded"
+      ],
+      "camera_media": {
+        "source_id": "sensor.camera.right",
+        "media_type": "video/mp4; codecs=\"avc1.641028\"",
+        "width": 800,
+        "height": 600,
+        "initialization_sha256": "e2279963e16d84c91d68e7dbb1f7efed840533387dfeb844b7398bff45fbde38"
+      },
+      "calibration": {
+        "slot_id": "camera_1",
+        "sha256": "05f3ad9b38b3a4fc95388a8ec83da83c745e217709e51787b3d5aad0969f6fa9"
+      },
+      "media_epoch_policy": "exactly-one-complete-epoch",
+      "seekable": true,
+      "adapter": {
+        "adapter_id": "xgrids-k1-recorded-observatory-v2",
+        "version": 2,
+        "adapter_sha256": "4e12be6d2503e2e237eddb290b28d6a7d16cf983855b6d8e6b4e3b65d2feb0de"
+      }
+    }
+  ]
+}
@@ -0,0 +1,206 @@
+{
+  "schema_version": "missioncore.perception-profile-candidate/v1",
+  "profile_id": "k1-perception-ddrnet39-rfdetr-tgs-prototype/v1",
+  "display_name": "K1 Perception — DDRNet-39 + RF-DETR + TGS",
+  "status": "stage-1-candidate-not-installed-not-qualified",
+  "experiment_policy": {
+    "bounded_lab_overload_allowed": true,
+    "retain_profiles_that_fail_current_hardware_realtime": true,
+    "realtime_failure_blocks_experimental_packaging": false,
+    "qualification_scope": ["profile-version", "effective-config", "hardware", "source", "transport"],
+    "preserve_original_source_clock": true,
+    "report_drops_and_staleness": true,
+    "overload_is_realtime_pass": false,
+    "future_onboard_placement_requires_new_measurement": true
+  },
+  "packaging": {
+    "image": "ndc-k1-perception-ddrnet39-rfdetr-tgs:prototype-v1",
+    "image_sha256": null,
+    "single_container": true,
+    "external_model_server_required": false,
+    "host_model_cache_required": false,
+    "runtime_model_download_allowed": false,
+    "model_environment_isolation": "supervised-processes-one-gpu-scheduler",
+    "common_interpreter_required": false
+  },
+  "hardware_baseline": {
+    "gpu": "NVIDIA GeForce RTX 4090",
+    "active_profiles_per_worker": 1,
+    "sources_per_worker": 1,
+    "gpu_inference_policy": "serialized",
+    "other_gpu_workloads_allowed": false
+  },
+  "cpu_execution_policy": {
+    "OPENBLAS_NUM_THREADS": 1,
+    "OMP_NUM_THREADS": 1,
+    "MKL_NUM_THREADS": 1,
+    "reason": "bounded-single-thread-numeric-libraries-before-whole-graph-qualification"
+  },
+  "operating_envelope": {
+    "status": "bounded-latency-reference-not-full-qualification",
+    "checker": "k1link.perception.worker_operating_envelope.operating_envelope_failures",
+    "reference_conditions": {
+      "envelope_id": "worker006-4090-610.47-stock-clock-reference/v1",
+      "gpu_name": "NVIDIA GeForce RTX 4090",
+      "driver_version": "610.47",
+      "cpu_limit_millicores": 8000,
+      "memory_limit_mib": 8192,
+      "minimum_sm_clock_mhz": 2610,
+      "minimum_memory_clock_mhz": 10251,
+      "maximum_snapshot_age_ms": 1000
+    },
+    "check_phase": "post-warmup-before-timed-window-plus-runtime-monitoring",
+    "container_may_set_host_clocks": false,
+    "persistent_host_clock_policy_installed": false,
+    "readiness_is_realtime_qualification": false,
+    "unknown_ownership_or_telemetry_is_pass": false,
+    "failed_envelope_allows_labelled_experiment": true
+  },
+  "output_freshness_contract": {
+    "schema_version": "missioncore.perception-scene-freshness/v1",
+    "required_layers": ["segmentation", "objects", "geometry", "motion", "costmap", "policy"],
+    "retain_original_layer_identity": true,
+    "propagate_required_input_age": true,
+    "recheck_at_publication_receipt_and_use": true,
+    "clock_uncertainty_adds_to_age": true,
+    "unavailable_or_stale_required_layer": "no-go-advisory-only",
+    "history_can_independently_authorize_terrain": false,
+    "transport_streamstart_and_lease_fencing_required_separately": true
+  },
+  "input_contract": {
+    "schema_version": "missioncore.perception-stream-start/v1",
+    "channels": ["camera", "point-cloud", "pose"],
+    "camera": {
+      "width": 800,
+      "height": 600,
+      "projection": "KB4",
+      "decoded_pixel_format": "bgr8",
+      "calibration_sha256": "05f3ad9b38b3a4fc95388a8ec83da83c745e217709e51787b3d5aad0969f6fa9",
+      "valid_fov_sha256": "a40cee06b7c6f69b6a09a11563dcfd237f3de833b1ccd31459e66692e528ba63"
+    },
+    "point_cloud": {
+      "representation": "vendor-registered-current-increment",
+      "coordinate_frame": "map",
+      "units": "metres",
+      "scalar_type": "float32-little-endian",
+      "raw_fields_retained": true
+    },
+    "pose": {"parent_frame": "map", "child_frame": "sensor"},
+    "clock_mapping_required": true,
+    "source_end_or_duration_required": false,
+    "full_source_transfer_required": false,
+    "full_source_hash_pass_required": false,
+    "full_decode_or_png_cache_required": false,
+    "previous_perception_artifacts_allowed": false
+  },
+  "stream_policy": {
+    "replay_speed": 1.0,
+    "release_clock": "original-source-timestamps",
+    "inference_stride": 1,
+    "sampling_status": "strict-every-frame-initial-baseline-no-silent-multirate",
+    "first_result_requires_eof": false,
+    "lookahead_allowed": false,
+    "reconnect": "new-epoch-drop-old-backlog-reacquire-codec-keyframe",
+    "overflow": "bounded-drop-with-ledger-degraded-and-failed-runtime-gate",
+    "archive_export_on_critical_path": false,
+    "transport_candidate": "grpc-bidirectional-protobuf-binary-payloads",
+    "transport_qualified": false
+  },
+  "components": {
+    "segmentation": {
+      "model": "ddrnet_39-goose-fine-64",
+      "checkpoint_sha256": "b99c2838051bcd7b092fd3970aa62a77d5c0bbb809c9b9afb2ff4b0ebdaa4ee6",
+      "precision": "existing-fp32-baseline",
+      "preprocessing": "center-600-square-to-512-rgb-tensor-0-1",
+      "outside_crop": "undefined-not-free",
+      "class_count": 64,
+      "runtime": "python-3.9-pytorch-1.13.1-cu117-super-gradients-3.2.0"
+    },
+    "objects": {
+      "model": "rf_detr_large_native_kb4",
+      "checkpoint_sha256": "0f4e20e19a99c0f8a62b5685f57f6c8b5c371c59081feda6752a0561a79ccf38",
+      "engine_sha256": "b8a40b3580edff001ec9680de68707242294ff590ab296000fae371f1083f695",
+      "runtime": "tensorrt-11-fp16-native-uint8",
+      "minimum_score": 0.25,
+      "minimum_box_area_pixels": 64,
+      "maximum_box_area_fraction": 0.5,
+      "minimum_valid_fov_fraction": 0.5,
+      "require_center_inside_valid_fov": true,
+      "required_existing_classes": ["person", "cat", "dog"],
+      "fine_static_object_classifier_required": false,
+      "filter_quality_status": "existing-unchanged-near-large-and-small-object-risk-unqualified"
+    },
+    "geometry": {
+      "online_surface": "K1LocalSurfaceShadowEstimator",
+      "prepared_local_surface_allowed": false,
+      "generic_static_class": "static.unknown",
+      "detected_object_range": "median-camera-z-of-owned-current-points/v1",
+      "geometry_only_range": "nearest-euclidean-sensor-distance/v1",
+      "vehicle_clearance_claim": false,
+      "missing_support": "unavailable-not-zero-not-free"
+    },
+    "motion": {
+      "reuse": "BoundedSpatialTemporalProvider+ClassIndependentMotionEstimator",
+      "semantic_class_implies_motion": false
+    },
+    "costmap": {
+      "algorithm": "TRAVEL-TGS",
+      "revision": "95dc2fbd66a343efd9060c45a5711b6307a950a4",
+      "execution": "cpu",
+      "rolling_history_seconds": 1.0,
+      "states": ["UNOBSERVED", "GROUND_SUPPORT", "NONGROUND_OCCUPIED", "UNKNOWN_REJECTED"],
+      "policy_input": true
+    },
+    "policy": {
+      "scope": "rural-prototype-advisory-only",
+      "hard_surface": "ALLOW-candidate-subject-to-geometry-and-freshness",
+      "fine_road_sidewalk_bikeway_distinction_required": false,
+      "effective_material_rules_required": true,
+      "unknown_or_occupied_overrides_material_allowance": true,
+      "sensor_to_vehicle_mount": "simulation-only-until-measured"
+    }
+  },
+  "reference_files": [
+    {"path": "config/perception/rf-detr-large-native-kb4-risk-shadow-v0.json", "sha256": "dbf4da5dbad6c3c22b1280b46ffcad81719bd183c81c263a4859847d829019b6"},
+    {"path": "config/perception/lab-v1-goose-vegetation-benchmark-v1.json", "sha256": "96a427a8baae387b827ec9c0bf7ca42e3fb9114b8fa9a8671bbc9d10877670b9"},
+    {"path": "config/perception/lab-v1-vegetation-provider-label-map-v1.json", "sha256": "f2b69046b6a740fd9532d2d88e7fabae7c20fb662f783c9502adc9026406f352"},
+    {"path": "config/perception/lab-v1-vegetation-mission-policy-v1.json", "sha256": "b75c4ac841d7b4bcc57f7a9c8417ca2317d8ecfa499e72a9af8a8591a2ec0d35"},
+    {"path": "config/perception/m49-tgs-full-shadow-v1.json", "sha256": "c2e07010aaee78259d36c057962d6bfb885349251ff7356d867e5813e632881c"},
+    {"path": "config/perception/m4-geometry-association-v1.json", "sha256": "cc666c9389a5e221957faddec89584709b66918d14abaf646f1832e001421999"}
+  ],
+  "reference_usage": "reuse-model-parameters-and-algorithms-only-not-recording-ids-or-precomputed-results",
+  "realtime_contract": {
+    "schema_version": "missioncore.perception-realtime-contract/v1",
+    "budget_status": "engineering-targets-worker-pilot-measured-not-whole-path-qualified-not-safety-approved",
+    "budgets": {
+      "maximum_start_metadata_bytes": 65536,
+      "maximum_chunk_bytes": 1048576,
+      "maximum_inflight_bytes": 16777216,
+      "maximum_pending_camera_frames": 2,
+      "maximum_codec_preroll_ms": 500.0,
+      "maximum_pose_age_ms": 100.0,
+      "maximum_clock_uncertainty_ms": 5.0,
+      "maximum_release_lag_ms": 25.0,
+      "maximum_output_age_p95_ms": 125.0,
+      "maximum_output_age_p99_ms": 125.0,
+      "maximum_layer_age_ms": 250.0,
+      "maximum_first_result_ms": 1000.0,
+      "maximum_warmup_seconds": 120.0,
+      "maximum_stop_seconds": 5.0,
+      "maximum_vram_mib": 22000,
+      "maximum_rss_mib": 8192,
+      "maximum_backlog_growth_ms": 25.0
+    },
+    "budget_origin": "125ms-historical-envelope-retained-as-target-now-applied-to-whole-path; other-limits-explicit-initial-engineering-guards",
+    "capacity_drop_count_max": 0,
+    "unaccounted_input_count_max": 0,
+    "full_input_transfer_before_first_result_allowed": false,
+    "independent_quality_and_physical_live_status": "pending"
+  },
+  "authority": {
+    "commands_enabled": false,
+    "actuation_allowed": false,
+    "navigation_or_safety_accepted": false,
+    "production_accepted": false
+  }
+}
@@ -0,0 +1,162 @@
+{
+  "schema_version": "missioncore.lab-v1-eomt-ddrnet-portable-profile/v2",
+  "profile_id": "lab-v1-eomt-ddrnet-portable-v2",
+  "lab_id": "LAB-V1",
+  "worker_id": "worker-006",
+  "source_binding": {
+    "mode": "admitted-k1-recording",
+    "camera_source_id": "sensor.camera.right",
+    "camera_timeline": "dynamic",
+    "filesystem_paths": "executor-resolved",
+    "expected_width": 800,
+    "expected_height": 600,
+    "expected_frame_count": "source-derived",
+    "frame_indices": "source-derived-representative",
+    "crop_contract": "center-600-square-to-512; outside-crop-is-undefined"
+  },
+  "effective_config_contract": {
+    "schema_version": "missioncore.lab-v1-goose-vegetation-benchmark/v1",
+    "dynamic_field": "ravnoves",
+    "source_id": "sealed-source-derived",
+    "source_sha256": "sealed-camera-input-derived",
+    "base_m4_result_id": null
+  },
+  "runtime": {
+    "super_gradients_version": "3.2.0",
+    "super_gradients_revision": "54d062ecb1081944a672ce447cf3e96a36708ff9",
+    "python_version": "3.9",
+    "numpy_version": "1.23.0",
+    "cmake_version": "3.31.6",
+    "onnxsim_version": "0.4.36",
+    "opencv_python_version": "4.8.1.78",
+    "pytorch_version": "1.13.1",
+    "torchvision_version": "0.14.1",
+    "pytorch_cuda_version": "11.7",
+    "container_base": "nvidia/cuda:12.8.1-cudnn-devel-ubuntu22.04@sha256:ad6d59a3bbf3e82c1c849c9ac09cfc2a3e0bbb8655042fd899be6681b3fe2a85",
+    "miniconda_installer": "Miniconda3-py39_24.11.1-0-Linux-x86_64.sh",
+    "miniconda_installer_sha256": "3ea8373098d72140e08aac9217822b047ec094eb457e7f73945af7c6f68bf6f5"
+  },
+  "dataset": {
+    "dataset_id": "goose-2d-validation-visible-rgb",
+    "relative_root": "goose-2d/validation",
+    "mapping_relative_path": "goose_label_mapping.csv",
+    "mapping_sha256": "88ae319ba5a3877dd3ae0773f693a6a5fdc283934140de9dfaff029108aefd7f",
+    "image_glob": "images/val/**/*_windshield_vis.png",
+    "expected_pair_count": 962,
+    "input_size": [
+      512,
+      512
+    ],
+    "preprocessing": [
+      "center-square-crop",
+      "nearest-neighbor-resize",
+      "rgb-to-tensor-0-1"
+    ]
+  },
+  "candidates": {
+    "ddrnet": {
+      "candidate_id": "goose-ddrnet-class-512",
+      "model_names": [
+        "ddrnet_39"
+      ],
+      "checkpoint_relative_path": "models/goose/ddrnet_class_512.pth",
+      "checkpoint_size_bytes": 259419077,
+      "checkpoint_sha256": "b99c2838051bcd7b092fd3970aa62a77d5c0bbb809c9b9afb2ff4b0ebdaa4ee6",
+      "published_validation_miou_percent": 46.53
+    }
+  },
+  "vegetation_class_names": [
+    "leaves",
+    "forest",
+    "bush",
+    "moss",
+    "tree_crown",
+    "tree_trunk",
+    "crops",
+    "low_grass",
+    "high_grass",
+    "scenery_vegetation",
+    "hedge",
+    "tree_root"
+  ],
+  "visual_case_contract": {
+    "selection_basis": "ground-truth-class-support-only",
+    "case_count": 12,
+    "minimum_focus_pixels": 2048,
+    "strata": [
+      {
+        "class_name": "high_grass",
+        "count": 2
+      },
+      {
+        "class_name": "low_grass",
+        "count": 2
+      },
+      {
+        "class_name": "bush",
+        "count": 2
+      },
+      {
+        "class_name": "tree_trunk",
+        "count": 2
+      },
+      {
+        "class_name": "tree_crown",
+        "count": 1
+      },
+      {
+        "class_name": "hedge",
+        "count": 1
+      },
+      {
+        "class_name": "forest",
+        "count": 1
+      },
+      {
+        "class_name": "crops",
+        "count": 1
+      }
+    ],
+    "error_overlay": {
+      "correct_material_rgba": [
+        34,
+        197,
+        94,
+        72
+      ],
+      "missed_vegetation_rgba": [
+        239,
+        68,
+        68,
+        220
+      ],
+      "false_vegetation_rgba": [
+        245,
+        158,
+        11,
+        220
+      ],
+      "wrong_vegetation_material_rgba": [
+        168,
+        85,
+        247,
+        220
+      ]
+    }
+  },
+  "policy_action_colors": {
+    "ALLOW": "#22c55e",
+    "HIGH_COST": "#f59e0b",
+    "NO_GO": "#ef4444"
+  },
+  "invariants": {
+    "one_heavy_candidate_at_a_time": true,
+    "raw_fisheye_is_immutable": true,
+    "outside_center_crop_is_free": false,
+    "missing_or_unknown_is_free": false,
+    "camera_semantics_can_clear_rigid_geometry": false,
+    "navigation_authority": false,
+    "actuation_authority": false,
+    "canonical_triton_mutation_allowed": false
+  }
+}
@@ -0,0 +1,60 @@
+{
+  "schema_version": "missioncore.m49-tgs-portable-profile/v2",
+  "profile_id": "m49-tgs-portable-v2",
+  "source_binding": {
+    "mode": "admitted-k1-recording",
+    "camera_timeline": "dynamic",
+    "lidar_replay": "dynamic",
+    "trajectory": "dynamic",
+    "frame_counts": "source-derived",
+    "filesystem_paths": "executor-resolved"
+  },
+  "alignment": {
+    "timeline": "recorded-camera-host-arrival",
+    "lidar_selection": "latest-not-newer-than-camera-frame",
+    "maximum_lidar_age_seconds": 1.0,
+    "future_frames_allowed": false
+  },
+  "tgs": {
+    "max_range_m": 80.0,
+    "min_range_m": 1.0,
+    "resolution_m": 8.0,
+    "num_iterations": 3,
+    "num_lowest_representative_points": 5,
+    "minimum_points": 10,
+    "seed_threshold_m": 0.5,
+    "distance_threshold_m": 0.125,
+    "outlier_threshold_m": 0.3,
+    "normal_threshold": 0.94,
+    "weight_threshold": 200.0,
+    "lcc_normal_similarity": 0.03,
+    "lcc_planar_distance_m": 0.1,
+    "obstacle_height_m": 1.0,
+    "refine_mode": true
+  },
+  "rolling_profile": {
+    "history_seconds": 1.0,
+    "local_radius_m": 12.0,
+    "missing_lidar_policy": "all-cells-unobserved"
+  },
+  "costmap": {
+    "coordinate_frame": "map-gravity-local",
+    "cell_size_m": 0.45,
+    "radius_m": 12.0,
+    "state_priority": [
+      "NONGROUND_OCCUPIED",
+      "UNKNOWN_REJECTED",
+      "GROUND_SUPPORT",
+      "UNOBSERVED"
+    ]
+  },
+  "invariants": {
+    "aos_allowed": false,
+    "gpu_allowed": false,
+    "missing_support_means_free": false,
+    "missing_lidar_means_unobserved": true,
+    "unobserved_cells_are_emitted": true,
+    "camera_projection_is_authoritative": false,
+    "navigation_or_actuation_allowed": false
+  }
+}
@@ -20,10 +20,23 @@ The normalizer exposes a read-only normalized telemetry adapter on
 Timescale credentials, and Timescale is not published on a host port.
 The normalizer uses a separate `missioncore_normalizer` database role with only
 `SELECT`, `INSERT`, `UPDATE`, and bounded retention `DELETE` on the telemetry
-hypertable. Raw telemetry older than 30 days is removed at most once per day by the
-normalizer. This stays compatible with the Apache-licensed Timescale image without
+hypertable. Raw telemetry older than 30 days is removed in batches of at most
+1000 rows per minute, on a separate connection/thread (2s statement / 250ms lock
+deadline). Retention never runs inside the MQTT callback. This stays compatible
+with the Apache-licensed Timescale image without
 depending on the Timescale License retention scheduler.

+The 1 GiB database container explicitly sets 128 MiB shared buffers and 64 MiB
+maintenance memory. The HA image's automatic tuning sees the Docker VM instead
+of this container limit; do not inherit its multi-GiB defaults.
+
+For a memory-constrained local repair, `compose.source.yaml` mounts the reviewed
+normalizer source read-only into the **existing** image. Set
+`MISSIONCORE_NORMALIZER_SOURCE` to the absolute `normalizer.py` path, pass both
+Compose files and the existing private `--env-file` / `--project-directory`, and
+use `up -d --no-deps --no-build normalizer`. This is an explicit local source
+override, not a rebuilt portable image. Normal restart/reboot retains the mount.
+
 The stack is one deployment contour, not one multi-process container. Keeping broker,
 normalizer and database in separate containers preserves independent health checks,
 least-privilege boundaries and rollback while Compose provides one operator lifecycle:
@@ -136,6 +149,24 @@ globally unique because Mosquitto ACL ownership is username-based.

 ## Worker agent

+MQTT outputs use `startup_error_behavior="retry"`, with a 2000-metric buffer and
+the configured flush interval. A missing broker at agent startup must not end
+the service. See [Telegraf's startup policy](https://docs.influxdata.com/telegraf/v1/configuration/plugin-options/).
+If Docker lost a published listener while the saved LAN address is unchanged,
+the explicit broker Apply action reconciles that listener; a telemetry GET never
+restarts infrastructure. Node connectivity does not prove a profile is ready.
+
+The streaming profile can export one bounded (8 KiB) current observation using
+`--telemetry-snapshot /telemetry/current.json`, with `/telemetry` mounted to
+`C:\ProgramData\NDC\MissionCore\telemetry-agent\perception` on Worker. The existing
+collector reads it with a 5s freshness limit and forwards it over the same MQTT
+pipeline topic. It overrides the legacy service only when explicitly present;
+an expired/broken file reports unavailable rather than relabeling a legacy model.
+The publisher runs independently from heartbeat/inference and never renews a
+lease, grants GPU ownership, or qualifies real-time. Queue memory includes active
+input and decoder scratch. Stage timings are unavailable until actually measured.
+No camera, point cloud, model result, MQTT secret, or motor command goes here.
+
 Worker 006 uses the official Windows Telegraf distribution as the host service
 `NDC Mission Core Telemetry Agent`. Install or update it with:

@@ -0,0 +1,9 @@
+# Local, read-only source override for repairing the existing normalizer without
+# rebuilding an image on a memory-constrained operator machine. No extra service.
+services:
+  normalizer:
+    volumes:
+      - type: bind
+        source: ${MISSIONCORE_NORMALIZER_SOURCE:?Set the absolute normalizer.py path}
+        target: /app/normalizer.py
+        read_only: true
@@ -49,6 +49,8 @@ services:

  timescale:
    image: timescale/timescaledb-ha:pg16.14-ts2.28.2-all-oss
+    # The HA image auto-tunes for the Docker VM, not this 1 GiB container.
+    command: ["postgres", "-c", "shared_buffers=128MB", "-c", "work_mem=4MB", "-c", "maintenance_work_mem=64MB", "-c", "effective_cache_size=512MB", "-c", "max_parallel_workers_per_gather=0", "-c", "max_connections=32"]
    container_name: ndc-mission-core-telemetry-timescaledb
    restart: unless-stopped
    security_opt:
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
DCCONSTRUCTIONS	b2a1b23131	fix(observatory): preserve camera across follow transitions	2026-09-05 08:46:35 +03:00
DCCONSTRUCTIONS	cada687173	feat(observatory): ship modular AI inference labs	2026-09-04 17:59:05 +03:00
DCCONSTRUCTIONS	eff60e490a	docs(observatory): record saved replay evidence and open visual gates	2026-09-03 13:24:32 +03:00
DCCONSTRUCTIONS	9db29bcdc6	feat(observatory): share native result replay and expose saved TGS layers	2026-09-03 13:23:56 +03:00
DCCONSTRUCTIONS	27979854a7	feat(observatory): cache sealed camera and TGS replay on Core	2026-09-03 13:15:07 +03:00
DCCONSTRUCTIONS	3ea8d987a7	docs(observatory): record real M49 publication and restart acceptance	2026-09-03 11:50:32 +03:00
DCCONSTRUCTIONS	bd947b49f4	fix(observatory): preserve source identity on unchanged reindex	2026-09-03 11:43:03 +03:00
DCCONSTRUCTIONS	54c8d82884	ops(observatory): install exact recorded-progress agent layers	2026-09-03 11:22:03 +03:00
DCCONSTRUCTIONS	bee8552003	feat(observatory): expose attempt-bound recorded progress	2026-09-03 11:17:56 +03:00
DCCONSTRUCTIONS	4e0565eb4b	docs(observatory): refresh four-stage recorded-first roadmap	2026-09-03 10:35:48 +03:00
DCCONSTRUCTIONS	44afadb021	docs(observatory): record selector rules and local UI acceptance	2026-09-03 10:16:12 +03:00
DCCONSTRUCTIONS	e436fb56d4	fix(observatory): offer only uncalculated profiles without completion badges	2026-09-03 10:16:01 +03:00
DCCONSTRUCTIONS	c2710b55a7	docs(observatory): record cache activation and Docker memory recovery	2026-09-03 09:44:02 +03:00
DCCONSTRUCTIONS	d777f3198b	docs(observatory): record cache proof and pending activation	2026-09-03 09:15:12 +03:00
DCCONSTRUCTIONS	1e4ddc2cff	feat(observatory): verify exact published result reuse	2026-09-03 09:14:54 +03:00
DCCONSTRUCTIONS	80fc0058cb	docs(observatory): record claim-v3 repair and preserved queue history	2026-09-03 00:00:08 +03:00
DCCONSTRUCTIONS	43f1cdc862	fix(worker): preserve transport patch in Docker snapshot layers	2026-09-02 23:50:22 +03:00
DCCONSTRUCTIONS	0041e9fadb	fix(worker): bind claim migration to the imported transport module	2026-09-02 23:45:06 +03:00
DCCONSTRUCTIONS	cabd3081c7	fix(observatory): version non-binding idle claims and preserve grant history	2026-09-02 23:40:11 +03:00
DCCONSTRUCTIONS	049ed3eed4	docs(observatory): prioritize recorded laboratories and cached review before onboard profiles	2026-09-02 23:16:01 +03:00
DCCONSTRUCTIONS	35c1249631	fix(observatory): reject duplicate active portable computations atomically	2026-09-02 23:15:39 +03:00
DCCONSTRUCTIONS	941183d624	docs(perception): record TLS and direct TCP latency attribution	2026-09-02 22:40:08 +03:00
DCCONSTRUCTIONS	6af4c208ce	test(perception): localize transport tails with bounded TLS record witnesses	2026-09-02 22:34:12 +03:00
DCCONSTRUCTIONS	75a5320756	docs(perception): record clock route A/B/A and continuous LAN canary	2026-09-02 22:14:58 +03:00
DCCONSTRUCTIONS	59a74a3677	test(perception): add bounded clock-only route and scheduler diagnostics	2026-09-02 21:57:02 +03:00
DCCONSTRUCTIONS	35d28418f3	docs(perception): record joint startup proof and remaining clock wait	2026-09-02 21:16:03 +03:00
DCCONSTRUCTIONS	48835a0499	fix(perception): require joint clock readiness before source activation	2026-09-02 21:03:33 +03:00
DCCONSTRUCTIONS	93ae1edbb4	docs(perception): record cross-host canary failure and joint startup gate	2026-09-02 20:44:08 +03:00
DCCONSTRUCTIONS	093df8b38f	style(perception): format streaming lifecycle guards	2026-09-02 20:43:31 +03:00
DCCONSTRUCTIONS	35b6cd9e9e	feat(perception): gate cross-host graph with acknowledged source clocks	2026-09-02 20:37:21 +03:00
DCCONSTRUCTIONS	d80df61a7e	docs(perception): record cross-host clock and control proof	2026-09-02 19:46:27 +03:00
DCCONSTRUCTIONS	d7b8989e43	feat(perception): add scoped stream control and bounded clock observations	2026-09-02 19:41:43 +03:00
DCCONSTRUCTIONS	0cc6b96306	docs(perception): record full-graph network and recovery evidence	2026-09-02 19:05:13 +03:00
DCCONSTRUCTIONS	6469505c41	feat(perception): connect full graph to external streaming source and scene receiver	2026-09-02 19:04:41 +03:00
DCCONSTRUCTIONS	191612282b	test(perception): record cross-host gRPC recovery and backpressure proof	2026-09-02 18:14:51 +03:00
DCCONSTRUCTIONS	0310592ee3	feat(perception): add bounded authenticated gRPC stream transport	2026-09-02 18:11:42 +03:00
DCCONSTRUCTIONS	df0158e1ba	docs(perception): record Worker observability repair and remaining stream gates	2026-09-02 17:40:45 +03:00
DCCONSTRUCTIONS	2ef8c08bf2	feat(perception): export bounded runtime observations outside heartbeat lane	2026-09-02 17:35:46 +03:00
DCCONSTRUCTIONS	c570f7d938	fix(telemetry): restore worker agent delivery and truthful system status	2026-09-02 17:35:20 +03:00
DCCONSTRUCTIONS	03e8e71bea	docs(perception): record host telemetry recovery and scoped inventory evidence	2026-09-02 16:56:22 +03:00
DCCONSTRUCTIONS	61cbdb30a0	feat(perception): connect scoped host telemetry to recoverable profile lifecycle	2026-09-02 16:50:57 +03:00
DCCONSTRUCTIONS	e91721fe6a	docs(perception): record full graph recovery and separate availability latency	2026-09-02 16:01:36 +03:00
DCCONSTRUCTIONS	70927ea585	feat(perception): resume full graph on fresh input without restarting models	2026-09-02 15:54:13 +03:00
DCCONSTRUCTIONS	03a7e730ae	docs(perception): record recoverable input policy and decoder continuity proof	2026-09-02 15:33:53 +03:00
DCCONSTRUCTIONS	c31c46caa5	feat(perception): preserve resident runtime across recoverable input gaps	2026-09-02 15:27:06 +03:00
DCCONSTRUCTIONS	06a66a3da8	docs(perception): record controller readiness boundary and fault evidence	2026-09-02 14:54:43 +03:00
DCCONSTRUCTIONS	92625bf48b	feat(perception): gate streaming lifecycle on controller readiness	2026-09-02 14:49:36 +03:00
DCCONSTRUCTIONS	b8ba0cae1e	docs(perception): record exact parity and fixed-envelope IPC comparison	2026-09-02 14:28:58 +03:00
DCCONSTRUCTIONS	f39f1ff0b6	perf(perception): borrow contiguous image buffers for local IPC	2026-09-02 14:20:39 +03:00
DCCONSTRUCTIONS	380b6eaba7	fix(perception): preserve quaternion alignment across binary ingress	2026-09-02 14:20:38 +03:00
DCCONSTRUCTIONS	f6d73d8bfb	docs(perception): record binary full-graph evidence and remaining gates	2026-09-02 14:02:28 +03:00
DCCONSTRUCTIONS	221e429c0a	feat(perception): connect binary ingress to the supervised full graph	2026-09-02 13:53:25 +03:00
DCCONSTRUCTIONS	a85aed2e03	docs(perception): record decoder parity and remaining full-graph bridge	2026-09-02 13:14:11 +03:00
DCCONSTRUCTIONS	f102712f0b	test(perception): verify incremental decoder parity and binary ingress on Worker	2026-09-02 13:07:33 +03:00
DCCONSTRUCTIONS	350366bae0	refactor(perception): decode bounded fMP4 without source file dependencies	2026-09-02 13:07:33 +03:00
DCCONSTRUCTIONS	c23e86fd39	docs(perception): record bounded binary ingress evidence and remaining bridge	2026-09-02 12:37:25 +03:00
DCCONSTRUCTIONS	79ce55d197	test(perception): verify reuse of existing raw live ingress	2026-09-02 12:30:16 +03:00
DCCONSTRUCTIONS	a937400942	test(perception): seal source end marker before IPC shutdown	2026-09-02 12:28:23 +03:00
DCCONSTRUCTIONS	da60feff90	feat(perception): add bounded binary stream ingress	2026-09-02 12:21:25 +03:00
DCCONSTRUCTIONS	85349f42f9	docs(perception): record lifecycle ownership and expiry evidence	2026-09-02 12:05:00 +03:00
DCCONSTRUCTIONS	ac69e3b444	test(perception): exercise lifecycle and lease loss in full profile	2026-09-02 11:55:57 +03:00
DCCONSTRUCTIONS	6acf468b25	feat(perception): fence streaming lifecycle with worker-local ownership	2026-09-02 11:55:56 +03:00
DCCONSTRUCTIONS	d264cbce04	docs(perception): record stage-two scheduler and cell freshness proof	2026-09-02 11:03:26 +03:00
DCCONSTRUCTIONS	1f8101e4a5	feat(perception): expire costmap permissions per cell	2026-09-02 10:57:42 +03:00
DCCONSTRUCTIONS	bcacb02a22	refactor(perception): share bounded streaming scheduler	2026-09-02 10:57:41 +03:00
DCCONSTRUCTIONS	adcca7aa81	docs(perception): close stage-one baseline and record freshness proof	2026-09-02 10:21:44 +03:00
DCCONSTRUCTIONS	097e450a87	feat(perception): enforce six-layer freshness through receipt	2026-09-02 10:14:28 +03:00
DCCONSTRUCTIONS	4e633a662c	docs(perception): record gpu clock latency proof	2026-09-02 09:42:40 +03:00
DCCONSTRUCTIONS	c6c42c29e8	fix(perception): reject material ties and trace gpu pacing	2026-09-02 09:34:20 +03:00
DCCONSTRUCTIONS	ce09d30c1a	docs(perception): record latency and triton parity limits	2026-09-02 02:52:38 +03:00
DCCONSTRUCTIONS	34f13ba59e	feat(perception): add bounded triton runtime diagnostics	2026-09-02 02:52:11 +03:00
DCCONSTRUCTIONS	d9ea7c1129	perf(perception): reuse local surface cell observations	2026-09-02 02:03:09 +03:00
DCCONSTRUCTIONS	a3c67e249c	docs(perception): record rendezvous worker proof	2026-09-02 01:50:35 +03:00
DCCONSTRUCTIONS	294585936f	fix(perception): rendezvous completed gpu handoff	2026-09-02 01:48:25 +03:00
DCCONSTRUCTIONS	380a13688c	docs(perception): record preroll worker pilot	2026-09-02 01:40:06 +03:00
DCCONSTRUCTIONS	fd8313899b	fix(perception): separate preroll history from current sensor binding Preserve rolling points and original clocks; expose per-modality ages, held pose and rejection reasons. Saved-lineage audit changes only the first admission (75 to 76 of 128). No new model/performance claim. 384 focused Python and 62 frontend tests passed.	2026-09-02 01:09:03 +03:00
DCCONSTRUCTIONS	05c99efb68	test(observatory): isolate legacy contracts from installed package pins Freeze configuration-only legacy fixtures from `7025e17`, update current installed-image assertions, and explicitly reject the prior agent image. Production admission and digest validation are unchanged.	2026-09-02 01:02:38 +03:00
DCCONSTRUCTIONS	ffd6be5606	docs(observatory): record realtime plan and measured latency evidence	2026-09-02 00:59:48 +03:00
DCCONSTRUCTIONS	bfe6ef4c77	feat(perception): add bounded full-graph streaming and latency pilots	2026-09-02 00:59:48 +03:00
DCCONSTRUCTIONS	4e04d06191	feat(perception): define stream-first profile and qualification contracts	2026-09-02 00:59:47 +03:00
DCCONSTRUCTIONS	5a78c997ac	feat(observatory-ui): review portable results and retry publication Checkpoint the existing generic result-viewing and publication lifecycle UI. Focused architecture and Observatory tests: 62 passed; no new visual changes or rebuild in this checkpoint.	2026-09-02 00:59:21 +03:00
DCCONSTRUCTIONS	62d5520c7a	feat(worker): package independent installed LAB container steps Preserve local installer, offline validation and pinned component adapters; 62 focused packaging tests pass. No deployment performed by this commit.	2026-09-02 00:58:51 +03:00
DCCONSTRUCTIONS	a945d665dd	feat(observatory): add installed package dispatch and durable publication Checkpoint existing backend lifecycle changes. Focused verification found nine legacy fixture failures in portable LAB V1 executor/runtime tests; repair follows separately without rewriting this snapshot. ADR date retains its intentional Markdown hard break.	2026-09-02 00:58:37 +03:00
DCCONSTRUCTIONS	d655d6998d	feat(observatory): attest recording equipment and capture profiles	2026-09-02 00:57:27 +03:00
DCCONSTRUCTIONS	7025e173a3	fix(worker): accept omitted empty image command	2026-08-31 21:47:47 +03:00
DCCONSTRUCTIONS	10fe727561	fix(worker): preserve exec-form entrypoint	2026-08-31 21:45:51 +03:00
DCCONSTRUCTIONS	00ee5f163a	fix(worker): keep commit labels shell-safe	2026-08-31 21:42:31 +03:00
DCCONSTRUCTIONS	cbcc09afd6	fix(worker): mount generated shell scripts	2026-08-31 21:39:07 +03:00
DCCONSTRUCTIONS	e958729e9d	fix(worker): seal coordinator Python dependencies	2026-08-31 21:31:45 +03:00
DCCONSTRUCTIONS	0fcd037e4f	fix(worker): compose staged source paths safely	2026-08-31 21:01:30 +03:00
DCCONSTRUCTIONS	11a146011f	feat(worker): install combined observatory profiles	2026-08-31 20:56:29 +03:00
DCCONSTRUCTIONS	44ebbe7ca2	test(lab): import adapters in legacy runtimes	2026-08-31 20:04:31 +03:00
DCCONSTRUCTIONS	a3299dcfc3	fix(lab): avoid runtime typing on Python 3.9	2026-08-31 20:01:49 +03:00
DCCONSTRUCTIONS	2989fba99c	fix(lab): support legacy Python 3.9 adapters	2026-08-31 19:58:20 +03:00
DCCONSTRUCTIONS	142481f0d8	fix(lab): probe optional adapter image safely	2026-08-31 19:52:34 +03:00
DCCONSTRUCTIONS	b2ae29b8d8	feat(lab): install thin adapter layers offline	2026-08-31 19:51:51 +03:00
DCCONSTRUCTIONS	8eced6c34d	feat(worker): compose installed LAB V1 profile	2026-08-31 19:47:24 +03:00
DCCONSTRUCTIONS	732cc139fd	refactor(worker): externalize runtime registries	2026-08-31 19:47:07 +03:00
DCCONSTRUCTIONS	104e54f4dd	refactor(lab): separate release contract identity	2026-08-31 19:46:58 +03:00
DCCONSTRUCTIONS	7b021782d3	feat(lab): install sealed component adapters	2026-08-31 19:46:47 +03:00
DCCONSTRUCTIONS	759830b054	feat(lab): seal reusable EoMT runtime trees	2026-08-31 19:24:42 +03:00
DCCONSTRUCTIONS	19c0bd70d0	feat(lab): bind sealed component adapter images	2026-08-31 19:19:47 +03:00
DCCONSTRUCTIONS	35d99e40d5	perf(m49): verify source payloads during assembly	2026-08-31 19:06:59 +03:00
DCCONSTRUCTIONS	bfc1f1bbed	feat(worker): define unified agent image artifact	2026-08-31 19:00:06 +03:00
DCCONSTRUCTIONS	f41428f907	feat(lab): add sealed local component runners	2026-08-31 18:59:47 +03:00
DCCONSTRUCTIONS	3744d79ad3	feat(lab): seal reusable ffmpeg runtime asset	2026-08-31 18:59:37 +03:00
DCCONSTRUCTIONS	b57c3e94da	perf(m49): defer fresh stage revalidation	2026-08-31 18:42:31 +03:00
DCCONSTRUCTIONS	73a7d28065	perf(lidar): avoid duplicate replay decode during build	2026-08-31 18:35:12 +03:00
DCCONSTRUCTIONS	f64fbb1fa6	feat(worker): compose all ready observatory profiles	2026-08-31 18:31:54 +03:00
DCCONSTRUCTIONS	1ff527b264	perf(observatory): avoid duplicate camera verification	2026-08-31 18:25:09 +03:00
DCCONSTRUCTIONS	def8c71410	perf(observatory): bound source destination planning	2026-08-31 18:19:04 +03:00
DCCONSTRUCTIONS	7e59176581	fix(observatory): disable source artifact compression	2026-08-31 18:05:34 +03:00
DCCONSTRUCTIONS	4cd94b5805	perf(observatory): pack camera epoch source transfer	2026-08-31 17:59:18 +03:00
DCCONSTRUCTIONS	1766c0bdb2	feat(observatory): reconcile quarantined recorded jobs	2026-08-31 17:59:03 +03:00
DCCONSTRUCTIONS	56bfeaee7b	fix(observatory): admit camera archive metadata overhead	2026-08-31 17:19:45 +03:00
DCCONSTRUCTIONS	892d0085e3	refactor(worker): defer optional visualization imports	2026-08-31 17:15:13 +03:00
DCCONSTRUCTIONS	e2de8188ab	feat(observatory): bridge local M49 worker container	2026-08-31 16:58:03 +03:00
DCCONSTRUCTIONS	9c69d81296	feat(observatory): install local M49 worker path	2026-08-31 16:51:10 +03:00
DCCONSTRUCTIONS	2f6e45bc96	fix(observatory): validate M49 fixture filtering	2026-08-31 16:12:45 +03:00
DCCONSTRUCTIONS	8a1c578e0e	fix(observatory): admit committed M49 executor candidates	2026-08-31 16:06:23 +03:00
DCCONSTRUCTIONS	9beb534108	feat(observatory): add portable calculation profiles	2026-08-31 15:42:56 +03:00
DCCONSTRUCTIONS	d1b75efcea	fix(observatory): fence portable catalog refresh	2026-08-31 11:11:36 +03:00
DCCONSTRUCTIONS	c9302c78c2	feat(observatory): add portable LAB V1 foundation	2026-08-31 11:02:34 +03:00
DCCONSTRUCTIONS	d67e86176e	feat(observatory): add durable recorded compute queue	2026-08-31 01:04:25 +03:00
DCCONSTRUCTIONS	e72609120f	fix(observatory): align setup typography	2026-08-30 23:31:09 +03:00
DCCONSTRUCTIONS	177be8869f	feat(local-service): allow exact worktree migration	2026-08-30 23:23:36 +03:00
DCCONSTRUCTIONS	2a5763d3fb	feat(observatory): seal blocked run preparations	2026-08-30 23:14:05 +03:00
DCCONSTRUCTIONS	8d5aeb0533	feat(observatory): add laboratory setup preflight	2026-08-30 22:21:58 +03:00
DCCONSTRUCTIONS	be83283ee0	fix(observatory): refine catalog and replay UX	2026-08-30 20:36:12 +03:00
DCCONSTRUCTIONS	023151c186	feat(observatory): admit canonical recorded replay	2026-08-30 19:21:27 +03:00
DCCONSTRUCTIONS	e6a9846167	feat(observatory): add bounded M5.1 session review	2026-08-30 17:29:39 +03:00
DCCONSTRUCTIONS	81fdf6904a	refactor(lab): объединить RAV004 в единый Rerun replay	2026-08-30 16:40:12 +03:00
DCCONSTRUCTIONS	9c5259dbc9	fix(lab): запускать RAV004 с первого кадра	2026-08-30 14:33:17 +03:00
DCCONSTRUCTIONS	35daf73d5c	fix(lab): сжать и адресовать RAV004 overlay	2026-08-30 14:05:32 +03:00
DCCONSTRUCTIONS	07453142c2	fix(lab): стабилизировать нативный RAV004 replay	2026-08-30 13:28:33 +03:00
DCCONSTRUCTIONS	f5ee42751d	refactor(lab): перевести RAV004 на канонический Rerun pipeline	2026-08-30 12:59:16 +03:00
				`@@ -0,0 +1 @@`
				`export { CanonicalVegetationRerunReplay } from "../../components/laboratory/CanonicalVegetationRerunReplay";`