docs(node): reconcile release status and build provenance for 0.6.11

fix(sensors): align device lamp with identity and refresh to end
fix(node): show camera connectivity and remove company header marks
2026-09-06 01:39:02 +03:00 · 2026-09-06 01:18:47 +03:00 · 2026-09-06 01:05:19 +03:00 · 2026-09-06 00:44:23 +03:00 · 2026-09-06 00:24:48 +03:00 · 2026-09-05 23:25:11 +03:00
576 changed files with 145117 additions and 1351 deletions
@@ -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>
@@ -10,7 +10,6 @@ import {
  ControlRow,
  HeaderNavigation,
  HeaderProfile,
-  HeaderWorkspace,
  Icon,
  Inspector,
  RangeControl,
@@ -629,7 +628,10 @@ export default function App() {
    return () => window.clearTimeout(timer);
  }, [layoutSaveNotice]);

+  const [fleetCreateRequest, setFleetCreateRequest] = useState(0);
+  const onAddVehicle = useCallback(() => setFleetCreateRequest(value => value + 1), []);
  const contentActions = useApplicationPanelActions({
+    onAddVehicle,
    definition: activeDefinition,
    refreshRuntime: runtime.refresh,
    resetConnectionScenario: runtime.resetConnectionScenario,
@@ -645,8 +647,6 @@ export default function App() {
      brandHref="/"
      brandLabel="NODEDC MISSION CORE"
      center={
-        <>
-          <HeaderWorkspace kind="mark" label="Mission Core" imageUrl="/nodedc-mark.svg" />
          <HeaderNavigation
            label="Архитектурные блоки пункта управления"
            value={activeRoot ?? undefined}
@@ -656,7 +656,6 @@ export default function App() {
            }))}
            onChange={selectRoot}
          />
-        </>
      }
      right={
        <HeaderProfile>
@@ -802,10 +801,12 @@ export default function App() {
                    settleRecordedReplaySwitch(outcome)}
                  onDeleteBegin={releaseRecordedReplayForDelete}
                />
-              ) : activeDefinition.kind === "datasets" ? (
+              ) : activeDefinition.kind === "vehicles" ? null : activeDefinition.kind === "datasets" ? (
                <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}
@@ -826,6 +827,7 @@ export default function App() {
            ) : (
              <WorkspaceRenderer
                definition={activeDefinition}
+                fleetCreateRequest={fleetCreateRequest}
                state={activeRuntimeState}
                backendStatus={runtime.backendStatus}
                sourceUrl={effectiveSourceUrl}
@@ -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 {
@@ -138,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;
@@ -166,6 +184,13 @@ interface RecordedRerunIdentity {

 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$/;
@@ -230,8 +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)
-      || LAB_RECORDED_REPLAY_PATH.test(descriptor.sourceUrl)) ||
+    !isRecordedRrdSource(descriptor.sourceUrl) ||
    descriptor.viewerSourceUrl !== expectedViewerSourceUrl ||
    endpoint.origin !== base.origin ||
    endpoint.pathname !== descriptor.sourceUrl ||
@@ -262,7 +286,9 @@ export function resolveRecordedBlueprintUrl(
  if (explicitSourceUrl !== undefined) {
    const explicit = explicitSourceUrl.trim();
    if (
-      !LAB_RECORDED_REPLAY_PATH.test(normalized)
+      !(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}/`);
@@ -388,7 +414,13 @@ export async function fetchRecordedBlueprintRrd(
    followTrajectory = false,
    semanticLayer,
    unifiedPerception,
+    unifiedCameraShare = 0.46,
    planView = false,
+    cameraEye,
+    eyeRelativeToTracking = false,
+    currentTimeNs,
+    reactivateUpdates = false,
+    onCameraMaxOrbitalRadius,
    perceptionLayers = {
      enabled: false,
      detections2d: false,
@@ -405,7 +437,13 @@ export async function fetchRecordedBlueprintRrd(
    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;
  },
@@ -421,10 +459,8 @@ 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) ||
@@ -432,12 +468,28 @@ export async function fetchRecordedBlueprintRrd(
    ![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) ||
@@ -468,11 +520,27 @@ export async function fetchRecordedBlueprintRrd(
      view_reset_generation: viewResetGeneration,
      follow_trajectory: followTrajectory,
      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,
  });
@@ -496,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,
@@ -707,6 +800,7 @@ export function RerunViewport({
  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;
@@ -752,9 +846,9 @@ export function RerunViewport({
    : sourceUrl
      ? resolveRecordedPerceptionUrl(sourceUrl, window.location.origin)
      : null;
-  const recordedPointColorsUrl = sourceUrl
-    ? resolveRecordedPointColorsUrl(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,
@@ -791,8 +885,7 @@ export function RerunViewport({
      return;
    }

-    const isRecordedSource = RECORDED_RRD_PATH.test(normalizedSource)
-      || LAB_RECORDED_REPLAY_PATH.test(normalizedSource);
+    const isRecordedSource = isRecordedRrdSource(normalizedSource);
    let resolvedSource: string;
    try {
      if (isRecordedSource) {
@@ -827,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;
@@ -1073,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;
@@ -1080,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();
@@ -1146,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) {
@@ -1182,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 ||
@@ -1491,7 +1607,7 @@ export function RerunViewport({
          };
          await viewer.start(
            rerunViewerInitialSource(resolvedSource),
-            host,
+            mount,
            viewerOptions,
          );
          if (disposed) {
@@ -1509,7 +1625,36 @@ 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);
          }
@@ -1569,6 +1714,8 @@ export function RerunViewport({
      });

    return () => {
+      window.removeEventListener("pagehide", disposeActiveViewerLifecycle);
+      window.removeEventListener("pageshow", restoreAfterPageCache);
      if (activeViewerLifecycleRef.current === disposeActiveViewerLifecycle) {
        activeViewerLifecycleRef.current = null;
      }
@@ -1938,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 (
@@ -1946,29 +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,
-      semanticLayer: recordedSemanticLayer,
-      unifiedPerception: recordedUnifiedPerception,
-      planView: recordedPlanView,
-    }).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.
    });
@@ -1981,11 +2218,15 @@ export function RerunViewport({
    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}
+    />
+  );
+}
@@ -88,6 +88,9 @@ export function CanonicalRecordedLabReplay<
  mediaLayerControls,
  spatialLayerControls,
  spatialLeadingControl,
+  spatialTrailingControl,
+  mediaModeControlsVisible = true,
+  paneToolbarsAlwaysVisible = false,
  mediaMultiLayer = false,
  mediaContent,
  spatialContent,
@@ -116,10 +119,14 @@ 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;
-  /** One upstream Rerun viewer owns both panes and the shared playback clock. */
+  /** One upstream Rerun viewer owns both panes; this controlled split owns their shared geometry. */
  unifiedContent?: ReactNode;
  emptyMessage: string;
  deckOverlays?: ReactNode;
@@ -162,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}
@@ -181,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"
@@ -190,6 +197,7 @@ export function CanonicalRecordedLabReplay<
          <div className="m4-replay-threat-visual__spatial-toolbar-end">
            {spatialLayerControls}
            {spatialModeControls}
+            {spatialTrailingControl}
          </div>
        </div>
      ) : null}
@@ -216,7 +224,7 @@ export function CanonicalRecordedLabReplay<
        expanded={expanded}
        onModeChange={onMediaModeChange}
        onExpandedChange={onExpandedChange}
-        modeControlsVisible={!splitView}
+        modeControlsVisible={!splitView && !paneToolbarsAlwaysVisible}
        actions={actions}
        overlay={overlay}
        transport={transport}
@@ -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" />;
+}
@@ -53,7 +53,7 @@ export const LABORATORY_REPORT_TEMPLATE_VERSION =

 const EXECUTION_LABELS: Record<LaboratoryExecutionClass, string> = {
  deterministic: "Детерминированный",
-  "ai-inference": "AI inference",
+  "ai-inference": "AI Inference",
  hybrid: "Гибридный",
 };

@@ -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 };
@@ -5,6 +5,7 @@ import type { WorkspaceDefinition } from "../productModel";

 interface ApplicationPanelActionsOptions {
  definition: WorkspaceDefinition | null;
+  onAddVehicle?: () => void;
  refreshRuntime: () => void;
  resetConnectionScenario?: () => Promise<boolean>;
  connectionScenarioResetting: boolean;
@@ -43,6 +44,7 @@ export function deviceRuntimeUtilityAction({

 export function useApplicationPanelActions({
  definition,
+  onAddVehicle,
  refreshRuntime,
  resetConnectionScenario,
  connectionScenarioResetting,
@@ -52,6 +54,7 @@ export function useApplicationPanelActions({
 }: ApplicationPanelActionsOptions): ApplicationPanelUtilityAction[] {
  return useMemo(() => {
    const actions: ApplicationPanelUtilityAction[] = [];
+    if (definition?.kind === "vehicles" && onAddVehicle) actions.push({ label: "Добавить аппарат", icon: "plus", onClick: onAddVehicle });
    if (definition?.kind === "device") {
      actions.push(deviceRuntimeUtilityAction({
        refreshRuntime,
@@ -71,6 +74,7 @@ export function useApplicationPanelActions({
    return actions;
  }, [
    definition,
+    onAddVehicle,
    refreshRuntime,
    resetConnectionScenario,
    connectionScenarioResetting,
@@ -0,0 +1,61 @@
+import { useCallback, useEffect, useState } from "react";
+
+export interface BoardHost {
+  hostname: string; os: string; architecture: string; cpus: number;
+  memory_kib: number | null; collected_at: string;
+  networks: { name: string; up: boolean; addresses: string[] }[];
+  usb: { port: string; product: string }[];
+}
+export interface Vehicle {
+  id: string; node_id: string; name: string; platform: string;
+  enrollment: "pending" | "paired" | "revoked" | "failed";
+  connectivity: "online" | "offline"; last_seen: number | null;
+  host: BoardHost | null; notice: string; revision: number;
+}
+export interface FleetPreview {
+  preview_id: string; node_id: string; name: string; host: BoardHost;
+  endpoint: string; expires_at: number;
+}
+export async function fleetRequest<T>(path = "", method = "GET", body?: unknown): Promise<T> {
+  const response = await fetch(`/api/v1/fleet${path}`, {
+    method, credentials: "same-origin", cache: "no-store",
+    headers: body === undefined ? {} : { "Content-Type": "application/json" },
+    body: body === undefined ? undefined : JSON.stringify(body), signal: AbortSignal.timeout(12000),
+  });
+  if (!response.ok) {
+    const data = await response.json().catch(() => ({}));
+    throw new Error(typeof data.detail === "string" ? data.detail : "Не удалось выполнить действие с аппаратом.");
+  }
+  return response.json();
+}
+export function useFleet() {
+  const [items, setItems] = useState<Vehicle[] | null>(null);
+  const [error, setError] = useState("");
+  const refresh = useCallback(async () => {
+    const value = await fleetRequest<{ items: Vehicle[] }>();
+    setItems(value.items); setError(""); return value.items;
+  }, []);
+  useEffect(() => {
+    let active = true;
+    let fallback: ReturnType<typeof setInterval> | undefined;
+    const read = async () => {
+      try { const value = await fleetRequest<{ items: Vehicle[] }>(); if (active) { setItems(value.items); setError(""); } }
+      catch { if (active) setError("Реестр недоступен. Показаны последние полученные сведения; связь сейчас не подтверждена."); }
+    };
+    void read();
+    const events = new EventSource("/api/v1/fleet/events");
+    events.onmessage = event => {
+      if (!active) return;
+      try { const value = JSON.parse(event.data); setItems(value.items); setError(""); if (fallback) { clearInterval(fallback); fallback = undefined; } }
+      catch { unavailable(); }
+    };
+    const unavailable = () => {
+      if (!active) return;
+      setError("Связь обновляется. Показаны последние полученные сведения.");
+      if (!fallback) fallback = setInterval(() => void read(), 5000);
+    };
+    events.onerror = unavailable;
+    return () => { active = false; events.close(); if (fallback) clearInterval(fallback); };
+  }, []);
+  return { items, error, refresh };
+}
@@ -23,26 +23,34 @@ export async function resolveCanonicalLabReplay(
    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 (
-    !SAFE_RESULT_ID.test(resultId)
+    !(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 =
-    `/api/v1/laboratory/vegetation-shadow/${encodeURIComponent(resultId)}`
-    + "/canonical-replay.rrd";
+  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}/`);
-  descriptorUrl.searchParams.set("base_generation", launch.sha256);
+  if (sourceKind === "legacy-vegetation") descriptorUrl.searchParams.set("base_generation", launch.sha256);
  if (descriptorUrl.origin !== base.origin) {
    throw new Error("Канонический replay LAB должен быть same-origin.");
  }
@@ -74,3 +82,53 @@ export async function resolveCanonicalLabReplay(
    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"),
+  };
+}
@@ -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. */ });
+  };
+}
@@ -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 {
@@ -75,6 +77,8 @@ export interface RecordedSessionRerunProfile {
  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;
@@ -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,
+    },
+    "Не удалось удалить лабораторный результат из AI Inference.",
+  );
+  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(
+      "Выбранный результат не допущен к изменению каталога AI Inference.",
+    );
+  }
+  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
+    : "Каталог AI Inference недоступен.";
+}
+
+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",
@@ -16,6 +16,7 @@ export type WorkspaceKind =
  | "map"
  | "timeline"
  | "missions"
+  | "vehicles"
  | "catalog"
  | "contour-health"
  | "compute-modules"
@@ -23,7 +24,8 @@ export type WorkspaceKind =
  | "datasets"
  | "artifact-health"
  | "lab-archive"
-  | "simulations";
+  | "simulations"
+  | "observatory";

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

@@ -166,6 +168,17 @@ export const workspaces: WorkspaceDefinition[] = [
    kind: "simulations",
    groups: [],
  },
+  {
+    id: "observatory",
+    root: "polygon",
+    label: "AI Inference",
+    title: "AI Inference",
+    eyebrow: "ТЕСТОВЫЙ КОНТУР / AI INFERENCE",
+    description: "Сессии и квалификация без доступа к управлению.",
+    icon: "eye",
+    kind: "observatory",
+    groups: [],
+  },
  {
    id: "contour-health",
    root: "fleet",
@@ -181,23 +194,12 @@ export const workspaces: WorkspaceDefinition[] = [
    id: "vehicles",
    root: "fleet",
    label: "Аппараты",
-    title: "Реестр аппаратов",
+    title: "Аппараты",
    eyebrow: "ПАРК / РЕЕСТР",
-    description: "Нейтральный реестр наземных, воздушных и стационарных платформ.",
+    description: "Аппараты и их бортовые компьютеры в частном контуре.",
    icon: "apps",
-    kind: "catalog",
-    groups: [
-      {
-        title: "Идентичность аппарата",
-        description: "Никакой привязки продуктовой модели к конкретному производителю.",
-        capabilities: [
-          ready("Локальный стенд", "Первый аппарат представлен текущим устройством и его адаптером."),
-          contract("Паспорт борта", "Тип, серийный профиль, вычислитель, питание и транспорт."),
-          contract("Состояние доступности", "Онлайн, занят, обслуживание, потеря связи."),
-          later("Группы и рои", "Логические группы, роли и совместное назначение миссий."),
-        ],
-      },
-    ],
+    kind: "vehicles",
+    groups: [],
  },
  {
    id: "local-device",
@@ -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";
@@ -62,6 +62,43 @@
  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;
@@ -108,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"] {
@@ -138,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 > *,
@@ -152,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 {
@@ -212,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;
@@ -233,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;
 }
@@ -257,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,
@@ -282,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)
+    );
+  }
+}
@@ -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;
@@ -1,3 +1,4 @@
+import { VehiclesWorkspace } from "./fleet/VehiclesWorkspace";
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 import { Button, GlassSurface, Icon, StatusBadge } from "@nodedc/ui-react";
 import {
@@ -41,6 +42,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";
@@ -1166,6 +1168,8 @@ export function WorkspaceRenderer(props: WorkspaceRendererProps) {
      return <TimelineWorkspace {...props} />;
    case "missions":
      return <MissionWorkspace {...props} />;
+    case "vehicles":
+      return <VehiclesWorkspace createRequest={props.fleetCreateRequest} />;
    case "catalog":
      return <CatalogWorkspace {...props} />;
    case "contour-health":
@@ -1191,6 +1195,8 @@ export function WorkspaceRenderer(props: WorkspaceRendererProps) {
      );
    case "simulations":
      return <SimulationWorkspace />;
+    case "observatory":
+      return <ObservatoryWorkspace definition={props.definition} />;
    case "device":
      return null;
  }
@@ -35,6 +35,7 @@ export interface LaboratoryViewAction {
 }

 export interface WorkspaceRendererProps {
+  fleetCreateRequest?: number;
  definition: WorkspaceDefinition;
  state: MissionRuntimeState | null;
  backendStatus: BackendStatus;
@@ -0,0 +1,13 @@
+import {useMemo} from 'react';
+import {SensorWorkspace} from '../../../../../packages/sensor-ui/src/SensorWorkspace';
+import type {SensorInventory,SensorTransport} from '../../../../../packages/sensor-ui/src/contracts';
+import {fleetRequest} from '../../core/fleet/useFleet';
+export function VehicleSensors({vehicleID,enabled,onDetailChange}:{vehicleID:string;enabled:boolean;onDetailChange:(open:boolean)=>void}){
+ const transport=useMemo<SensorTransport>(()=>({
+  inventory:async()=>{const fleet=await fleetRequest<{items:{id:string;connectivity:string;sensor_state:SensorInventory}[]}>();const value=fleet.items.find(v=>v.id===vehicleID);if(!value)throw new Error('Аппарат не найден.');return {...value.sensor_state,fresh:value.connectivity==='online'};},
+  subscribe:(receive,unavailable)=>{const events=new EventSource('/api/v1/fleet/events');events.onmessage=e=>{try{const value=JSON.parse(e.data).items.find((v:{id:string})=>v.id===vehicleID);if(value)receive({...value.sensor_state,fresh:value.connectivity==='online'});else unavailable();}catch{unavailable();}};events.onerror=unavailable;return()=>events.close();},
+  submit:value=>fleetRequest(`/${encodeURIComponent(vehicleID)}/devices/operations`,'POST',value),
+  operation:id=>fleetRequest(`/${encodeURIComponent(vehicleID)}/devices/operations/${encodeURIComponent(id)}`),
+ }),[vehicleID]);
+ return <SensorWorkspace key={vehicleID} transport={transport} enabled={enabled} onDetailChange={onDetailChange}/>;
+}
@@ -0,0 +1,69 @@
+import { useEffect, useRef, useState } from "react";
+import { ActivityIndicator, Button, ConfirmationModal, Icon, IconButton, ResourceList, ResourceRow, Select, SettingsCard, StatusBadge, TextAreaField, TextField, Window, WindowFooterActions } from "@nodedc/ui-react";
+import { fleetRequest, useFleet, type FleetPreview, type Vehicle } from "../../core/fleet/useFleet";
+import "./fleet.css";
+import { VehicleSensors } from "./VehicleSensors";
+
+const platforms = [{ value: "ugv", label: "Наземный (UGV)" }, { value: "uav", label: "Воздушный (UAV)" }, { value: "stationary", label: "Стационарный" }, { value: "other", label: "Другой" }];
+const platformLabel = (value: string) => platforms.find(item => item.value === value)?.label ?? value;
+function statusLabel(item: Vehicle) { return item.enrollment === "pending" ? "Подтверждаем привязку" : item.enrollment === "revoked" ? "Доверие отозвано" : item.enrollment === "failed" ? "Привязка не завершена" : item.connectivity === "online" ? "В сети" : "Нет связи"; }
+
+export function VehiclesWorkspace({ createRequest = 0 }: { createRequest?: number }) {
+  const fleet = useFleet();
+  const [adding, setAdding] = useState(false);
+  const [code, setCode] = useState("");
+  const [name, setName] = useState("");
+  const [platform, setPlatform] = useState("ugv");
+  const [preview, setPreview] = useState<FleetPreview | null>(null);
+  const [pending, setPending] = useState(false);
+  const [error, setError] = useState("");
+  const [selected, setSelected] = useState<string | null>(null);
+  const [sensorOpen, setSensorOpen] = useState(false);
+  const [revoking, setRevoking] = useState<Vehicle | null>(null);
+  const lastCreateRequest = useRef(createRequest);
+  useEffect(() => { if (createRequest !== lastCreateRequest.current) { lastCreateRequest.current = createRequest; setAdding(true); setError(""); } }, [createRequest]);
+  function close() { if (pending) return; setAdding(false); setPreview(null); setCode(""); setName(""); setError(""); }
+  async function inspect(event: React.FormEvent) {
+    event.preventDefault(); if (pending) return;
+    setPending(true); setError("");
+    try { const value = await fleetRequest<FleetPreview>("/preview", "POST", { code: code.trim() }); setPreview(value); setName(current => current || value.name); setCode(""); }
+    catch (error) { setError(error instanceof Error ? error.message : "Не удалось проверить приглашение."); }
+    finally { setPending(false); }
+  }
+  async function add() {
+    if (!preview || pending) return;
+    setPending(true); setError("");
+    try {
+      const item = await fleetRequest<Vehicle>("", "POST", { preview_id: preview.preview_id, name: name.trim(), platform });
+      await fleet.refresh(); setSelected(item.id); setAdding(false); setPreview(null); setCode(""); setName("");
+    } catch (error) { setError(error instanceof Error ? error.message : "Не удалось добавить аппарат."); void fleet.refresh().catch(() => undefined); }
+    finally { setPending(false); }
+  }
+  const detail = fleet.items?.find(item => item.id === selected);
+  return <div className="fleet-workspace">
+    {fleet.error && <p role="alert">{fleet.error}</p>}
+    {!adding && error && <p role="alert">{error}</p>}
+    {detail ? <>
+      <div><Button onClick={() => {setSelected(null);setSensorOpen(false);}}>К списку аппаратов</Button></div>
+      {!sensorOpen && <SettingsCard title={detail.name} description={`${platformLabel(detail.platform)} · с бортовым компьютером`} actions={<StatusBadge tone={!fleet.error && detail.enrollment === "paired" && detail.connectivity === "online" ? "success" : "neutral"}>{fleet.error ? "Нет свежих данных" : statusLabel(detail)}</StatusBadge>}>
+        {detail.notice && <p role="status">{detail.notice}</p>}
+        <dl className="fleet-facts"><div><dt>Бортовой компьютер</dt><dd>{detail.node_id}</dd></div>
+          <div><dt>Последняя связь</dt><dd>{detail.last_seen ? new Date(detail.last_seen * 1000).toLocaleString("ru-RU") : "Соединение ещё не получено"}</dd></div>
+          {detail.host && <><div><dt>Имя БК в системе</dt><dd>{detail.host.hostname}</dd></div><div><dt>Операционная система</dt><dd>{detail.host.os}</dd></div><div><dt>Архитектура</dt><dd>{detail.host.architecture}</dd></div><div><dt>Процессоры</dt><dd>{detail.host.cpus}</dd></div><div><dt>Память</dt><dd>{detail.host.memory_kib ? `${(detail.host.memory_kib / 1024 / 1024).toFixed(1)} ГиБ` : "Нет сведений"}</dd></div></>}
+        </dl>
+        {detail.enrollment !== "revoked" && <Button onClick={() => setRevoking(detail)}>Отозвать привязку БК</Button>}
+      </SettingsCard>}
+      <SettingsCard title="Устройства аппарата"><VehicleSensors onDetailChange={setSensorOpen} vehicleID={detail.id} enabled={!fleet.error && detail.enrollment === "paired" && detail.connectivity === "online"} /></SettingsCard>
+    </> : !fleet.items ? <ActivityIndicator label="Получаем аппараты" /> : fleet.items.length === 0 ? <SettingsCard title="Аппаратов пока нет" description="Добавьте аппарат по приглашению из Mission Core Node на его бортовом компьютере."><Button onClick={() => setAdding(true)}>Добавить аппарат</Button></SettingsCard> : <ResourceList aria-label="Аппараты">{fleet.items.map(item => <li key={item.id}><ResourceRow icon={<Icon name="apps" />} title={item.name} description={`${platformLabel(item.platform)} · бортовой компьютер`} status={<StatusBadge tone={!fleet.error && item.enrollment === "paired" && item.connectivity === "online" ? "success" : "neutral"}>{fleet.error ? "Нет свежих данных" : statusLabel(item)}</StatusBadge>} actions={<IconButton label={`Конфигурация: ${item.name}`} onClick={() => setSelected(item.id)}><Icon name="eye" /></IconButton>} /></li>)}</ResourceList>}
+    <Window open={adding} title="Добавить аппарат" subtitle="Подключить бортовой компьютер по приглашению Node" size="md" closeOnBackdrop={false} closeOnEscape={!pending} onClose={close} footer={<WindowFooterActions><Button disabled={pending} onClick={close}>Отмена</Button>{preview ? <Button disabled={pending || !name.trim()} onClick={() => void add()}>{pending ? "Добавляем…" : "Добавить аппарат"}</Button> : <Button type="submit" form="fleet-invitation" disabled={pending || !code.trim()}>{pending ? "Проверяем БК…" : "Проверить БК"}</Button>}</WindowFooterActions>}>
+      <form id="fleet-invitation" className="fleet-form" onSubmit={inspect} aria-busy={pending}>
+        <Select label="Способ подключения" value="node" options={[{ value: "node", label: "С бортовым компьютером" }]} onChange={() => undefined} disabled={pending} />
+        <Select label="Класс аппарата" value={platform} options={platforms} onChange={setPlatform} disabled={pending} />
+        <TextField label="Название аппарата" value={name} maxLength={80} onChange={event => setName(event.target.value)} disabled={pending} autoComplete="off" />
+        {preview ? <SettingsCard title={preview.name} description="Идентичность БК проверена по приглашению"><dl className="fleet-facts"><div><dt>Идентификатор БК</dt><dd>{preview.node_id}</dd></div><div><dt>Система</dt><dd>{preview.host.os} · {preview.host.architecture}</dd></div><div><dt>Адрес БК</dt><dd>{preview.endpoint}</dd></div></dl><Button disabled={pending} onClick={() => setPreview(null)}>Другое приглашение</Button></SettingsCard> : <TextAreaField label="Код приглашения из Node" value={code} rows={5} maxLength={4096} spellCheck={false} autoComplete="off" disabled={pending} onChange={event => setCode(event.target.value)} />}
+        {error && <p role="alert">{error}</p>}
+      </form>
+    </Window>
+    <ConfirmationModal open={revoking !== null} title="Отозвать привязку БК?" description={`Аппарат «${revoking?.name ?? ""}» останется в реестре, а его БК потеряет доступ к Core. БК получит отзыв при следующем соединении.`} confirmLabel="Отозвать" cancelLabel="Отмена" danger onClose={() => setRevoking(null)} onConfirm={async () => { if (!revoking) return; try { await fleetRequest(`/${encodeURIComponent(revoking.id)}`, "DELETE"); await fleet.refresh(); setRevoking(null); } catch (error) { setError(error instanceof Error ? error.message : "Не удалось отозвать привязку."); throw error; } }} />
+  </div>;
+}
@@ -0,0 +1,9 @@
+.fleet-workspace, .fleet-form { display: flex; flex-direction: column; gap: var(--nodedc-space-4); }
+.fleet-workspace { padding: var(--nodedc-space-4); }
+.fleet-facts { display: grid; gap: var(--nodedc-space-3); }
+.fleet-facts > div { display: grid; grid-template-columns: minmax(120px, 1fr) minmax(0, 2fr); gap: var(--nodedc-space-3); }
+.fleet-facts dd { margin: 0; overflow-wrap: anywhere; }
+
+.fleet-facts { font-size: var(--nodedc-font-size-sm); line-height: 1.5; }
+.fleet-facts dt { color: var(--nodedc-text-secondary); }
+.fleet-facts dd { color: var(--nodedc-text-muted); }
@@ -1,249 +1 @@
-import { useEffect, useMemo, useState } from "react";
-import { Button, Icon, SegmentedControl } from "@nodedc/ui-react";
-
-import { ObservationTimeline } from "../../components/ObservationTimeline";
-import {
-  RerunViewport,
-  type RerunPlaybackController,
-  type RerunPlaybackState,
-} from "../../components/RerunViewport";
-import {
-  CanonicalRecordedLabReplay,
-  useCanonicalRecordedLabReplayState,
-} from "../../components/laboratory/CanonicalRecordedLabReplay";
-import {
-  resolveCanonicalLabReplay,
-  type CanonicalLabReplayDescriptor,
-} from "../../core/laboratory/canonicalLabReplay";
-import type { VegetationFullRouteReview } from "../../core/laboratory/vegetationShadow";
-import type { ObservationSessionReplayLaunch } from "../../core/observation/sessionArchive";
-import { recordedSessionRerunProfile } from "../../core/observation/viewerProfile";
-import { resolveObservationSessionReplay } from "../../core/observation/useObservationSessions";
-import { defaultSceneSettings } from "../../sceneSettings";
-
-type MediaMode = "video" | "camera";
-type SpatialMode = "3d" | "plan";
-type SpatialLayer = "source" | "local" | "tgs" | "semantic";
-type SemanticLayer = "city" | "vegetation";
-
-interface CanonicalReplayLaunch {
-  base: ObservationSessionReplayLaunch;
-  replay: CanonicalLabReplayDescriptor;
-}
-
-export function CanonicalVegetationRerunReplay({
-  resultId,
-  review,
-}: {
-  resultId: string;
-  review: VegetationFullRouteReview;
-}) {
-  const {
-    mediaMode,
-    spatialMode,
-    splitPrimarySize,
-    splitOrientation,
-    expanded,
-    onMediaModeChange,
-    onSpatialModeChange,
-    onSplitPrimarySizeChange,
-    onExpandedChange,
-  } = useCanonicalRecordedLabReplayState<MediaMode, SpatialMode>({
-    initialMediaMode: "video",
-    initialSpatialMode: "3d",
-  });
-  const [semanticLayer, setSemanticLayer] = useState<SemanticLayer>("vegetation");
-  const [showSemantics, setShowSemantics] = useState(true);
-  const [spatialLayer, setSpatialLayer] = useState<SpatialLayer>("source");
-  const [viewResetGeneration, setViewResetGeneration] = useState<0 | 1>(0);
-  const [playback, setPlayback] = useState<RerunPlaybackState | null>(null);
-  const [playbackController, setPlaybackController] =
-    useState<RerunPlaybackController | null>(null);
-  const [launch, setLaunch] = useState<CanonicalReplayLaunch | null>(null);
-  const [launchError, setLaunchError] = useState<string | null>(null);
-
-  useEffect(() => {
-    const controller = new AbortController();
-    setLaunch(null);
-    setLaunchError(null);
-    void resolveObservationSessionReplay(review.sessionId, {
-      signal: controller.signal,
-      maximumWaitMs: 30 * 60 * 1000,
-      onUpdate: () => undefined,
-    }).then(async (value) => ({
-      base: value,
-      replay: await resolveCanonicalLabReplay(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 : "Каноническая запись RAV004 недоступна.",
-        );
-      }
-    });
-    return () => controller.abort();
-  }, [resultId, review.sessionId]);
-
-  const splitView = mediaMode !== null && spatialMode !== null;
-  const sceneSettings = useMemo(() => ({
-    ...defaultSceneSettings,
-    accumulationSeconds: spatialLayer === "local" ? 5 : 0,
-    showPoints: spatialMode !== null,
-    showTrajectory: spatialMode !== null,
-    showGrid: spatialMode !== null,
-    pointSize: 3.8,
-  }), [spatialLayer, spatialMode]);
-  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: review.timelineStartSeconds,
-    view: mediaMode !== null ? "perception" : "spatial",
-    viewResetGeneration,
-    followTrajectory: true,
-    semanticLayer,
-    unifiedPerception: splitView,
-    planView: spatialMode === "plan",
-    perceptionLayers: {
-      enabled: mediaMode !== null,
-      detections2d: mediaMode === "video",
-      segmentation: mediaMode === "video" && showSemantics,
-      cuboids3d: false,
-    },
-    perceptionRetryGeneration: 0,
-    lockPerceptionCameraInteraction: false,
-  }) : null;
-
-  const mediaLayerControls = (
-    <div
-      className="m4-replay-threat-visual__pane-layer-controls"
-      role="group"
-      aria-label="Слои камеры и видео"
-    >
-      <Button
-        size="dense"
-        shape="pill"
-        variant={showSemantics ? "primary" : "secondary"}
-        aria-pressed={showSemantics}
-        onClick={() => setShowSemantics((visible) => !visible)}
-      >
-        СЕМАНТИКА
-      </Button>
-      <SegmentedControl
-        value={semanticLayer}
-        items={[
-          { value: "city", label: "ГОРОД · EoMT" },
-          { value: "vegetation", label: "ПРИРОДА · DDRNet" },
-        ]}
-        label="Источник семантики"
-        size="dense"
-        onChange={(value) => {
-          setSemanticLayer(value);
-          setShowSemantics(true);
-        }}
-      />
-    </div>
-  );
-  const spatialLayerControls = (
-    <div
-      className="m4-replay-threat-visual__pane-layer-controls"
-      role="group"
-      aria-label="Пространственные слои RAV004"
-    >
-      <SegmentedControl
-        value={spatialLayer}
-        items={[
-          { value: "source", label: "ИСХ. ТОЧКИ" },
-          { value: "local", label: "ЛОК. SLAM" },
-          { value: "tgs", label: "TGS", disabled: true },
-          { value: "semantic", label: "СЕМАНТИКА", disabled: true },
-        ]}
-        label="Пространственные слои"
-        size="dense"
-        onChange={setSpatialLayer}
-      />
-    </div>
-  );
-  const resetSpatialView = (
-    <Button
-      size="dense"
-      variant="ghost"
-      icon={<Icon name="refresh" size={14} />}
-      aria-label="Сбросить положение 3D камеры"
-      title="Сбросить положение 3D камеры"
-      onClick={() => setViewResetGeneration((value) => value === 0 ? 1 : 0)}
-    >
-    </Button>
-  );
-
-  const transport = playback && playbackController ? (
-    <ObservationTimeline
-      className="m4-replay-threat-visual__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 (
-    <CanonicalRecordedLabReplay
-      label="RAVNOVES004TREE · канонический повтор Rerun"
-      mediaMode={mediaMode ?? "none"}
-      mediaModes={[
-        { value: "video", label: "ВИДЕО" },
-        { value: "camera", label: "КАМЕРА" },
-      ]}
-      spatialMode={spatialMode ?? "none"}
-      spatialModes={[
-        { value: "3d", label: "3D" },
-        { value: "plan", label: "ПЛАН" },
-      ]}
-      expanded={expanded}
-      splitPrimarySize={splitPrimarySize}
-      splitOrientation={splitOrientation}
-      mediaAriaLabel={mediaMode === "camera" ? "Камера" : "Видео и семантика"}
-      spatialAriaLabel={spatialMode === "plan" ? "Вид сверху" : "Трёхмерная сцена"}
-      mediaLayerControls={mediaLayerControls}
-      spatialLayerControls={spatialLayerControls}
-      spatialLeadingControl={resetSpatialView}
-      mediaMultiLayer
-      unifiedContent={profile ? (
-        <RerunViewport
-          profile={profile}
-          sceneSettings={sceneSettings}
-          onPlaybackChange={setPlayback}
-          onPlaybackControllerChange={setPlaybackController}
-        />
-      ) : (
-        <div className="l3-visual-audit__state" role={launchError ? "alert" : "status"}>
-          {launchError ?? "Готовим единый кэш канонического повтора RAV004…"}
-        </div>
-      )}
-      emptyMessage="Выберите ВИДЕО/КАМЕРА или 3D/ПЛАН. Общие часы Rerun останутся на месте."
-      transport={transport}
-      onMediaModeChange={onMediaModeChange}
-      onSpatialModeChange={onSpatialModeChange}
-      onExpandedChange={onExpandedChange}
-      onSplitPrimarySizeChange={onSplitPrimarySizeChange}
-    />
-  );
-}
+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)
    )),
@@ -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",
@@ -104,3 +104,53 @@ test("laboratory UI is a bounded feature slice, not a central workspace branch",
  assert.doesNotMatch(laboratoryCss, /\.e30-human-review/);
  assert.match(e30HumanReviewCss, /\.e30-human-review/);
 });
+
+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");
+
+  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/);
+});
@@ -132,3 +132,32 @@ test("canonical LAB resolves one generation-bound merged RRD", async () => {
    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,6 +40,7 @@ let formatAccumulationDuration;
 let resolveRerunSourceUrl;
 let resolveRecordedBlueprintUrl;
 let fetchRecordedBlueprintRrd;
+let recordedCameraJournalContract;
 let resolveRecordedPerceptionUrl;
 let fetchRecordedPerceptionRrd;
 let resolveRecordedPerceptionViewerSourceUrl;
@@ -110,6 +111,7 @@ before(async () => {
    resolveRerunSourceUrl,
    resolveRecordedBlueprintUrl,
    fetchRecordedBlueprintRrd,
+    recordedCameraJournalContract,
    resolveRecordedPerceptionUrl,
    fetchRecordedPerceptionRrd,
    resolveRecordedPerceptionViewerSourceUrl,
@@ -118,7 +120,7 @@ before(async () => {
    fetchRecordedPointColorsRrd,
    recordedPointColorKey,
    isRecordedPlaybackFullyBuffered,
-  } = await server.ssrLoadModule(
+} = await server.ssrLoadModule(
    "/src/components/RerunViewport.tsx",
  ));
  ({ recordedObservationSources } = await server.ssrLoadModule(
@@ -129,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);
@@ -444,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",
@@ -464,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,
@@ -474,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",
+          },
        });
      },
    },
@@ -497,13 +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",
@@ -537,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(
@@ -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: "Проекция не принадлежит AI Inference." }, { status: 409 }),
+    }),
+    (error) => error instanceof ObservatoryCatalogMutationError
+      && error.status === 409
+      && error.message === "Проекция не принадлежит AI Inference.",
+  );
+});
@@ -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: "AI Inference",
+      title: "AI Inference",
+      eyebrow: "ТЕСТОВЫЙ КОНТУР / AI INFERENCE",
+      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="Удалить результат из AI Inference\?"/);
+  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/);
+});
@@ -14,6 +14,8 @@ let liveRerunReceiverBindingIdentity;
 let recordedOpenWatchdogTimeoutMs;
 let rerunViewerInitialSource;
 let resolveRecordedViewerSourceUrl;
+let isRecordedRrdSource;
+let resolveRecordedBlueprintUrl;

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

@@ -86,6 +90,25 @@ test("one canonical LAB replay generation reaches the same native receiver", ()
  );
 });

+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", () => {
  assert.equal(isLiveRerunPresentationReady(false, { min: 1, max: 2 }, 1), false);
  assert.equal(isLiveRerunPresentationReady(true, null, 1), false);
@@ -225,6 +248,9 @@ 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.doesNotMatch(source, /rerunViewerOpenOptions/);
  assert.match(
@@ -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\}/);
 });

@@ -0,0 +1,24 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {readFileSync} from 'node:fs';
+import ts from 'typescript';
+
+const source=readFileSync(new URL('../../../packages/sensor-ui/src/sensorStatus.ts',import.meta.url),'utf8');
+const code=ts.transpileModule(source,{compilerOptions:{module:ts.ModuleKind.ESNext}}).outputText;
+const {sensorStatus}=await import('data:text/javascript;base64,'+Buffer.from(code).toString('base64'));
+const connected={online:true,configured:true,prepared:true,verified:false,snapshot:{acquisition:'idle',enrollment:'enrolled'}};
+
+test('a configured, reconnected camera is connected before another frame verification',()=>{
+ assert.deepEqual(sensorStatus(connected,true),{label:'Подключено',tone:'success'});
+});
+test('stale board data cannot assert camera connectivity',()=>{
+ assert.equal(sensorStatus(connected,false).tone,'neutral');
+ assert.equal(sensorStatus({...connected,online:false},true).label,'Не подключено');
+});
+test('a capture failure or unavailable driver is not shown as healthy',()=>{
+ assert.equal(sensorStatus({...connected,snapshot:{acquisition:'failed'}},true).tone,'danger');
+ assert.equal(sensorStatus({...connected,prepared:false},true).tone,'warning');
+});
+test('an unconfigured camera still requires preparation',()=>{
+ assert.deepEqual(sensorStatus({...connected,configured:false},true),{label:'Требуется подготовка',tone:'neutral'});
+});
@@ -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/);
@@ -452,7 +452,7 @@ test("canonical recorded LAB spatial frame keeps source, SLAM and body identity
 });

 test("vegetation realtime LAB uses one upstream Rerun clock and keeps archival review separate", async () => {
-  const [resultSource, benchmarkSource, m49Source, canonicalSource, rerunSource] = await Promise.all([
+  const [resultSource, benchmarkSource, m49Source, canonicalSource, rerunSource, replayStyles] = await Promise.all([
    readFile(
      new URL("../src/workspaces/laboratory/VegetationShadowResult.tsx", import.meta.url),
      "utf8",
@@ -470,7 +470,11 @@ test("vegetation realtime LAB uses one upstream Rerun clock and keeps archival r
      "utf8",
    ),
    readFile(
-      new URL("../src/workspaces/laboratory/CanonicalVegetationRerunReplay.tsx", import.meta.url),
+      new URL("../src/components/laboratory/CanonicalResultRerunReplay.tsx", import.meta.url),
+      "utf8",
+    ),
+    readFile(
+      new URL("../src/styles/m4-replay-threat.css", import.meta.url),
      "utf8",
    ),
  ]);
@@ -490,16 +494,40 @@ test("vegetation realtime LAB uses one upstream Rerun clock and keeps archival r
  assert.match(rerunSource, /<RerunViewport/);
  assert.match(rerunSource, /ИСХ\. ТОЧКИ/);
  assert.match(rerunSource, /ЛОК\. SLAM/);
-  assert.match(rerunSource, /resolveCanonicalLabReplay/);
+  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(rerunSource, /value: "tgs", label: "TGS", disabled: true/);
+  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="Изменить размер видео\/камеры и 3D\/плана"/);
+  assert.match(canonicalSource, /resizable=\{splitView\}/);
  assert.match(resultSource, /linked canonical M4\.9 TGS evidence/);
  assert.match(resultSource, /linkedTgsResultId/);
  assert.match(benchmarkSource, /M48MaskComparisonVisual/);
@@ -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,4 @@
+/build/
+/ui/node_modules/
+/ui/dist/
+/web/dist/
@@ -0,0 +1,222 @@
+# Mission Core Node — onboard configuration and sensors
+
+## Current candidate: 0.6.11
+
+The installed candidate on the qualification Mini is 0.6.11. It contains the
+native GTK/WebKit application, seven-step environment configuration, host and
+USB/network inventory, trusted SSH key management, Tailscale access, explicit
+Node/Core pairing, and the first RealSense D455 sensor workflow. Supported host:
+Ubuntu 24.04 LTS Desktop amd64. This is an early candidate, not a completed or
+fully hardware-qualified Node v1.
+
+The shared Node/Core sensor UI supports preparation, naming, profiles/options,
+live RGB/depth/IR/points/motion, and capture/recording commands owned by the
+board. After initial preparation, the device row keeps one connectivity lamp,
+settings and viewer actions; driver redeployment moves into device settings.
+USB events update inventory while persistent identity/name/configuration remain
+available across sessions. A green connection lamp does not assert that frames
+are currently being acquired or that every sensor option has been qualified.
+
+Actual GUI acceptance and its limits are recorded in
+[the sensor architecture report](../../docs/node/05_SENSOR_HOST_AND_SHARED_CONTROL.md).
+Node GUI raw playback has passed. Core replay/API event acceptance still needs
+the separately approved canonical server restart. Resumable raw transfer/import,
+continuous unplug/replug without service restart, different USB ports, native
+WebKit media, recovery/soak and clean-OS qualification remain open. The owner
+powered the Mini off after the session; no later hardware checks are implied.
+
+Installed package: `mission-core-node_0.6.11_amd64.deb`, 94,021,846 bytes;
+SHA-256 `2d593616d64ed9fecb99e5758763ae52610731aaf1467fb23c7d75b19ffef0fa`.
+Its source/provenance base is `404285419f864da7306eef6ee07a2077ad30e674`.
+Subsequent documentation commits do not imply another package installation.
+
+## Bootstrap history: 0.2–0.4
+
+0.4.0 makes «Настройка окружения» the first system view. A fixed privileged
+helper starts a durable, versioned systemd workflow for packages, the board
+service, network/USB inventory, SSH and Tailscale. Operator-controlled SSH keys
+and Tailscale login are available in the same section. The package bootstraps
+the GUI/service; operational configuration is performed by its UI button.
+Operator copy is OS-neutral; actual OS/version appears only in «Обзор БК».
+Support remains Ubuntu 24.04 LTS Desktop amd64.
+
+0.3.2 also repairs Linux interface inventory: the unprivileged service admits
+AF_NETLINK for OS metadata reads while retaining an empty capability set.
+Inventory and UI distinguish a failed network/address read from an empty list.
+
+0.3.1 consolidates host inventory, USB, Tailscale and SSH under «Система».
+«Обзор БК» contains host facts, the board name and an observed connectivity
+summary. The separate configuration page and redundant Node health badge are
+removed. «Устройства» is reserved for driver-backed devices and remains disabled
+until a real device workflow exists. The admitted Node/Core pairing and fleet
+surface plan is in `docs/node/03_SYSTEM_AND_VEHICLE_PAIRING_SURFACE.md`.
+
+0.3.0 adopts the canonical Mission Core shell, navigation, system views and a
+GUI list of trusted SSH devices. ResourceRow is shared from Design Guideline;
+see `docs/node/02_NODE_DESKTOP_SURFACE.md` for composition and acceptance.
+The Debian package still contains the GTK/WebKit desktop launcher and bundled
+React UI. Real Mini installation and read-only UI checks passed; physical
+reboot, bare-Ubuntu installation and full GUI upgrade/removal remain open.
+
+**Qualification in progress (2026-09-05):** the owner installed 0.2.0 through
+App Center after closing Synaptic, which had blocked package installation.
+PackageKit completed successfully and the packaged service is active.
+The owner subsequently confirmed the corrected icon and Tailscale “online” with
+the board address under 0.2.2. 0.2.2 corrects the desktop icon's
+canvas and configures the pinned provider's HTTPS control transport. The earlier
+0.2.1 icon-only candidate was superseded before installation.
+Manual SSH bootstrap is authorized for engineering access only.
+
+0.2.3 also routes expired-session errors from Tailscale polling to the existing
+application login surface. Browser acceptance confirmed that restarting the
+temporary test service now shows login instead of a misleading unavailable
+provider. This does not preserve authentication across a service restart.
+
+Source of truth: MISSIONCOR-76 and its UI-FIRST / BRIDGE-ONLY / system
+configuration comments. Product surface and physical acceptance procedure:
+`docs/node/01_BOOTSTRAP_SURFACE_AND_ACCEPTANCE.md` at the repository root.
+
+This is an independently built application in the Mission Core monorepo.
+Version 0.2.0 contains local host/USB/network inventory, persistent Ed25519
+identity, GUI naming, OS-authenticated local launch, redacted report export,
+OpenSSH installation/autostart, and GUI enrollment/revocation of Ed25519 public
+keys for local Ubuntu administrators. The agent and desktop window run
+unprivileged; fixed polkit helpers admit only local login and the shipped system/network actions. SSH configuration is
+owned by the versioned environment workflow, with conflict detection and cleanup on removal.
+
+In 0.2.0, Core pairing/mTLS, sensor plugins, capture, media and recovery were
+subsequent vertical increments. See the current candidate section above for
+their present implementation and acceptance boundaries.
+
+## Operator workflow
+
+Open the `.deb` in Ubuntu's graphical package installer, install it, then launch
+Mission Core Node from the applications menu and approve the normal OS dialog.
+The application opens in its own GTK window with embedded WebKit rendering and
+native system dialogs for authorization and report saving. No external browser
+is opened. Closing the window leaves the independent board service running.
+The system installer resolves dependencies from Ubuntu repositories; internet
+access is needed when those dependencies are absent. There are no shared
+credentials in the package. SSH public keys are enrolled explicitly in the UI.
+No shell, Go, Python environment setup, npm, or source checkout is required from
+the operator. The included Python launcher uses the system Python dependency.
+
+The desktop icon contains the unchanged canonical NODE.DC mark from the admitted
+Design Guideline revision inside a transparent square SVG canvas. This gives
+desktop loaders square intrinsic dimensions without stretching the mark. After
+upgrading the package, close and reopen the
+application window so its native helpers and embedded UI have matching features.
+
+**Observed installer limitation (2026-09-05):** App Center revision 1270 on the
+qualification board showed “installed” instead of offering the 0.1.1 → 0.2.0
+local-file upgrade. Do not claim that update path is accepted. The owner's
+subsequent GUI removal succeeded; reinstall attempts then failed before dpkg
+because Synaptic remained open and held `/var/lib/dpkg/lock-frontend`.
+Exit Synaptic through File → Quit before retrying the `.deb` in App Center.
+Do not delete package-manager locks or terminate a running transaction. The
+0.2.0 SHA-256 still matches, and APT simulation resolves its dependencies;
+neither check alone establishes actual installation. The following GUI retry
+completed successfully and the installed package is 0.2.0. A complete product installer
+must still qualify GUI upgrade, removal and actionable lock/error handling.
+
+## Private network setup
+
+The optional Tailscale panel has real install, login, waiting-for-approval,
+stopped, starting, unavailable and connected states. Installation and connection
+use two fixed root-owned polkit helpers from the desktop window. The web API
+can only read a reduced local status; it cannot run commands or change network
+settings. The generic Node identity and capture lifecycle do not depend on
+Tailscale. Pairing to Mission Core is a separate explicit UI operation; see
+[the pairing protocol](../../docs/node/04_NODE_CORE_PAIRING_PROTOCOL.md).
+
+On a new machine, the helper downloads the official amd64 `.deb` pinned in
+`packaging/tailscale-release.json`, verifies SHA-256 before invoking APT, installs
+without removing other packages, and enables `tailscaled`. It does not add an
+APT repository or upgrade an existing Tailscale installation. An existing
+stopped authenticated configuration is resumed with a bare `tailscale up`;
+fresh login explicitly disables accepting remote DNS and subnet routes. No
+exit node, advertised subnet, Tailscale SSH, forced reauthentication or reset
+is configured. Incompatible existing preferences fail instead of being reset.
+
+For a new provider install, and when explicitly reconnecting a disconnected
+provider, a root-owned systemd drop-in selects `TS_FORCE_NOISE_443=true`.
+The board's port-80 control connection stalled after registration with queued
+unacknowledged data; the upstream `debug ts2021` handshake succeeded over 443.
+The helper checks the daemon's effective flag and restarts it only when needed.
+An already Running/NeedsMachineAuth provider is left untouched. Conflicting
+custom drop-ins are preserved and reported. Keys, DNS and route preferences
+are not changed. This drop-in remains with the independent provider on Node
+removal. The transport setting is specific to pinned Tailscale, not Node identity.
+
+The provider's validated `https://login.tailscale.com/a/...` URL opens in the
+user's normal browser only after the explicit login action. Node never collects
+the account password or exports the login URL to JS, its status API or reports.
+The status probe requests no peers and returns only installation/state, local
+Tailscale addresses and the provider's online flag. Closing Node or uninstalling
+it does not disconnect or remove the independently installed Tailscale service.
+
+Source contracts: [Tailscale stable packages](https://pkgs.tailscale.com/stable/),
+[pinned up implementation](https://github.com/tailscale/tailscale/blob/v1.102.3/cmd/tailscale/cli/up.go),
+[pinned status implementation](https://github.com/tailscale/tailscale/blob/v1.102.3/cmd/tailscale/cli/status.go).
+HTTPS underlay: [pinned control dialer](https://github.com/tailscale/tailscale/blob/v1.102.3/control/controlhttp/client.go).
+JSON contracts are version-sensitive; review the adapter when updating the pin.
+
+Only Ubuntu 24.04 LTS Desktop amd64 is admitted by this first package. No blind
+upgrade of OS, firmware, network profiles, router settings or camera SDK occurs.
+Existing Ubuntu SSH authentication is retained. Keys enrolled in Node are
+limited to private source addresses. Removing Node removes its SSH integration,
+but leaves the SSH server and persistent Node state available for reinstall.
+
+## Engineering build (not the operator installation procedure)
+
+Install UI dependencies with `npm ci --ignore-scripts` in `ui/`. The build
+requires the sibling Design Guideline repository used by the monorepo, at
+`999864e5b0a81555823cfa1ea6e8cf8a417c37f1` (the exact `DG_COMMIT` in
+`packaging/build.py`, not necessarily the latest documentation commit). In that checkout, run
+`npm ci --ignore-scripts` and `npm run build:packages` before building Node.
+Its dependencies are bundled into the binary; the board never references that
+sibling path. The pinned commit includes ResourceRow and the shared shell fixes;
+source and generated export hashes are also retained in package provenance.
+
+Use the Go release pinned in `toolchain.json`; download it from the official
+Go distribution and verify its SHA-256. No global Go install is needed.
+
+```sh
+python3 packaging/build.py --go /path/to/verified/go/bin/go
+```
+
+This runs the production UI build, replaces generated embedded assets, builds
+a static Linux amd64 Go binary, records source/build provenance, and packages
+the `.deb` without executing any installer scripts. `build/` is ignored.
+
+Validation is sequential: `go test -race ./...`, the Control Station application
+architecture boundary test, Node UI typecheck/unit tests/build, then desktop GUI QA.
+Package script syntax/archive checks and a macOS browser run cannot establish
+Ubuntu systemd/polkit/SSH or clean-install acceptance. Those require the GUI
+procedure on the actual board. The temporary native QA build must be stopped
+after inspection; the canonical Mission Core on port 8000 stays running.
+
+For this board, the owner's engineering checkout is under
+`Загрузки/NDC/MISSION_CORE` in the operator's home directory. Keep complete Git history separately
+from generated artifacts; do not copy another worktree's `.git` pointer. The
+launcher accepts `--development-socket` for an unprivileged development service
+on the board. This does not grant OS privileges and is not installer acceptance.
+
+K1 uses wireless Bridge in the common LAN only. D455 is attached by USB; check
+its actual negotiated speed and SDK operation separately from enumeration.
+
+## Local authority
+
+The node service binds only `127.0.0.1:8780`. This is not the remote Node/Core
+control plane. Its private Unix socket is `0600` in a `0700` directory. The
+root-owned launcher helper has a fixed executable and socket; no user command,
+path, URL or environment is executed with elevated privileges. One-use login
+tokens expire after one minute, authenticated cookies after eight hours, and
+all sessions expire on service restart. Identity corruption fails closed.
+
+The D455 worker reads USB/SDK serials internally to match one physical device;
+the shared sensor API uses a derived stable device ID. Treat identifiers, host
+inventory and captured data as private operational evidence. Credentials,
+private keys, real recordings, exported host reports and runtime state stay
+outside normal Git. See the architecture reports for the exact API/report
+boundaries rather than treating source-test fixtures as live evidence.
@@ -0,0 +1,41 @@
+// Engineering-only UI fixture: uses the production API and isolated storage.
+// No fixture is linked into cmd/node-agent or installed by the Debian package.
+package main
+
+import (
+ "bytes"
+ "io/fs"
+ "log"
+ "net/http"
+ "os"
+ "path/filepath"
+ "time"
+ "nodedc.local/mission-core/node-agent/internal/node"
+ "nodedc.local/mission-core/node-agent/web"
+)
+
+func main() {
+ dir := "/private/tmp/mc-node-ui-040-qa"
+ store, err := node.OpenStore(dir); if err != nil { log.Fatal(err) }
+ assets, _ := fs.Sub(web.Assets, "dist")
+ memory, available := uint64(8388608), uint64(5242880)
+ app := &node.Server{Store: store, Assets: assets, Origin: "http://127.0.0.1:8780", Version: "0.4.0-qa", Inventory: func() node.Inventory {
+  inventory := node.Inventory{CollectedAt: time.Now().UTC().Format(time.RFC3339), Hostname:"qa-board", OS:"Ubuntu 24.04.4 LTS", Architecture:"amd64", CPUs:8, MemoryKiB:&memory, AvailableKiB:&available,
+   NetworksReadable:true, Networks: []node.Network{{Name:"ethernet-qa", Up:true, AddressesReadable:true, Addresses:[]string{"192.0.2.10/24"}}},
+   USB:[]node.USB{{Port:"2-1", Vendor:"8086", ProductID:"0b5c", Product:"Intel RealSense D455 · QA", Speed:"5000"}}, USBReadable:true, Warnings:[]string{}}
+  if _, err := os.Stat(filepath.Join(dir,"network-unavailable")); err == nil { inventory.NetworksReadable=false; inventory.Networks=[]node.Network{}; inventory.Warnings=[]string{"Не удалось прочитать сетевые интерфейсы"} }
+  return inventory
+ }, Access: &node.AccessStore{Path:filepath.Join(dir,"ssh-keys.json"), Users:func()[]string{return []string{"operator"}}}, Tailscale:func()node.TailscaleStatus {
+   if _, err := os.Stat(filepath.Join(dir,"offline")); err == nil { return node.TailscaleStatus{Installed:true, State:"unavailable", Addresses:[]string{}} }
+   return node.TailscaleStatus{Installed:true, State:"Running", Online:true, Addresses:[]string{"100.64.0.10"}}
+ }}
+ if err := os.WriteFile(filepath.Join(dir,"login-url"),[]byte(app.IssueLogin()),0600); err != nil {log.Fatal(err)}
+ handler := app.Handler()
+ http.HandleFunc("/",func(w http.ResponseWriter,r *http.Request){
+   if r.URL.Path == "/qa-bridge.js" { w.Header().Set("Content-Type","application/javascript"); _,_ = w.Write([]byte(`window.missionCoreDesktop={networkSetup:true};`)); return }
+   if r.URL.Path == "/" { b,_:=fs.ReadFile(assets,"index.html"); b=bytes.Replace(b,[]byte("</head>"),[]byte(`<script src="/qa-bridge.js"></script></head>`),1); w.Header().Set("Content-Type","text/html"); _,_=w.Write(b); return }
+   handler.ServeHTTP(w,r)
+ })
+ log.Print("isolated Node UI QA: 127.0.0.1:8780")
+ log.Fatal(http.ListenAndServe("127.0.0.1:8780",nil))
+}
@@ -0,0 +1,157 @@
+package main
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"flag"
+	"fmt"
+	"io"
+	"io/fs"
+	"log"
+	"net"
+	"net/http"
+	"os"
+	"os/signal"
+	"path/filepath"
+	"syscall"
+	"time"
+
+	"nodedc.local/mission-core/node-agent/internal/node"
+	"nodedc.local/mission-core/node-agent/web"
+)
+
+var version = "0.2.0"
+
+const defaultSocket = "/run/mission-core-node/admin.sock"
+
+func main() {
+	if err := run(); err != nil {
+		log.Print(err)
+		os.Exit(1)
+	}
+}
+
+func run() error {
+	if len(os.Args) > 1 && os.Args[1] == "authorize" {
+		return authorize(defaultSocket)
+	}
+	if len(os.Args) == 3 && os.Args[1] == "ssh-keys" {
+		value, err := node.AuthorizedKeys("/var/lib/mission-core-node/ssh-keys.json", os.Args[2])
+		if err == nil {
+			fmt.Print(value)
+		}
+		return err
+	}
+	flags := flag.NewFlagSet("node-agent", flag.ContinueOnError)
+	dir := flags.String("state", "/var/lib/mission-core-node", "private state directory")
+	socket := flags.String("socket", defaultSocket, "private launcher socket")
+	listen := flags.String("listen", "127.0.0.1:8780", "loopback UI address")
+	if err := flags.Parse(os.Args[1:]); err != nil {
+		return err
+	}
+	host, _, err := net.SplitHostPort(*listen)
+	if err != nil || host != "127.0.0.1" {
+		return errors.New("local UI must bind 127.0.0.1")
+	}
+	// Bind before touching state/socket; a second instance cannot replace identity or launcher authority.
+	tcp, err := net.Listen("tcp", *listen)
+	if err != nil {
+		return err
+	}
+	defer tcp.Close()
+	store, err := node.OpenStore(*dir)
+	if err != nil {
+		return err
+	}
+	assets, err := fs.Sub(web.Assets, "dist")
+	if err != nil {
+		return err
+	}
+	app := &node.Server{Store: store, Assets: assets, Origin: "http://" + *listen, Version: version, Inventory: func() node.Inventory { return node.Host("/") }}
+	pairing, err := node.OpenPairing(store, *dir, version, app.Inventory)
+	if err != nil {
+		return err
+	}
+	app.Pairing = pairing
+	nodeID, _ := store.Public()
+	app.Sensors, err = node.OpenSensors(*dir, nodeID)
+	if err != nil {
+		return err
+	}
+	pairing.Sensors = app.Sensors
+	app.Access = &node.AccessStore{Path: filepath.Join(*dir, "ssh-keys.json"), Users: func() []string { return node.LocalAdmins("/") }}
+	if err := os.MkdirAll(filepath.Dir(*socket), 0700); err != nil {
+		return err
+	}
+	if info, e := os.Lstat(*socket); e == nil {
+		if info.Mode()&os.ModeSocket == 0 {
+			return errors.New("launcher path is not a socket")
+		}
+		if err := os.Remove(*socket); err != nil {
+			return err
+		}
+	} else if !os.IsNotExist(e) {
+		return e
+	}
+	unix, err := net.Listen("unix", *socket)
+	if err != nil {
+		return err
+	}
+	defer unix.Close()
+	defer os.Remove(*socket)
+	if err := os.Chmod(*socket, 0600); err != nil {
+		return err
+	}
+	admin := http.NewServeMux()
+	admin.HandleFunc("POST /login", func(w http.ResponseWriter, r *http.Request) {
+		w.Header().Set("Content-Type", "application/json")
+		json.NewEncoder(w).Encode(map[string]string{"url": app.IssueLogin()})
+	})
+	public := &http.Server{Handler: app.Handler(), ReadHeaderTimeout: 5 * time.Second, ReadTimeout: 10 * time.Second, WriteTimeout: 10 * time.Second, IdleTimeout: 30 * time.Second, MaxHeaderBytes: 8192}
+	private := &http.Server{Handler: admin, ReadHeaderTimeout: 5 * time.Second, ReadTimeout: 10 * time.Second, WriteTimeout: 10 * time.Second, IdleTimeout: 10 * time.Second, MaxHeaderBytes: 8192}
+	errs := make(chan error, 2)
+	go func() { errs <- public.Serve(tcp) }()
+	go func() { errs <- private.Serve(unix) }()
+	ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)
+	defer stop()
+	go app.Sensors.WatchUSB(ctx)
+	go pairing.Run(ctx)
+	log.Print("Mission Core Node " + version + " listening on loopback")
+	select {
+	case err = <-errs:
+	case <-ctx.Done():
+	}
+	shutdown, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+	defer cancel()
+	public.Shutdown(shutdown)
+	private.Shutdown(shutdown)
+	if errors.Is(err, http.ErrServerClosed) {
+		return nil
+	}
+	return err
+}
+
+func authorize(socket string) error {
+	// Called by a fixed, root-owned polkit helper. No user-supplied URL, command,
+	// path, or environment is interpreted by the privileged operation.
+	client := &http.Client{Timeout: 5 * time.Second, Transport: &http.Transport{DialContext: func(ctx context.Context, _, _ string) (net.Conn, error) {
+		return (&net.Dialer{}).DialContext(ctx, "unix", socket)
+	}}}
+	res, err := client.Post("http://local/login", "application/json", nil)
+	if err != nil {
+		return errors.New("Node is unavailable")
+	}
+	defer res.Body.Close()
+	if res.StatusCode != 200 {
+		return errors.New("Node rejected local authorization")
+	}
+	var value struct {
+		URL string `json:"url"`
+	}
+	if err := json.NewDecoder(io.LimitReader(res.Body, 1024)).Decode(&value); err != nil {
+		return err
+	}
+	fmt.Print(value.URL)
+	return nil
+}
@@ -0,0 +1,3 @@
+module nodedc.local/mission-core/node-agent
+
+go 1.26.0
@@ -0,0 +1,265 @@
+package node
+
+import (
+	"bufio"
+	"crypto/sha256"
+	"encoding/base64"
+	"encoding/binary"
+	"encoding/json"
+	"errors"
+	"net"
+	"net/http"
+	"os"
+	"path/filepath"
+	"regexp"
+	"strconv"
+	"strings"
+	"sync"
+	"time"
+	"unicode"
+	"unicode/utf8"
+)
+
+type AccessKey struct {
+	ID        string `json:"id"`
+	User      string `json:"user"`
+	Label     string `json:"label"`
+	PublicKey string `json:"public_key"`
+}
+type AccessStore struct {
+	mu    sync.Mutex
+	Path  string
+	Users func() []string
+}
+
+var usernamePattern = regexp.MustCompile(`^[a-z_][a-z0-9_-]{0,31}$`)
+
+// Only existing local administrative accounts are eligible. Never root,
+// a supplied home directory, an arbitrary NSS principal, or a generated user.
+func LocalAdmins(root string) []string {
+	group, _ := os.ReadFile(filepath.Join(root, "etc/group"))
+	admins := map[string]bool{}
+	for _, line := range strings.Split(string(group), "\n") {
+		p := strings.Split(line, ":")
+		if len(p) == 4 && p[0] == "sudo" {
+			for _, u := range strings.Split(p[3], ",") {
+				admins[u] = true
+			}
+		}
+	}
+	passwd, _ := os.ReadFile(filepath.Join(root, "etc/passwd"))
+	result := []string{}
+	for _, line := range strings.Split(string(passwd), "\n") {
+		p := strings.Split(line, ":")
+		if len(p) != 7 {
+			continue
+		}
+		uid, e := strconv.Atoi(p[2])
+		if e == nil && uid >= 1000 && uid < 65534 && admins[p[0]] && usernamePattern.MatchString(p[0]) && !strings.HasSuffix(p[6], "nologin") && !strings.HasSuffix(p[6], "false") {
+			result = append(result, p[0])
+		}
+	}
+	return result
+}
+
+func canonicalKey(key string) (string, string, error) {
+	parts := strings.Fields(strings.TrimSpace(key))
+	bad := errors.New("Нужен публичный ключ Ed25519, начинающийся с ssh-ed25519; приватный ключ вводить нельзя")
+	if len(parts) < 2 || parts[0] != "ssh-ed25519" || strings.ContainsAny(key, "\r\n") {
+		return "", "", bad
+	}
+	b, e := base64.StdEncoding.DecodeString(parts[1])
+	if e != nil || len(b) != 51 {
+		return "", "", bad
+	}
+	if binary.BigEndian.Uint32(b[:4]) != 11 || string(b[4:15]) != "ssh-ed25519" || binary.BigEndian.Uint32(b[15:19]) != 32 {
+		return "", "", bad
+	}
+	h := sha256.Sum256(b)
+	return "ssh-ed25519 " + base64.StdEncoding.EncodeToString(b), "SHA256:" + base64.RawStdEncoding.EncodeToString(h[:]), nil
+}
+
+func ReadAccess(path string) ([]AccessKey, error) {
+	b, err := os.ReadFile(path)
+	if errors.Is(err, os.ErrNotExist) {
+		return []AccessKey{}, nil
+	}
+	if err != nil {
+		return nil, err
+	}
+	var keys []AccessKey
+	if err = json.Unmarshal(b, &keys); err != nil {
+		return nil, err
+	}
+	if len(keys) > 64 {
+		return nil, errors.New("too many access keys")
+	}
+	for _, k := range keys {
+		key, id, err := canonicalKey(k.PublicKey)
+		if err != nil || key != k.PublicKey || id != k.ID || !usernamePattern.MatchString(k.User) {
+			return nil, errors.New("invalid access store")
+		}
+	}
+	return keys, nil
+}
+
+func (a *AccessStore) List() ([]AccessKey, error) {
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	return ReadAccess(a.Path)
+}
+func (a *AccessStore) allowed(user string) bool {
+	for _, u := range a.Users() {
+		if user == u {
+			return true
+		}
+	}
+	return false
+}
+func (a *AccessStore) change(fn func([]AccessKey) ([]AccessKey, error)) error {
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	keys, err := ReadAccess(a.Path)
+	if err != nil {
+		return errors.New("Хранилище SSH недоступно")
+	}
+	keys, err = fn(keys)
+	if err != nil {
+		return err
+	}
+	b, err := json.Marshal(keys)
+	if err != nil {
+		return err
+	}
+	f, err := os.CreateTemp(filepath.Dir(a.Path), ".ssh-keys-*")
+	if err != nil {
+		return err
+	}
+	defer os.Remove(f.Name())
+	if _, err = f.Write(b); err != nil {
+		f.Close()
+		return err
+	}
+	if err = f.Sync(); err != nil {
+		f.Close()
+		return err
+	}
+	if err = f.Close(); err != nil {
+		return err
+	}
+	return os.Rename(f.Name(), a.Path)
+}
+
+func (a *AccessStore) Add(user, label, key string) error {
+	if !a.allowed(user) {
+		return errors.New("Выберите существующую учётную запись администратора системы")
+	}
+	label = strings.TrimSpace(label)
+	if label == "" || utf8.RuneCountInString(label) > 64 || strings.ContainsFunc(label, unicode.IsControl) {
+		return errors.New("Название ключа должно содержать от 1 до 64 символов")
+	}
+	key, id, err := canonicalKey(key)
+	if err != nil {
+		return err
+	}
+	return a.change(func(keys []AccessKey) ([]AccessKey, error) {
+		for _, k := range keys {
+			if k.ID == id && k.User == user {
+				return keys, nil
+			}
+		}
+		if len(keys) >= 64 {
+			return nil, errors.New("Достигнут предел 64 ключа")
+		}
+		return append(keys, AccessKey{ID: id, User: user, Label: label, PublicKey: key}), nil
+	})
+}
+func (a *AccessStore) Remove(user, id string) error {
+	return a.change(func(keys []AccessKey) ([]AccessKey, error) {
+		next := []AccessKey{}
+		for _, k := range keys {
+			if k.User != user || k.ID != id {
+				next = append(next, k)
+			}
+		}
+		return next, nil
+	})
+}
+
+func SSHReady() bool {
+	c, err := net.DialTimeout("tcp", "127.0.0.1:22", 400*time.Millisecond)
+	if err != nil {
+		return false
+	}
+	defer c.Close()
+	c.SetReadDeadline(time.Now().Add(400 * time.Millisecond))
+	s := bufio.NewScanner(c)
+	return s.Scan() && strings.HasPrefix(s.Text(), "SSH-2.0-")
+}
+
+func (s *Server) accessRoutes(mux *http.ServeMux) {
+	mux.HandleFunc("GET /api/access", func(w http.ResponseWriter, r *http.Request) {
+		if !s.authorized(w, r) {
+			return
+		}
+		keys, err := s.Access.List()
+		if err != nil {
+			reply(w, 503, map[string]string{"error": "Хранилище SSH недоступно"})
+			return
+		}
+		reply(w, 200, map[string]any{"users": s.Access.Users(), "keys": keys, "ssh_ready": SSHReady()})
+	})
+	mux.HandleFunc("POST /api/access", func(w http.ResponseWriter, r *http.Request) {
+		if !s.authorized(w, r) {
+			return
+		}
+		var b struct {
+			User  string `json:"user"`
+			Label string `json:"label"`
+			Key   string `json:"key"`
+		}
+		if !decode(w, r, &b) {
+			return
+		}
+		if err := s.Access.Add(b.User, b.Label, b.Key); err != nil {
+			reply(w, 400, map[string]string{"error": err.Error()})
+			return
+		}
+		reply(w, 200, map[string]bool{"ok": true})
+	})
+	mux.HandleFunc("DELETE /api/access", func(w http.ResponseWriter, r *http.Request) {
+		if !s.authorized(w, r) {
+			return
+		}
+		var b struct {
+			User string `json:"user"`
+			ID   string `json:"id"`
+		}
+		if !decode(w, r, &b) {
+			return
+		}
+		if err := s.Access.Remove(b.User, b.ID); err != nil {
+			reply(w, 503, map[string]string{"error": "Не удалось удалить ключ"})
+			return
+		}
+		reply(w, 200, map[string]bool{"ok": true})
+	})
+}
+
+func AuthorizedKeys(path, user string) (string, error) {
+	a := &AccessStore{Path: path, Users: func() []string { return LocalAdmins("/") }}
+	if !a.allowed(user) {
+		return "", nil
+	}
+	keys, err := a.List()
+	if err != nil {
+		return "", err
+	}
+	var out strings.Builder
+	for _, k := range keys {
+		if k.User == user {
+			out.WriteString(`from="10.0.0.0/8,172.16.0.0/12,192.168.0.0/16,100.64.0.0/10,127.0.0.0/8,::1,fc00::/7,fe80::/10" ` + k.PublicKey + "\n")
+		}
+	}
+	return out.String(), nil
+}
@@ -0,0 +1,13 @@
+{
+  "schema": "missioncore.node.environment/v1",
+  "revision": "ubuntu-24.04-amd64/2",
+  "steps": [
+    {"id":"platform","label":"Проверка системы","description":"Операционная система и архитектура БК","requires":[]},
+    {"id":"packages","label":"Установка системных пакетов","description":"OpenSSH Server и зависимости окружения","requires":["platform"]},
+    {"id":"node-service","label":"Настройка службы БК","description":"Автозапуск и доступ к системной инвентаризации","requires":["platform"]},
+    {"id":"network-inventory","label":"Получение сетевых настроек","description":"Интерфейсы и назначенные адреса","requires":["node-service"]},
+    {"id":"usb-inventory","label":"Получение USB-устройств","description":"Оборудование, обнаруженное операционной системой","requires":["node-service"]},
+    {"id":"ssh-service","label":"Настройка SSH","description":"Запуск сервера и подключение реестра доверенных ключей","requires":["packages","node-service"]},
+    {"id":"tailscale-install","label":"Установка Tailscale","description":"Проверенный пакет и системная служба частной сети","requires":["packages"]}
+  ]
+}
@@ -0,0 +1,100 @@
+package node
+
+import (
+	"context"
+	_ "embed"
+	"encoding/json"
+	"io"
+	"os"
+	"os/exec"
+	"time"
+)
+
+//go:embed environment-profile.json
+var environmentProfile []byte
+
+type EnvironmentRun struct {
+	Schema          string            `json:"schema"`
+	ProfileRevision string            `json:"profile_revision"`
+	RunID           string            `json:"run_id"`
+	State           string            `json:"state"`
+	StartedAt       float64           `json:"started_at"`
+	UpdatedAt       float64           `json:"updated_at"`
+	Steps           []EnvironmentStep `json:"steps"`
+}
+type EnvironmentStep struct {
+	ID     string `json:"id"`
+	State  string `json:"state"`
+	Detail string `json:"detail"`
+}
+type EnvironmentStatus struct {
+	Profile   json.RawMessage `json:"profile"`
+	Run       *EnvironmentRun `json:"run"`
+	Available bool            `json:"available"`
+}
+
+func ReadEnvironment() EnvironmentStatus {
+	result := readEnvironmentFile("/var/lib/mission-core-node-environment/last-run.json")
+	if result.Run != nil && result.Run.State == "running" {
+		ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
+		defer cancel()
+		state, err := exec.CommandContext(ctx, "/usr/bin/systemctl", "show", "--property=ActiveState", "--value", "mission-core-node-environment.service").Output()
+		if err != nil || (string(state) != "activating\n" && string(state) != "active\n") {
+			// A stopped job/reboot cannot leave yesterday's spinner running.
+			result.Run.State = "interrupted"
+		}
+	}
+	return result
+}
+
+func readEnvironmentFile(path string) EnvironmentStatus {
+	result := EnvironmentStatus{Profile: json.RawMessage(environmentProfile), Available: true}
+	f, err := os.Open(path)
+	if os.IsNotExist(err) {
+		return result
+	}
+	if err != nil {
+		result.Available = false
+		return result
+	}
+	defer f.Close()
+	info, err := f.Stat()
+	if err != nil || !info.Mode().IsRegular() || info.Size() > 32768 {
+		result.Available = false
+		return result
+	}
+	var run EnvironmentRun
+	decoder := json.NewDecoder(io.LimitReader(f, 32769))
+	if decoder.Decode(&run) != nil || decoder.Decode(new(any)) != io.EOF || !validEnvironmentRun(run) {
+		result.Available = false
+		return result
+	}
+	result.Run = &run
+	return result
+}
+
+// Invalid or inconsistent progress cannot turn a failed setup into green UI.
+func validEnvironmentRun(run EnvironmentRun) bool {
+	if run.Schema != "missioncore.node.environment/v1" || run.RunID == "" || len(run.RunID) > 64 || len(run.Steps) == 0 || len(run.Steps) > 32 || run.ProfileRevision == "" {
+		return false
+	}
+	if run.State != "running" && run.State != "complete" && run.State != "error" {
+		return false
+	}
+	seen := map[string]bool{}
+	for _, step := range run.Steps {
+		if step.ID == "" || len(step.ID) > 64 || seen[step.ID] || len(step.Detail) > 4096 {
+			return false
+		}
+		seen[step.ID] = true
+		switch step.State {
+		case "pending", "running", "complete", "error", "blocked":
+		default:
+			return false
+		}
+		if run.State == "complete" && step.State != "complete" {
+			return false
+		}
+	}
+	return true
+}
@@ -0,0 +1,51 @@
+package node
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func TestEnvironmentStatusIsAuthorizedReadOnly(t *testing.T) {
+	s := newTestServer(t)
+	s.Environment = func() EnvironmentStatus { return EnvironmentStatus{Available: true, Profile: environmentProfile} }
+	if got := call(s, "GET", "/api/environment", "", nil); got.Code != 401 {
+		t.Fatal(got.Code)
+	}
+	cookie := login(t, s)
+	if got := call(s, "GET", "/api/environment", "", cookie); got.Code != 200 {
+		t.Fatal(got.Code, got.Body.String())
+	}
+	if got := call(s, "POST", "/api/environment", "{}", cookie); got.Code == 200 {
+		t.Fatal("HTTP can mutate system")
+	}
+}
+
+func TestMissingCorruptAndPartialEnvironmentReports(t *testing.T) {
+	path := filepath.Join(t.TempDir(), "last-run.json")
+	result := readEnvironmentFile(path)
+	if !result.Available || result.Run != nil {
+		t.Fatal("new install not admitted")
+	}
+	samples := []string{
+		`{broken`,
+		`{"schema":"missioncore.node.environment/v1","profile_revision":"test/1","run_id":"test","state":"complete","steps":[{"id":"network-inventory","state":"error"}]}`,
+		`{"schema":"missioncore.node.environment/v1","profile_revision":"test/1","run_id":"test","state":"complete","steps":[{"id":"x","state":"complete"},{"id":"x","state":"complete"}]}`,
+		`{"schema":"missioncore.node.environment/v1","profile_revision":"test/1","run_id":"test","state":"complete","steps":[{"id":"x","state":"complete"}]} {}`,
+	}
+	for _, sample := range samples {
+		if err := os.WriteFile(path, []byte(sample), 0600); err != nil {
+			t.Fatal(err)
+		}
+		if got := readEnvironmentFile(path); got.Available || got.Run != nil {
+			t.Fatal("invalid report admitted", sample)
+		}
+	}
+	if err := os.WriteFile(path, []byte(`{"schema":"missioncore.node.environment/v1","profile_revision":"test/1","run_id":"test","state":"error","steps":[{"id":"packages","state":"error"},{"id":"ssh-service","state":"blocked"}]}`), 0600); err != nil {
+		t.Fatal(err)
+	}
+	result = readEnvironmentFile(path)
+	if !result.Available || result.Run == nil || result.Run.State != "error" || result.Run.Steps[1].State != "blocked" {
+		t.Fatal("failure lost")
+	}
+}
@@ -0,0 +1,118 @@
+package node
+
+import (
+	"net"
+	"os"
+	"path/filepath"
+	"runtime"
+	"sort"
+	"strconv"
+	"strings"
+	"time"
+)
+
+type Network struct {
+	Name              string   `json:"name"`
+	Up                bool     `json:"up"`
+	Addresses         []string `json:"addresses"`
+	AddressesReadable bool     `json:"addresses_readable"`
+}
+type USB struct {
+	Port      string `json:"port"`
+	Vendor    string `json:"vendor"`
+	ProductID string `json:"product_id"`
+	Product   string `json:"product"`
+	Speed     string `json:"speed_mbps"`
+}
+type Inventory struct {
+	CollectedAt      string    `json:"collected_at"`
+	Hostname         string    `json:"hostname"`
+	OS               string    `json:"os"`
+	Architecture     string    `json:"architecture"`
+	CPUs             int       `json:"cpus"`
+	MemoryKiB        *uint64   `json:"memory_kib"`
+	AvailableKiB     *uint64   `json:"available_kib"`
+	Networks         []Network `json:"networks"`
+	NetworksReadable bool      `json:"networks_readable"`
+	USB              []USB     `json:"usb"`
+	USBReadable      bool      `json:"usb_readable"`
+	Warnings         []string  `json:"warnings"`
+}
+
+// Host reads only local kernel/OS metadata. It never probes network devices,
+// opens camera streams, reads device serials, or changes a network interface.
+func Host(root string) Inventory {
+	read := func(p string) string {
+		b, _ := os.ReadFile(filepath.Join(root, p))
+		return strings.TrimSpace(string(b))
+	}
+	host, _ := os.Hostname()
+	v := Inventory{CollectedAt: time.Now().UTC().Format(time.RFC3339), Hostname: host, OS: runtime.GOOS, Architecture: runtime.GOARCH, CPUs: runtime.NumCPU(), Networks: []Network{}, USB: []USB{}, Warnings: []string{}}
+	for _, line := range strings.Split(read("etc/os-release"), "\n") {
+		if x, ok := strings.CutPrefix(line, "PRETTY_NAME="); ok {
+			v.OS = strings.Trim(x, "\"")
+		}
+	}
+	for _, line := range strings.Split(read("proc/meminfo"), "\n") {
+		fields := strings.Fields(line)
+		if len(fields) < 2 {
+			continue
+		}
+		n, e := strconv.ParseUint(fields[1], 10, 64)
+		if e != nil {
+			continue
+		}
+		if fields[0] == "MemTotal:" {
+			v.MemoryKiB = &n
+		}
+		if fields[0] == "MemAvailable:" {
+			v.AvailableKiB = &n
+		}
+	}
+	if v.MemoryKiB == nil {
+		v.Warnings = append(v.Warnings, "Сведения о памяти недоступны")
+	}
+	var warnings []string
+	v.Networks, v.NetworksReadable, warnings = readNetworks(net.Interfaces, func(it net.Interface) ([]net.Addr, error) { return it.Addrs() })
+	v.Warnings = append(v.Warnings, warnings...)
+	entries, err := os.ReadDir(filepath.Join(root, "sys/bus/usb/devices"))
+	v.USBReadable = err == nil
+	if err != nil {
+		v.Warnings = append(v.Warnings, "Сведения об USB недоступны")
+	}
+	for _, e := range entries {
+		prefix := filepath.Join("sys/bus/usb/devices", e.Name())
+		vendor := read(filepath.Join(prefix, "idVendor"))
+		if vendor == "" {
+			continue
+		}
+		v.USB = append(v.USB, USB{Port: e.Name(), Vendor: vendor, ProductID: read(filepath.Join(prefix, "idProduct")), Product: read(filepath.Join(prefix, "product")), Speed: read(filepath.Join(prefix, "speed"))})
+	}
+	return v
+}
+
+func readNetworks(list func() ([]net.Interface, error), addrs func(net.Interface) ([]net.Addr, error)) ([]Network, bool, []string) {
+	result, warnings := []Network{}, []string{}
+	interfaces, err := list()
+	if err != nil {
+		return result, false, []string{"Не удалось прочитать сетевые интерфейсы"}
+	}
+	for _, it := range interfaces {
+		if it.Flags&net.FlagLoopback != 0 {
+			continue
+		}
+		addresses, err := addrs(it)
+		n := Network{Name: it.Name, Up: it.Flags&net.FlagUp != 0, Addresses: []string{}, AddressesReadable: err == nil}
+		if err != nil {
+			warnings = append(warnings, "Адреса интерфейса "+it.Name+" недоступны")
+		} else {
+			for _, a := range addresses {
+				n.Addresses = append(n.Addresses, a.String())
+			}
+		}
+		sort.Strings(n.Addresses)
+		result = append(result, n)
+	}
+	sort.Slice(result, func(i, j int) bool { return result[i].Name < result[j].Name })
+	return result, true, warnings
+}
@@ -0,0 +1,31 @@
+package node
+
+import (
+	"errors"
+	"net"
+	"testing"
+)
+
+func TestNetworkInventoryDistinguishesFailureFromEmpty(t *testing.T) {
+	denied := errors.New("read denied")
+	for _, failure := range []error{nil, denied} {
+		rows, readable, warnings := readNetworks(func() ([]net.Interface, error) { return nil, failure }, func(net.Interface) ([]net.Addr, error) { t.Fatal("no interface to read"); return nil, nil })
+		if len(rows) != 0 || readable != (failure == nil) || (len(warnings) > 0) != (failure != nil) {
+			t.Fatal(rows, readable, warnings)
+		}
+	}
+}
+
+func TestNetworkAddressFailureKeepsInterfaceWithoutInventingAddresses(t *testing.T) {
+	rows, readable, warnings := readNetworks(func() ([]net.Interface, error) {
+		return []net.Interface{{Name: "loop", Flags: net.FlagLoopback}, {Name: "ethernet", Flags: net.FlagUp}}, nil
+	}, func(it net.Interface) ([]net.Addr, error) {
+		if it.Name != "ethernet" {
+			t.Fatal("read loopback")
+		}
+		return []net.Addr{&net.IPAddr{IP: net.ParseIP("192.0.2.1")}}, errors.New("partial result")
+	})
+	if !readable || len(rows) != 1 || rows[0].Name != "ethernet" || !rows[0].Up || rows[0].AddressesReadable || len(rows[0].Addresses) != 0 || len(warnings) != 1 {
+		t.Fatal(rows, readable, warnings)
+	}
+}
@@ -0,0 +1,255 @@
+package node
+
+import (
+	"bytes"
+	"encoding/base64"
+	"encoding/binary"
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"os"
+	"path/filepath"
+	"strings"
+	"sync"
+	"testing"
+	"testing/fstest"
+	"time"
+)
+
+func newTestServer(t *testing.T) *Server {
+	t.Helper()
+	state, e := OpenStore(t.TempDir())
+	if e != nil {
+		t.Fatal(e)
+	}
+	return &Server{Store: state, Origin: "http://127.0.0.1:8780", Assets: fstest.MapFS{"index.html": {Data: []byte("test-only asset")}}, Inventory: func() Inventory {
+		return Inventory{Hostname: "private-host", Networks: []Network{{Name: "eth0", Addresses: []string{"192.168.10.4/24"}}}}
+	}}
+}
+func call(s *Server, method, path, body string, cookie *http.Cookie) *httptest.ResponseRecorder {
+	r := httptest.NewRequest(method, s.Origin+path, strings.NewReader(body))
+	r.Header.Set("Origin", s.Origin)
+	r.Header.Set("Content-Type", "application/json")
+	if cookie != nil {
+		r.AddCookie(cookie)
+	}
+	w := httptest.NewRecorder()
+	s.Handler().ServeHTTP(w, r)
+	return w
+}
+func login(t *testing.T, s *Server) *http.Cookie {
+	t.Helper()
+	v := strings.TrimPrefix(s.IssueLogin(), s.Origin+"/#login=")
+	w := call(s, "POST", "/api/session", `{"token":"`+v+`"}`, nil)
+	if w.Code != 200 {
+		t.Fatal(w.Code, w.Body.String())
+	}
+	return w.Result().Cookies()[0]
+}
+
+func TestIdentitySurvivesRenameAndReopen(t *testing.T) {
+	dir := t.TempDir()
+	s, e := OpenStore(dir)
+	if e != nil {
+		t.Fatal(e)
+	}
+	id, _ := s.Public()
+	if e = s.Rename("Борт 1"); e != nil {
+		t.Fatal(e)
+	}
+	s, e = OpenStore(dir)
+	if e != nil {
+		t.Fatal(e)
+	}
+	next, name := s.Public()
+	if next != id || name != "Борт 1" {
+		t.Fatal(next, name)
+	}
+	info, _ := os.Stat(filepath.Join(dir, "identity.json"))
+	if info.Mode().Perm() != 0600 {
+		t.Fatal(info.Mode())
+	}
+	if e = s.Rename("bad\nname"); e == nil {
+		t.Fatal("accepted control character")
+	}
+}
+
+func TestCorruptIdentityNeverReplaced(t *testing.T) {
+	dir := t.TempDir()
+	p := filepath.Join(dir, "identity.json")
+	bad := []byte(`{"version":1,"private_key":"bad"}`)
+	os.WriteFile(p, bad, 0600)
+	if _, e := OpenStore(dir); e == nil {
+		t.Fatal("corrupt state accepted")
+	}
+	got, _ := os.ReadFile(p)
+	if !bytes.Equal(got, bad) {
+		t.Fatal("identity replaced")
+	}
+}
+
+func TestLoginOneUseConcurrentAndExpires(t *testing.T) {
+	s := newTestServer(t)
+	now := time.Now()
+	s.Now = func() time.Time { return now }
+	v := strings.TrimPrefix(s.IssueLogin(), s.Origin+"/#login=")
+	var wg sync.WaitGroup
+	codes := make(chan int, 8)
+	for i := 0; i < 8; i++ {
+		wg.Add(1)
+		go func() { defer wg.Done(); codes <- call(s, "POST", "/api/session", `{"token":"`+v+`"}`, nil).Code }()
+	}
+	wg.Wait()
+	close(codes)
+	success := 0
+	for c := range codes {
+		if c == 200 {
+			success++
+		} else if c != 401 {
+			t.Fatal(c)
+		}
+	}
+	if success != 1 {
+		t.Fatal(success)
+	}
+	v = strings.TrimPrefix(s.IssueLogin(), s.Origin+"/#login=")
+	now = now.Add(time.Minute)
+	if call(s, "POST", "/api/session", `{"token":"`+v+`"}`, nil).Code != 401 {
+		t.Fatal("expired launch accepted")
+	}
+	c := login(t, s)
+	if !c.HttpOnly || c.SameSite != http.SameSiteStrictMode {
+		t.Fatal(c)
+	}
+	now = now.Add(8 * time.Hour)
+	if call(s, "GET", "/api/status", "", c).Code != 401 {
+		t.Fatal("expired session accepted")
+	}
+}
+
+func TestUnauthenticatedAndCrossSiteRequestsDenied(t *testing.T) {
+	s := newTestServer(t)
+	c := login(t, s)
+	for _, path := range []string{"/api/status", "/api/report"} {
+		if call(s, "GET", path, "", nil).Code != 401 {
+			t.Fatal(path)
+		}
+	}
+	for _, kind := range []string{"origin", "host", "metadata", "missing-origin"} {
+		r := httptest.NewRequest("PUT", s.Origin+"/api/name", strings.NewReader(`{"name":"attacker"}`))
+		r.AddCookie(c)
+		r.Header.Set("Origin", s.Origin)
+		r.Header.Set("Content-Type", "application/json")
+		switch kind {
+		case "origin":
+			r.Header.Set("Origin", "https://evil.example")
+		case "host":
+			r.Host = "evil.example"
+		case "metadata":
+			r.Header.Set("Sec-Fetch-Site", "cross-site")
+		case "missing-origin":
+			r.Header.Del("Origin")
+		}
+		w := httptest.NewRecorder()
+		s.Handler().ServeHTTP(w, r)
+		if w.Code != 403 {
+			t.Fatal(kind, w.Code)
+		}
+	}
+	_, name := s.Store.Public()
+	if name == "attacker" {
+		t.Fatal("cross-site state changed")
+	}
+}
+
+func TestReportDoesNotLeakPrivateState(t *testing.T) {
+	s := newTestServer(t)
+	c := login(t, s)
+	w := call(s, "GET", "/api/report", "", c)
+	if w.Code != 200 {
+		t.Fatal(w.Code)
+	}
+	id, _ := s.Store.Public()
+	for _, secret := range []string{"private-host", "192.168.10.4", id, "private_key", c.Value} {
+		if strings.Contains(w.Body.String(), secret) {
+			t.Fatal("report leaked", secret)
+		}
+	}
+	if !strings.Contains(w.Header().Get("Content-Disposition"), "attachment") {
+		t.Fatal("not downloadable")
+	}
+}
+
+func TestLogoutAndStrictJSON(t *testing.T) {
+	s := newTestServer(t)
+	c := login(t, s)
+	for _, body := range []string{`{"name":"x"} {}`, `{"name":"x","other":1}`} {
+		if call(s, "PUT", "/api/name", body, c).Code != 400 {
+			t.Fatal("accepted invalid document")
+		}
+	}
+	if call(s, "POST", "/api/logout", `{}`, c).Code != 200 {
+		t.Fatal("logout failed")
+	}
+	if call(s, "GET", "/api/status", "", c).Code != 401 {
+		t.Fatal("session survived logout")
+	}
+}
+
+func syntheticKey() string {
+	b := make([]byte, 51)
+	binary.BigEndian.PutUint32(b[:4], 11)
+	copy(b[4:15], "ssh-ed25519")
+	binary.BigEndian.PutUint32(b[15:19], 32)
+	for i := 19; i < len(b); i++ {
+		b[i] = byte(i)
+	}
+	return "ssh-ed25519 " + base64.StdEncoding.EncodeToString(b)
+}
+
+func TestSSHKeyEnrollmentRejectsCommandsAndRoot(t *testing.T) {
+	a := &AccessStore{Path: filepath.Join(t.TempDir(), "ssh-keys.json"), Users: func() []string { return []string{"operator"} }}
+	key := syntheticKey()
+	for _, bad := range []string{"command=\"sh\" " + key, key + "\n" + key, "-----BEGIN PRIVATE KEY-----", "ssh-ed25519 YQ=="} {
+		if e := a.Add("operator", "laptop", bad); e == nil {
+			t.Fatal("unsafe key accepted")
+		}
+	}
+	if e := a.Add("root", "laptop", key); e == nil {
+		t.Fatal("root accepted")
+	}
+	if e := a.Add("operator", "laptop", key+" private-comment"); e != nil {
+		t.Fatal(e)
+	}
+	if e := a.Add("operator", "laptop", key); e != nil {
+		t.Fatal(e)
+	}
+	keys, e := a.List()
+	if e != nil || len(keys) != 1 || keys[0].PublicKey != key {
+		t.Fatal(keys, e)
+	}
+	if e := a.Remove("operator", keys[0].ID); e != nil {
+		t.Fatal(e)
+	}
+	keys, _ = a.List()
+	if len(keys) != 0 {
+		t.Fatal("revocation failed")
+	}
+}
+
+func TestLinuxInventoryUsesActualMetadataWithoutSerial(t *testing.T) {
+	dir := t.TempDir()
+	for p, v := range map[string]string{"etc/os-release": "PRETTY_NAME=\"Synthetic Linux\"", "proc/meminfo": "MemTotal: 8388608 kB\nMemAvailable: 4000000 kB", "sys/bus/usb/devices/1-2/idVendor": "8086", "sys/bus/usb/devices/1-2/idProduct": "0b5c", "sys/bus/usb/devices/1-2/product": "Synthetic camera", "sys/bus/usb/devices/1-2/speed": "5000", "sys/bus/usb/devices/1-2/serial": "do-not-read"} {
+		target := filepath.Join(dir, p)
+		os.MkdirAll(filepath.Dir(target), 0700)
+		os.WriteFile(target, []byte(v), 0600)
+	}
+	v := Host(dir)
+	if v.OS != "Synthetic Linux" || *v.MemoryKiB != 8388608 || !v.USBReadable || len(v.USB) != 1 || v.USB[0].Speed != "5000" {
+		t.Fatal(v)
+	}
+	b, _ := json.Marshal(v)
+	if bytes.Contains(b, []byte("do-not-read")) {
+		t.Fatal("serial leaked")
+	}
+}
@@ -0,0 +1,233 @@
+package node
+
+import (
+	"crypto/sha256"
+	"crypto/subtle"
+	"encoding/base64"
+	"encoding/hex"
+	"encoding/json"
+	"errors"
+	"net/http"
+	"os"
+	"path/filepath"
+	"sync"
+	"time"
+)
+
+type Invitation struct {
+	ID         string `json:"id"`
+	Endpoint   string `json:"endpoint"`
+	ExpiresAt  int64  `json:"expires_at"`
+	SecretHash string `json:"secret_hash,omitempty"`
+}
+type CoreBinding struct {
+	BindingID string `json:"binding_id"`
+	CoreID    string `json:"core_id"`
+	CoreName  string `json:"core_name"`
+	Endpoint  string `json:"endpoint"`
+	CAPEM     string `json:"ca_pem"`
+	ClientPEM string `json:"client_pem"`
+	Receipt   string `json:"receipt,omitempty"`
+	OfferHash string `json:"offer_hash,omitempty"`
+	ExpiresAt int64  `json:"expires_at"`
+}
+type PairState struct {
+	Schema      string        `json:"schema"`
+	Phase       string        `json:"phase"`
+	Invitation  *Invitation   `json:"invitation,omitempty"`
+	Binding     *CoreBinding  `json:"binding,omitempty"`
+	Revocations []CoreBinding `json:"revocations,omitempty"`
+}
+type Pairing struct {
+	Sensors       *Sensors
+	mu            sync.Mutex
+	path          string
+	store         *Store
+	state         PairState
+	now           func() time.Time
+	inventory     func() Inventory
+	version       string
+	lastSeen      int64
+	connection    string
+	listenError   string
+	failureWindow int64
+	failures      int
+	clients       map[string]*http.Client
+}
+
+func OpenPairing(store *Store, dir, version string, inventory func() Inventory) (*Pairing, error) {
+	p := &Pairing{store: store, path: filepath.Join(dir, "core-binding.json"), now: time.Now, inventory: inventory, version: version, connection: "offline", clients: make(map[string]*http.Client), state: PairState{Schema: PairSchema, Phase: "unpaired"}}
+	data, e := os.ReadFile(p.path)
+	if os.IsNotExist(e) {
+		return p, nil
+	}
+	if e != nil {
+		return nil, e
+	}
+	info, e := os.Lstat(p.path)
+	if e != nil || !info.Mode().IsRegular() || info.Mode().Perm()&0077 != 0 || len(data) > 65536 {
+		return nil, errors.New("invalid Core binding permissions or size")
+	}
+	if json.Unmarshal(data, &p.state) != nil || p.state.Schema != PairSchema {
+		return nil, errors.New("invalid Core binding; recovery required")
+	}
+	switch p.state.Phase {
+	case "unpaired", "inviting", "pending", "paired", "revoked":
+	default:
+		return nil, errors.New("unknown Core binding state")
+	}
+	if (p.state.Phase == "pending" || p.state.Phase == "paired") && p.state.Binding == nil {
+		return nil, errors.New("incomplete Core binding")
+	}
+	if (p.state.Phase == "inviting" || p.state.Phase == "pending") && p.state.Invitation == nil {
+		return nil, errors.New("incomplete invitation")
+	}
+	if (p.state.Phase == "paired" || p.state.Phase == "revoked") && p.state.Invitation != nil {
+		next := p.state
+		next.Invitation = nil
+		if e := p.save(next); e != nil {
+			return nil, e
+		}
+	}
+	return p, nil
+}
+func savePrivateJSON(path string, value any) error {
+	data, e := json.Marshal(value)
+	if e != nil {
+		return e
+	}
+	f, e := os.CreateTemp(filepath.Dir(path), ".binding-*")
+	if e != nil {
+		return e
+	}
+	defer os.Remove(f.Name())
+	if _, e = f.Write(data); e != nil {
+		f.Close()
+		return e
+	}
+	if e = f.Sync(); e != nil {
+		f.Close()
+		return e
+	}
+	if e = f.Close(); e != nil {
+		return e
+	}
+	if e = os.Rename(f.Name(), path); e != nil {
+		return e
+	}
+	dir, e := os.Open(filepath.Dir(path))
+	if e != nil {
+		return e
+	}
+	defer dir.Close()
+	return dir.Sync()
+}
+func (p *Pairing) save(next PairState) error {
+	if e := savePrivateJSON(p.path, next); e != nil {
+		return e
+	}
+	p.state = next
+	return nil
+}
+func digest(value string) string { h := sha256.Sum256([]byte(value)); return hex.EncodeToString(h[:]) }
+func (p *Pairing) expire() error {
+	if (p.state.Phase == "inviting" && p.state.Invitation.ExpiresAt <= p.now().Unix()) || (p.state.Phase == "pending" && p.state.Binding.ExpiresAt <= p.now().Unix()) {
+		return p.save(PairState{Schema: PairSchema, Phase: "unpaired", Revocations: p.state.Revocations})
+	}
+	return nil
+}
+func (p *Pairing) status() map[string]any {
+	p.mu.Lock()
+	defer p.mu.Unlock()
+	_ = p.expire()
+	id, _ := p.store.Public()
+	out := map[string]any{"phase": p.state.Phase, "node_id": id, "connection": p.connection, "last_seen": p.lastSeen, "notice": p.listenError, "addresses": p.addresses(), "pending_revocations": len(p.state.Revocations)}
+	if i := p.state.Invitation; i != nil {
+		out["invitation"] = map[string]any{"id": i.ID, "endpoint": i.Endpoint, "expires_at": i.ExpiresAt}
+	}
+	if b := p.state.Binding; b != nil {
+		out["binding"] = map[string]any{"binding_id": b.BindingID, "core_id": b.CoreID, "core_name": b.CoreName, "endpoint": b.Endpoint}
+	}
+	return out
+}
+func (p *Pairing) addresses() []string {
+	result := []string{}
+	for _, network := range p.inventory().Networks {
+		if !network.Up {
+			continue
+		}
+		for _, alias := range network.Addresses {
+			address := alias
+			for i, c := range address {
+				if c == '/' {
+					address = address[:i]
+					break
+				}
+			}
+			if PrivateAddress(address) {
+				result = append(result, address)
+			}
+		}
+	}
+	return result
+}
+func (p *Pairing) invite(address string) (map[string]any, error) {
+	p.mu.Lock()
+	defer p.mu.Unlock()
+	if e := p.expire(); e != nil {
+		return nil, e
+	}
+	if p.state.Phase == "paired" || p.state.Phase == "pending" {
+		return nil, errors.New("Сначала отмените текущую привязку")
+	}
+	found := false
+	for _, a := range p.addresses() {
+		if a == address {
+			found = true
+		}
+	}
+	if !found {
+		return nil, errors.New("Выберите доступный частный адрес этого БК")
+	}
+	secret := token()
+	i := &Invitation{ID: token(), Endpoint: "https://" + address + ":" + PairPort, ExpiresAt: p.now().Add(10 * time.Minute).Unix(), SecretHash: digest(secret)}
+	if e := p.save(PairState{Schema: PairSchema, Phase: "inviting", Invitation: i, Revocations: p.state.Revocations}); e != nil {
+		return nil, e
+	}
+	p.connection = "offline"
+	p.lastSeen = 0
+	id, _ := p.store.Public()
+	code, _ := json.Marshal(map[string]any{"schema": PairSchema, "node_id": id, "id": i.ID, "endpoint": i.Endpoint, "expires_at": i.ExpiresAt, "secret": secret})
+	return map[string]any{"code": "MCN1." + base64.RawURLEncoding.EncodeToString(code), "expires_at": i.ExpiresAt}, nil
+}
+func (p *Pairing) cancel() error {
+	p.mu.Lock()
+	defer p.mu.Unlock()
+	revocations := append([]CoreBinding(nil), p.state.Revocations...)
+	if p.state.Binding != nil {
+		if len(revocations) >= 8 {
+			return errors.New("Дождитесь доставки предыдущих отзывов доверия")
+		}
+		revocations = append(revocations, *p.state.Binding)
+	}
+	p.connection = "offline"
+	p.listenError = ""
+	p.lastSeen = 0
+	return p.save(PairState{Schema: PairSchema, Phase: "unpaired", Revocations: revocations})
+}
+func (p *Pairing) checkInvitation(id, secret string) bool {
+	now := p.now().Unix()
+	if now-p.failureWindow >= 60 {
+		p.failureWindow = now
+		p.failures = 0
+	}
+	if p.failures >= 32 {
+		return false
+	}
+	i := p.state.Invitation
+	if i == nil || i.ID != id || i.ExpiresAt <= now || subtle.ConstantTimeCompare([]byte(i.SecretHash), []byte(digest(secret))) != 1 {
+		p.failures++
+		return false
+	}
+	return true
+}
@@ -0,0 +1,96 @@
+package node
+
+import (
+	"crypto/ed25519"
+	"crypto/rand"
+	"crypto/sha256"
+	"crypto/tls"
+	"crypto/x509"
+	"crypto/x509/pkix"
+	"encoding/hex"
+	"encoding/pem"
+	"errors"
+	"math/big"
+	"net"
+	"net/url"
+	"time"
+)
+
+const PairSchema = "missioncore.node-pairing/v1"
+const PairPort = "8781"
+const CorePort = "8782"
+
+func PrivateAddress(value string) bool {
+	ip := net.ParseIP(value)
+	if ip == nil || ip.To4() == nil {
+		return false
+	}
+	return ip.IsPrivate() || (ip.To4()[0] == 100 && ip.To4()[1] >= 64 && ip.To4()[1] <= 127)
+}
+func privateEndpoint(value, port string) bool {
+	u, e := url.Parse(value)
+	return e == nil && u.Scheme == "https" && u.User == nil && u.Path == "" && u.RawQuery == "" && u.Fragment == "" && u.Port() == port && PrivateAddress(u.Hostname())
+}
+func keyID(prefix string, key ed25519.PublicKey) string {
+	sum := sha256.Sum256(key)
+	return prefix + hex.EncodeToString(sum[:])
+}
+func (s *Store) pairingKey() ed25519.PrivateKey {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	return append(ed25519.PrivateKey(nil), s.state.PrivateKey...)
+}
+func bootstrapCertificate(key ed25519.PrivateKey, address string) (tls.Certificate, error) {
+	serial, e := rand.Int(rand.Reader, new(big.Int).Lsh(big.NewInt(1), 128))
+	if e != nil {
+		return tls.Certificate{}, e
+	}
+	spec := &x509.Certificate{SerialNumber: serial, Subject: pkix.Name{CommonName: "Mission Core Node"}, NotBefore: time.Now().Add(-time.Minute), NotAfter: time.Now().Add(24 * time.Hour), IPAddresses: []net.IP{net.ParseIP(address)}, KeyUsage: x509.KeyUsageDigitalSignature, ExtKeyUsage: []x509.ExtKeyUsage{x509.ExtKeyUsageServerAuth}, BasicConstraintsValid: true}
+	der, e := x509.CreateCertificate(rand.Reader, spec, spec, key.Public(), key)
+	return tls.Certificate{Certificate: [][]byte{der}, PrivateKey: key}, e
+}
+func bindingTLS(b CoreBinding, key ed25519.PrivateKey) (*tls.Config, error) {
+	if !privateEndpoint(b.Endpoint, CorePort) {
+		return nil, errors.New("Core address is not private")
+	}
+	block, _ := pem.Decode([]byte(b.CAPEM))
+	if block == nil {
+		return nil, errors.New("missing Core certificate")
+	}
+	ca, e := x509.ParseCertificate(block.Bytes)
+	if e != nil {
+		return nil, e
+	}
+	pub, ok := ca.PublicKey.(ed25519.PublicKey)
+	if !ok || keyID("core_", pub) != b.CoreID || !ca.IsCA || ca.CheckSignatureFrom(ca) != nil {
+		return nil, errors.New("Core identity mismatch")
+	}
+	block, _ = pem.Decode([]byte(b.ClientPEM))
+	if block == nil {
+		return nil, errors.New("missing client certificate")
+	}
+	cert, e := x509.ParseCertificate(block.Bytes)
+	if e != nil {
+		return nil, e
+	}
+	roots := x509.NewCertPool()
+	roots.AddCert(ca)
+	if _, e = cert.Verify(x509.VerifyOptions{Roots: roots, KeyUsages: []x509.ExtKeyUsage{x509.ExtKeyUsageClientAuth}}); e != nil {
+		return nil, e
+	}
+	nodePub, ok := cert.PublicKey.(ed25519.PublicKey)
+	if !ok || !nodePub.Equal(key.Public()) {
+		return nil, errors.New("client identity mismatch")
+	}
+	return &tls.Config{MinVersion: tls.VersionTLS13, RootCAs: roots, Certificates: []tls.Certificate{{Certificate: [][]byte{cert.Raw}, PrivateKey: key}}}, nil
+}
+
+// Once the issued credential expires, the old Core cannot accept this binding.
+func clientExpired(b CoreBinding) bool {
+	block, _ := pem.Decode([]byte(b.ClientPEM))
+	if block == nil {
+		return false
+	}
+	cert, e := x509.ParseCertificate(block.Bytes)
+	return e == nil && time.Now().After(cert.NotAfter)
+}
@@ -0,0 +1,40 @@
+package node
+
+import (
+	"net"
+	"sync"
+)
+
+// Bound unauthenticated bootstrap sockets before TLS allocates a goroutine.
+type pairingListener struct {
+	net.Listener
+	slots chan struct{}
+	done  chan struct{}
+	once  sync.Once
+}
+
+func (l *pairingListener) Accept() (net.Conn, error) {
+	select {
+	case l.slots <- struct{}{}:
+	case <-l.done:
+		return nil, net.ErrClosed
+	}
+	c, e := l.Listener.Accept()
+	if e != nil {
+		<-l.slots
+		return nil, e
+	}
+	return &pairingConn{Conn: c, release: func() { <-l.slots }}, nil
+}
+func (l *pairingListener) Close() error {
+	l.once.Do(func() { close(l.done) })
+	return l.Listener.Close()
+}
+
+type pairingConn struct {
+	net.Conn
+	release func()
+	once    sync.Once
+}
+
+func (c *pairingConn) Close() error { e := c.Conn.Close(); c.once.Do(c.release); return e }
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
DCCONSTRUCTIONS	020a878915	docs(node): reconcile release status and build provenance for 0.6.11	2026-09-06 01:39:02 +03:00
DCCONSTRUCTIONS	404285419f	fix(sensors): align device lamp with identity and refresh to end	2026-09-06 01:18:47 +03:00
DCCONSTRUCTIONS	ba0c948ca1	fix(node): show camera connectivity and remove company header marks	2026-09-06 01:05:19 +03:00
DCCONSTRUCTIONS	429b4681fe	fix(node): use compact guideline copy and plain setup checkmarks	2026-09-06 00:44:23 +03:00
DCCONSTRUCTIONS	22d69107ba	feat(node): push USB changes and preserve sensor setup across sessions	2026-09-06 00:24:48 +03:00
DCCONSTRUCTIONS	a8647c4d87	fix(node): verify D455 access and share sensor progress and recording UI	2026-09-05 23:25:11 +03:00
DCCONSTRUCTIONS	b1aaa40508	Add D455 sensor host and shared Node/Core preparation surface	2026-09-05 22:27:07 +03:00
DCCONSTRUCTIONS	3616acc648	fix(node): clear consumed invitations after confirmed pairing	2026-09-05 21:37:56 +03:00
DCCONSTRUCTIONS	e82d012907	feat(node): pair onboard computers with the Core fleet through UI	2026-09-05 21:16:13 +03:00
DCCONSTRUCTIONS	fc545f8440	docs(node): proceed to pairing with clean-install acceptance deferred	2026-09-05 20:31:43 +03:00
DCCONSTRUCTIONS	a98ef339de	fix(node): show completed setup checks with a timestamp	2026-09-05 20:11:17 +03:00
DCCONSTRUCTIONS	9062126913	fix(node): make environment progress readable from the desktop	2026-09-05 19:54:08 +03:00
DCCONSTRUCTIONS	59e14c5bc0	feat(node): configure system environment through the desktop workflow	2026-09-05 19:46:52 +03:00
DCCONSTRUCTIONS	15bb793e5e	fix(node): restore Linux network inventory and expose read failures	2026-09-05 18:47:12 +03:00
DCCONSTRUCTIONS	79911eb316	feat(node): consolidate board system views and plan fleet pairing	2026-09-05 18:35:57 +03:00
DCCONSTRUCTIONS	d696842f5d	feat(node): package Ubuntu desktop setup and trusted access	2026-09-05 17:27:59 +03:00
DCCONSTRUCTIONS	57f2537af3	Document AI Inference architecture and freeze current baseline	2026-09-05 10:05:01 +03:00
DCCONSTRUCTIONS	e56eb42507	docs: inventory Rerun customizations and upstream dependencies	2026-09-05 09:21:28 +03:00
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