fix(lab): overlay full route semantic masks

apps/control-station/src/components/simulation/SimulationUgvController.ts

@@ -24,7 +24,14 @@ const PHYSICS_PROXY_ERROR = 0.0003;
 const PHYSICS_PROXY_MAX_TRIANGLES = 240_000;
 const SERVICE_BRAKE_DECELERATION_MPS2 = 1.8;
 const COAST_DECELERATION_MPS2 = 0.18;
-const BRAKE_ATTITUDE_DAMPING = 6;
+const PARKING_BRAKE_HOLD_DECELERATION_MPS2 = 6;
+const PARKING_BRAKE_ENGAGE_SPEED_MPS = 0.08;
+const TYRE_FRICTION_SLIP = 8.5;
+const TYRE_STATIC_FRICTION_COEFFICIENT = 0.95;
+const TYRE_KINETIC_FRICTION_COEFFICIENT = 0.78;
+const TYRE_CONTACT_VELOCITY_RESPONSE_PER_SECOND = 10;
+const GRAVITY_METERS_PER_SECOND_SQUARED = 9.81;
+const MIN_TYRE_NORMAL_FORCE_NEWTONS = 1;
 const DEFAULT_ORBIT_PITCH = 0.48;
 const CAMERA_RETURN_DELAY_SECONDS = 1.2;
 const CAMERA_RETURN_DURATION_SECONDS = 2;
@@ -79,12 +86,20 @@ interface NativeTransform extends NativeObject {
   getRotation(): NativeQuaternion;
 }
 
+interface NativeRaycastInfo extends NativeObject {
+  get_m_contactNormalWS(): NativeVector3;
+  get_m_contactPointWS(): NativeVector3;
+  get_m_wheelAxleWS(): NativeVector3;
+}
+
 interface NativeWheelInfo extends NativeObject {
   set_m_suspensionStiffness(value: number): void;
   set_m_wheelsDampingRelaxation(value: number): void;
   set_m_wheelsDampingCompression(value: number): void;
   set_m_frictionSlip(value: number): void;
   set_m_rollInfluence(value: number): void;
+  get_m_wheelsSuspensionForce(): number;
+  get_m_raycastInfo(): NativeRaycastInfo;
 }
 
 interface NativeRaycastVehicle extends NativeObject {
@@ -102,6 +117,7 @@ interface NativeRaycastVehicle extends NativeObject {
   setBrake(force: number, wheel: number): void;
   setSteeringValue(value: number, wheel: number): void;
   getNumWheels(): number;
+  getWheelInfo(wheel: number): NativeWheelInfo;
   updateWheelTransform(wheel: number, interpolated: boolean): void;
   getWheelTransformWS(wheel: number): NativeTransform;
   getForwardVector(): NativeVector3;
@@ -126,6 +142,11 @@ interface NativeDynamicsWorld extends NativeObject {
   removeAction(action: NativeObject): void;
 }
 
+interface NativeRigidBody extends NativeObject {
+  applyImpulse(impulse: NativeVector3, relativePosition: NativeVector3): void;
+  setActivationState(state: number): void;
+}
+
 interface PhysicsSystemAccess {
   systems: {
     rigidbody: {
@@ -137,7 +158,7 @@ interface PhysicsSystemAccess {
 
 interface NativeRigidBodyAccess {
   rigidbody?: {
-    body: NativeObject | null;
+    body: NativeRigidBody | null;
     linearVelocity: Vec3;
     angularVelocity: Vec3;
     teleport(position: Vec3, rotation?: Vec3 | Quat): void;
@@ -192,6 +213,13 @@ export class SimulationUgvController {
   private readonly smoothedCamera = new Vec3();
   private readonly limitedLinearVelocity = new Vec3();
   private readonly limitedAngularVelocity = new Vec3();
+  private readonly tyreContactNormal = new Vec3();
+  private readonly tyreLateralDirection = new Vec3();
+  private readonly tyreLongitudinalDirection = new Vec3();
+  private readonly tyreContactPoint = new Vec3();
+  private readonly tyreRelativePosition = new Vec3();
+  private readonly tyreAngularContactVelocity = new Vec3();
+  private readonly tyreContactVelocity = new Vec3();
   private readonly spawnPosition = UGV_SPAWN_POSITION.clone();
   private orbitPointerId: number | null = null;
   private orbitPointerX = 0;
@@ -206,6 +234,8 @@ export class SimulationUgvController {
   private vehicle: NativeRaycastVehicle | null = null;
   private vehicleTuning: NativeObject | null = null;
   private vehicleRaycaster: NativeObject | null = null;
+  private tyreImpulseNative: NativeVector3 | null = null;
+  private tyreRelativePositionNative: NativeVector3 | null = null;
   private dynamicsWorld: NativeDynamicsWorld | null = null;
   private chassisMaterial: StandardMaterial | null = null;
   private wheelMaterial: StandardMaterial | null = null;
@@ -308,9 +338,27 @@ export class SimulationUgvController {
     const braking = this.pressed.has("Space");
     const rigidbody = (this.vehicleEntity as Entity & NativeRigidBodyAccess).rigidbody;
     const speedMetersPerSecond = this.vehicle.getCurrentSpeedKmHour() / 3.6;
+    const nativeForward = this.vehicle.getForwardVector();
+    const nativeForwardLength = Math.hypot(
+      nativeForward.x(),
+      nativeForward.y(),
+      nativeForward.z(),
+    );
+    const longitudinalSpeedMetersPerSecond = rigidbody && nativeForwardLength > 0.001
+      ? Math.abs(
+        (
+          rigidbody.linearVelocity.x * nativeForward.x()
+          + rigidbody.linearVelocity.y * nativeForward.y()
+          + rigidbody.linearVelocity.z * nativeForward.z()
+        ) / nativeForwardLength,
+      )
+      : Math.abs(speedMetersPerSecond);
     const maxSpeed = this.settings.maxSpeedMetersPerSecond;
     const maxTurnRate = this.settings.maxTurnRateDegrees * Math.PI / 180;
     const pureTurn = !braking && forwardInput === 0 && turnInput !== 0;
+    const holding = !braking && forwardInput === 0 && turnInput === 0;
+    const parkingBrakeEngaged = holding
+      && longitudinalSpeedMetersPerSecond <= PARKING_BRAKE_ENGAGE_SPEED_MPS;
     const desiredSpeed = forwardInput * maxSpeed;
     const speedError = desiredSpeed - speedMetersPerSecond;
     const speedResponseRange = Math.max(0.35, maxSpeed * 0.2);
@@ -325,13 +373,27 @@ export class SimulationUgvController {
     const leftCommand = clamp(forwardCommand - turnCommand, -1, 1);
     const rightCommand = clamp(forwardCommand + turnCommand, -1, 1);
     const engineForce = pureTurn ? pivotForcePerWheel : driveForcePerWheel;
+    const brakeDeceleration = braking
+      ? SERVICE_BRAKE_DECELERATION_MPS2
+      : holding
+        ? parkingBrakeEngaged
+          ? PARKING_BRAKE_HOLD_DECELERATION_MPS2
+          : COAST_DECELERATION_MPS2
+        : 0;
+    const wheelBrakeForce = this.settings.massKg * brakeDeceleration
+      / Math.max(1, this.wheelDefinitions.length);
 
     for (let index = 0; index < this.wheelDefinitions.length; index += 1) {
       const definition = this.wheelDefinitions[index];
       const command = definition.left ? leftCommand : rightCommand;
+      // Parking contact is solved below with one 2D Coulomb limit; disable the
+      // raycast vehicle's parallel friction impulse so grip is not counted twice.
+      this.vehicle.getWheelInfo(index).set_m_frictionSlip(
+        parkingBrakeEngaged ? 0 : TYRE_FRICTION_SLIP,
+      );
       this.vehicle.setSteeringValue(0, index);
       this.vehicle.applyEngineForce(command * engineForce, index);
-      this.vehicle.setBrake(0, index);
+      this.vehicle.setBrake(wheelBrakeForce, index);
       this.vehicle.updateWheelTransform(index, true);
       const transform = this.vehicle.getWheelTransformWS(index);
       const position = transform.getOrigin();
@@ -340,22 +402,21 @@ export class SimulationUgvController {
       definition.anchor.setRotation(rotation.x(), rotation.y(), rotation.z(), rotation.w());
     }
 
+    const body = rigidbody?.body ?? null;
+    if (rigidbody && body) {
+      this.applyParkingTyreContact(
+        deltaSeconds,
+        rigidbody,
+        body,
+        parkingBrakeEngaged,
+      );
+    }
+
     if (rigidbody) {
       const linearVelocity = rigidbody.linearVelocity;
       let nextLinearX = linearVelocity.x;
       let nextLinearZ = linearVelocity.z;
       let horizontalSpeed = Math.hypot(nextLinearX, nextLinearZ);
-      const coasting = !braking && forwardInput === 0 && turnInput === 0;
-      if ((braking || coasting) && horizontalSpeed > 0.001) {
-        const deceleration = braking
-          ? SERVICE_BRAKE_DECELERATION_MPS2
-          : COAST_DECELERATION_MPS2;
-        const nextSpeed = Math.max(0, horizontalSpeed - deceleration * Math.max(0, deltaSeconds));
-        const scale = nextSpeed / horizontalSpeed;
-        nextLinearX *= scale;
-        nextLinearZ *= scale;
-        horizontalSpeed = nextSpeed;
-      }
       if (pureTurn && horizontalSpeed > 0.001) {
         const pivotDamping = Math.exp(-Math.max(0, deltaSeconds) * 8);
         nextLinearX *= pivotDamping;
@@ -372,9 +433,6 @@ export class SimulationUgvController {
         rigidbody.linearVelocity = this.limitedLinearVelocity;
       }
       const angularVelocity = rigidbody.angularVelocity;
-      const attitudeDamping = braking
-        ? Math.exp(-Math.max(0, deltaSeconds) * BRAKE_ATTITUDE_DAMPING)
-        : 1;
       let nextAngularY = angularVelocity.y;
       if (pureTurn) {
         const desiredYawRate = -turnInput * maxTurnRate;
@@ -387,24 +445,137 @@ export class SimulationUgvController {
       } else if (Math.abs(angularVelocity.y) > maxTurnRate) {
         nextAngularY = Math.sign(angularVelocity.y) * maxTurnRate;
       }
-      if (attitudeDamping !== 1 || nextAngularY !== angularVelocity.y) {
+      if (nextAngularY !== angularVelocity.y) {
         this.limitedAngularVelocity.set(
-          angularVelocity.x * attitudeDamping,
+          angularVelocity.x,
           nextAngularY,
-          angularVelocity.z * attitudeDamping,
+          angularVelocity.z,
         );
         rigidbody.angularVelocity = this.limitedAngularVelocity;
       }
     }
 
-    const body = (this.vehicleEntity as Entity & NativeRigidBodyAccess).rigidbody?.body as {
-      setActivationState?: (state: number) => void;
-    } | null;
-    body?.setActivationState?.(DISABLE_DEACTIVATION);
+    body?.setActivationState(DISABLE_DEACTIVATION);
     if (this.vehicleEntity.getPosition().y < -8) this.reset();
     this.updateCamera(deltaSeconds);
   }
 
+  private applyParkingTyreContact(
+    deltaSeconds: number,
+    rigidbody: NonNullable<NativeRigidBodyAccess["rigidbody"]>,
+    body: NativeRigidBody,
+    parkingBrakeEngaged: boolean,
+  ): void {
+    if (!this.vehicle || !this.vehicleEntity || !this.tyreImpulseNative
+      || !this.tyreRelativePositionNative) return;
+
+    if (!parkingBrakeEngaged) return;
+
+    const timeStep = Math.min(Math.max(0, deltaSeconds), 1 / 30);
+    if (timeStep === 0) return;
+    const wheelEffectiveMass = this.settings.massKg
+      / Math.max(1, this.wheelDefinitions.length);
+    const chassisPosition = this.vehicleEntity.getPosition();
+
+    for (let index = 0; index < this.wheelDefinitions.length; index += 1) {
+      const wheel = this.vehicle.getWheelInfo(index);
+      const raycast = wheel.get_m_raycastInfo();
+      const normalForce = wheel.get_m_wheelsSuspensionForce();
+      if (!Number.isFinite(normalForce) || normalForce < MIN_TYRE_NORMAL_FORCE_NEWTONS) {
+        continue;
+      }
+
+      const nativeNormal = raycast.get_m_contactNormalWS();
+      this.tyreContactNormal.set(nativeNormal.x(), nativeNormal.y(), nativeNormal.z());
+      if (this.tyreContactNormal.lengthSq() < 0.001) continue;
+      this.tyreContactNormal.normalize();
+
+      const nativeAxle = raycast.get_m_wheelAxleWS();
+      this.tyreLateralDirection.set(nativeAxle.x(), nativeAxle.y(), nativeAxle.z());
+      this.tyreLateralDirection.addScaled(
+        this.tyreContactNormal,
+        -this.tyreLateralDirection.dot(this.tyreContactNormal),
+      );
+      if (this.tyreLateralDirection.lengthSq() < 0.001) continue;
+      this.tyreLateralDirection.normalize();
+      this.tyreLongitudinalDirection.cross(
+        this.tyreContactNormal,
+        this.tyreLateralDirection,
+      ).normalize();
+
+      const nativeContactPoint = raycast.get_m_contactPointWS();
+      this.tyreContactPoint.set(
+        nativeContactPoint.x(),
+        nativeContactPoint.y(),
+        nativeContactPoint.z(),
+      );
+      this.tyreRelativePosition.sub2(this.tyreContactPoint, chassisPosition);
+      this.tyreAngularContactVelocity.cross(
+        rigidbody.angularVelocity,
+        this.tyreRelativePosition,
+      );
+      this.tyreContactVelocity.add2(
+        rigidbody.linearVelocity,
+        this.tyreAngularContactVelocity,
+      );
+
+      const lateralSlipSpeed = this.tyreContactVelocity.dot(this.tyreLateralDirection);
+      const longitudinalSlipSpeed = this.tyreContactVelocity.dot(
+        this.tyreLongitudinalDirection,
+      );
+      // Static tyre friction is a contact constraint: it balances the component
+      // of gravity along the surface and damps slip at the contact patch. The
+      // force still passes through a Coulomb circle and is applied at the wheel,
+      // so the chassis remains a fully dynamic rigid body.
+      const lateralGravityAcceleration = -GRAVITY_METERS_PER_SECOND_SQUARED
+        * this.tyreLateralDirection.y;
+      const longitudinalGravityAcceleration = -GRAVITY_METERS_PER_SECOND_SQUARED
+        * this.tyreLongitudinalDirection.y;
+      const trialLateralForce = -wheelEffectiveMass * (
+        lateralGravityAcceleration
+        + TYRE_CONTACT_VELOCITY_RESPONSE_PER_SECOND * lateralSlipSpeed
+      );
+      const trialLongitudinalForce = -wheelEffectiveMass * (
+        longitudinalGravityAcceleration
+        + TYRE_CONTACT_VELOCITY_RESPONSE_PER_SECOND * longitudinalSlipSpeed
+      );
+      const staticFrictionLimit = TYRE_STATIC_FRICTION_COEFFICIENT * normalForce;
+      let lateralForce = trialLateralForce;
+      let longitudinalForce = trialLongitudinalForce;
+
+      if (Math.hypot(trialLateralForce, trialLongitudinalForce) > staticFrictionLimit) {
+        const slipSpeed = Math.hypot(lateralSlipSpeed, longitudinalSlipSpeed);
+        const kineticFrictionLimit = TYRE_KINETIC_FRICTION_COEFFICIENT * normalForce;
+        if (slipSpeed > 0.0001) {
+          lateralForce = -(lateralSlipSpeed / slipSpeed) * kineticFrictionLimit;
+          longitudinalForce = -(longitudinalSlipSpeed / slipSpeed) * kineticFrictionLimit;
+        } else {
+          const forceScale = staticFrictionLimit
+            / Math.hypot(trialLateralForce, trialLongitudinalForce);
+          lateralForce = trialLateralForce * forceScale;
+          longitudinalForce = trialLongitudinalForce * forceScale;
+        }
+      }
+
+      const lateralImpulse = lateralForce * timeStep;
+      const longitudinalImpulse = longitudinalForce * timeStep;
+      this.tyreImpulseNative.setValue(
+        this.tyreLateralDirection.x * lateralImpulse
+          + this.tyreLongitudinalDirection.x * longitudinalImpulse,
+        this.tyreLateralDirection.y * lateralImpulse
+          + this.tyreLongitudinalDirection.y * longitudinalImpulse,
+        this.tyreLateralDirection.z * lateralImpulse
+          + this.tyreLongitudinalDirection.z * longitudinalImpulse,
+      );
+      this.tyreRelativePositionNative.setValue(
+        this.tyreRelativePosition.x,
+        this.tyreRelativePosition.y,
+        this.tyreRelativePosition.z,
+      );
+      body.applyImpulse(this.tyreImpulseNative, this.tyreRelativePositionNative);
+    }
+  }
+
   private async createStaticCollisionBodies(collisionWorld: Entity): Promise<void> {
     const models = collisionWorld.findComponents("model") as ModelComponent[];
     if (models.length === 0) throw new Error("В слое коллизий нет геометрии для физики UGV.");
@@ -464,8 +635,9 @@ export class SimulationUgvController {
       type: "dynamic",
       mass: this.settings.massKg,
       friction: 0.85,
-      linearDamping: 0.08,
-      angularDamping: 0.45,
+      rollingFriction: 0.12,
+      linearDamping: 0.12,
+      angularDamping: 0.6,
     });
 
     this.chassisMaterial = createMaterial(readThemeAccent(), new Color(0.03, 0.04, 0.05));
@@ -525,7 +697,10 @@ export class SimulationUgvController {
       applyMaterial(wheelMesh, this.wheelMaterial);
       anchor.addChild(wheelMesh);
       vehicle.addChild(anchor);
-      this.wheelDefinitions.push({ ...definition, anchor });
+      this.wheelDefinitions.push({
+        ...definition,
+        anchor,
+      });
     }
 
     vehicle.setLocalPosition(this.spawnPosition);
@@ -559,12 +734,14 @@ export class SimulationUgvController {
       wheel.set_m_suspensionStiffness(24);
       wheel.set_m_wheelsDampingRelaxation(3.2);
       wheel.set_m_wheelsDampingCompression(4.8);
-      wheel.set_m_frictionSlip(5.5);
+      wheel.set_m_frictionSlip(TYRE_FRICTION_SLIP);
       wheel.set_m_rollInfluence(0.08);
     }
     this.ammo.destroy(axle);
     this.ammo.destroy(direction);
     this.ammo.destroy(connection);
+    this.tyreImpulseNative = new this.ammo.btVector3(0, 0, 0);
+    this.tyreRelativePositionNative = new this.ammo.btVector3(0, 0, 0);
 
     dynamicsWorld.addAction(nativeVehicle);
     this.vehicleEntity = vehicle;
@@ -685,9 +862,13 @@ export class SimulationUgvController {
     if (this.vehicle) runCleanup("destroy vehicle", () => this.ammo.destroy(this.vehicle as NativeObject));
     if (this.vehicleRaycaster) runCleanup("destroy vehicle raycaster", () => this.ammo.destroy(this.vehicleRaycaster as NativeObject));
     if (this.vehicleTuning) runCleanup("destroy vehicle tuning", () => this.ammo.destroy(this.vehicleTuning as NativeObject));
+    if (this.tyreImpulseNative) runCleanup("destroy tyre impulse vector", () => this.ammo.destroy(this.tyreImpulseNative as NativeObject));
+    if (this.tyreRelativePositionNative) runCleanup("destroy tyre relative-position vector", () => this.ammo.destroy(this.tyreRelativePositionNative as NativeObject));
     this.vehicle = null;
     this.vehicleRaycaster = null;
     this.vehicleTuning = null;
+    this.tyreImpulseNative = null;
+    this.tyreRelativePositionNative = null;
     this.dynamicsWorld = null;
 
     if (this.vehicleEntity) runCleanup("destroy vehicle entity", () => this.vehicleEntity?.destroy());

apps/control-station/src/core/laboratory/advancedIndex.ts

@@ -48,9 +48,13 @@ import { fetchM48SFixedClassDetectorResult } from "./m48sFixedClassDetector";
 import { fetchM48TRiskQualityResult } from "./m48tRiskQuality";
 import { fetchM49TgsFailClosedResult } from "./m49TgsFailClosed";
 import { fetchM49TgsFullShadowResult } from "./m49TgsFullShadow";
-import { fetchVegetationShadowResult } from "./vegetationShadow";
+import {
+  fetchVegetationBenchmarkResult,
+  fetchVegetationShadowResult,
+} from "./vegetationShadow";
 
 export type AdvancedLaboratoryWorkId =
+  | "lab-v1-vegetation-benchmark"
   | "lab-v1-vegetation-shadow"
   | "m48-object-centric-quality"
   | "m48-small-static-passage-regression"
@@ -102,6 +106,7 @@ export interface AdvancedLaboratoryIndexItem {
 }
 
 const WORK_IDS: readonly AdvancedLaboratoryWorkId[] = [
+  "lab-v1-vegetation-benchmark",
   "lab-v1-vegetation-shadow",
   "m48-object-centric-quality",
   "m48-small-static-passage-regression",
@@ -148,6 +153,7 @@ const WORK_IDS: readonly AdvancedLaboratoryWorkId[] = [
 ];
 
 const RESULT_PREFIX: Readonly<Record<AdvancedLaboratoryWorkId, string>> = {
+  "lab-v1-vegetation-benchmark": "lab-v1-vegetation-benchmark",
   "lab-v1-vegetation-shadow": "lab-v1-vegetation-shadow",
   "m48-object-centric-quality": "m48-object-quality-(?:pack|result)",
   "m48-small-static-passage-regression": "m48-small-static-passage-regression",
@@ -201,6 +207,7 @@ export function isAdvancedLaboratoryWorkId(
 
 export function emptyAdvancedLaboratoryResults(): AdvancedLaboratoryResults {
   return {
+    vegetationBenchmark: null,
     vegetationShadow: null,
     m47Graph: null,
     m48: null,
@@ -335,7 +342,8 @@ export function advancedLaboratoryResultAvailable(
   workId: AdvancedLaboratoryWorkId,
   results: AdvancedLaboratoryResults,
 ): boolean {
-  return workId === "lab-v1-vegetation-shadow" ? results.vegetationShadow !== null
+  return workId === "lab-v1-vegetation-benchmark" ? results.vegetationBenchmark !== null
+    : workId === "lab-v1-vegetation-shadow" ? results.vegetationShadow !== null
     : workId === "m48-object-centric-quality" ? results.m48 !== null
     : workId === "m48-small-static-passage-regression" ? results.m48SmallStatic !== null
     : workId === "m48-static-occupancy-qualification" ? results.m48StaticOccupancy !== null
@@ -393,7 +401,10 @@ export async function fetchAdvancedLaboratoryResult(
   } = {},
 ): Promise<AdvancedLaboratoryResults> {
   const results = emptyAdvancedLaboratoryResults();
-  if (workId === "lab-v1-vegetation-shadow") {
+  if (workId === "lab-v1-vegetation-benchmark") {
+    if (!resultId) throw new AdvancedLaboratoryContractError("Vegetation benchmark identity не выбрана.");
+    results.vegetationBenchmark = await fetchVegetationBenchmarkResult(resultId, { fetcher, signal });
+  } else if (workId === "lab-v1-vegetation-shadow") {
     if (!resultId) throw new AdvancedLaboratoryContractError("Vegetation LAB identity не выбрана.");
     results.vegetationShadow = await fetchVegetationShadowResult(resultId, { fetcher, signal });
   } else if (workId === "m48-object-centric-quality") {

apps/control-station/src/core/laboratory/advancedLaboratoryResults.ts

@@ -45,6 +45,7 @@ import type { M49TgsFullShadowResult } from "./m49TgsFullShadow";
 import type { VegetationShadowResult } from "./vegetationShadow";
 
 export interface AdvancedLaboratoryResults {
+  vegetationBenchmark: VegetationShadowResult | null;
   vegetationShadow: VegetationShadowResult | null;
   m47Graph: M47ReferenceGraphLabResult | null;
   m48: M48AdvancedResult | null;

apps/control-station/src/core/laboratory/advancedResults.ts

@@ -967,6 +967,7 @@ export async function fetchAdvancedLaboratoryResults({
   const e39 = settledCatalogValue(settled[7]);
   const e40 = settledCatalogValue(settled[8]);
   return {
+    vegetationBenchmark: null,
     vegetationShadow: null,
     m47Graph: null, m48: null, m48SmallStatic: null, m48StaticOccupancy: null,
     m48r3StaticOccupancy: null,

apps/control-station/src/core/laboratory/vegetationShadow.ts

@@ -1,6 +1,7 @@
 import type { LaboratoryFetch } from "./advancedResults";
 
 const RESULT_ID = /^lab-v1-vegetation-shadow-[a-f0-9]{64}$/;
+const BENCHMARK_RESULT_ID = /^lab-v1-vegetation-benchmark-[a-f0-9]{64}$/;
 const SHA256 = /^[a-f0-9]{64}$/;
 const CANDIDATES = ["ddrnet", "ppliteseg"] as const;
 const ROUTE_MODES = ["source", "ddrnet", "ppliteseg", "urban", "rural", "offroad"] as const;
@@ -55,7 +56,9 @@ export interface VegetationVideoSemanticClass {
   classId: number;
   label: string;
   colorRgb: readonly [number, number, number];
-  disposition: "prediction" | "undefined";
+  disposition: "labeled" | "ambiguous" | "prediction" | "undefined";
+  materialClass: string | null;
+  evidenceState: string | null;
 }
 
 export interface VegetationRouteVideo {
@@ -67,8 +70,77 @@ export interface VegetationRouteVideo {
   height: 600;
   centerCropXyxy: readonly [100, 0, 700, 600];
   outsideCropState: "undefined";
+  viewKind: "fine-semantic-prediction" | "coarse-material-policy-review";
+  linkedTgsResultId: string | null;
   taxonomy: readonly VegetationVideoSemanticClass[];
   aggregatePredictionPixels: readonly number[];
+  policyPresets: Readonly<Record<string, Readonly<Record<string, string>>>> | null;
+  fusionMode: "synchronised-multilayer-review" | null;
+  validFovMaskSha256: string | null;
+}
+
+export interface VegetationMixedRouteCase {
+  caseId: string;
+  phase: "rural" | "transition" | "urban";
+  sourceSequence: number;
+  sessionSeconds: number;
+  assets: Readonly<Record<"source" | "city" | "vegetation" | "tgs", string>>;
+  tgs: {
+    groundCells: number;
+    occupiedCells: number;
+    rejectedCells: number;
+    unobservedCells: number;
+  };
+}
+
+export interface VegetationMixedRouteReview {
+  sourceId: "RAVNOVES004TREE";
+  sessionId: string;
+  packId: string;
+  frameCount: 10;
+  models: {
+    city: { name: string; inferenceFps: number; endToEndP95Ms: number };
+    vegetation: { name: string; latencyP95Ms: number };
+    tgs: { name: string; latencyP95Ms: number; cellSizeM: number; radiusM: number };
+  };
+  cases: readonly VegetationMixedRouteCase[];
+}
+
+export interface VegetationFullRouteLayer {
+  name: string;
+  resultId: string;
+  frameCount: 6830;
+  taxonomy: readonly VegetationVideoSemanticClass[];
+  inferenceFps: number;
+  latencyP95Ms: number;
+  peakReservedVramBytes: number;
+}
+
+export interface VegetationFullRouteReview {
+  sourceId: "RAVNOVES004TREE";
+  sessionId: "20260828T130511Z_viewer_live";
+  sourceJobId: "recorded-camera-eb2783c5480d56bda07c8af0";
+  sourceJobInputSha256: string;
+  sourceStreamSha256: string;
+  recordedMediaSourceId: "recorded.camera.6a3945242828a038";
+  recordedMediaGenerationSha256: string;
+  frameCount: 6830;
+  width: 800;
+  height: 600;
+  timelineStartSeconds: number;
+  timelineEndSeconds: number;
+  timelineArtifact: {
+    sha256: string;
+    byteLength: number;
+  };
+  frameSourceTimesNs: readonly number[];
+  decodeRepair: {
+    repairedFrameCount: 1;
+    sequence: 6092;
+    method: "duplicate-previous-decoded-frame";
+  };
+  city: VegetationFullRouteLayer;
+  vegetation: VegetationFullRouteLayer;
 }
 
 export interface VegetationShadowResult {
@@ -80,6 +152,8 @@ export interface VegetationShadowResult {
   routeCases: readonly VegetationVisualCase[];
   validationCases: readonly VegetationVisualCase[];
   routeVideo: VegetationRouteVideo | null;
+  routeReview: VegetationMixedRouteReview | null;
+  routeFullReview: VegetationFullRouteReview | null;
   limitations: readonly string[];
   visualShadowReady: true;
   missionPolicyReadyForConfiguration: true;
@@ -186,6 +260,7 @@ function visualCaseValue(
   value: unknown,
   resultId: string,
   expectedKind: "goose" | "ravnoves",
+  endpointRoot: string,
 ): VegetationVisualCase {
   const row = objectValue(value, `vegetation.${expectedKind}.case`);
   exact(row.source_kind, expectedKind, "vegetation.case.source_kind");
@@ -204,7 +279,7 @@ function visualCaseValue(
     if (!SHA256.test(sha256) || !path.startsWith(`visual/${expectedKind}/${caseId}/`)) {
       throw new VegetationShadowContractError(`vegetation.case.assets.${key}: proof invalid.`);
     }
-    projected[key] = `/api/v1/laboratory/vegetation-shadow/${encodeURIComponent(resultId)}/assets/${path
+    projected[key] = `${endpointRoot}/${encodeURIComponent(resultId)}/assets/${path
       .split("/")
       .map(encodeURIComponent)
       .join("/")}`;
@@ -257,6 +332,9 @@ function routeVideoValue(value: unknown): VegetationRouteVideo | null {
     "vegetation.route_video.m47_reference_graph_result_id",
   );
   const baseM4ResultId = textValue(row.base_m4_result_id, "vegetation.route_video.base_m4_result_id");
+  const viewKind = row.view_kind === undefined
+    ? "fine-semantic-prediction"
+    : textValue(row.view_kind, "vegetation.route_video.view_kind");
   if (
     !/^lab-v1-ravnoves-video-ddrnet-[a-f0-9]{64}$/.test(workerResultId)
     || !/^m47-reference-graph-lab-[a-f0-9]{64}$/.test(m47ReferenceGraphResultId)
@@ -264,6 +342,15 @@ function routeVideoValue(value: unknown): VegetationRouteVideo | null {
   ) {
     throw new VegetationShadowContractError("vegetation.route_video: identity invalid.");
   }
+  if (viewKind !== "fine-semantic-prediction" && viewKind !== "coarse-material-policy-review") {
+    throw new VegetationShadowContractError("vegetation.route_video: view kind invalid.");
+  }
+  const linkedTgsResultId = viewKind === "coarse-material-policy-review"
+    ? textValue(row.linked_tgs_result_id, "vegetation.route_video.linked_tgs_result_id")
+    : null;
+  if (linkedTgsResultId && !/^m49-tgs-full-shadow-[a-f0-9]{64}$/.test(linkedTgsResultId)) {
+    throw new VegetationShadowContractError("vegetation.route_video: TGS identity invalid.");
+  }
   exact(row.frame_count, 4489, "vegetation.route_video.frame_count");
   exact(row.width, 800, "vegetation.route_video.width");
   exact(row.height, 600, "vegetation.route_video.height");
@@ -279,11 +366,9 @@ function routeVideoValue(value: unknown): VegetationRouteVideo | null {
     throw new VegetationShadowContractError("vegetation.route_video: crop contract changed.");
   }
   const taxonomy = objectValue(row.taxonomy, "vegetation.route_video.taxonomy");
-  exact(
-    taxonomy.schema_version,
-    "missioncore.lab-v1-vegetation-taxonomy/v1",
-    "vegetation.route_video.taxonomy.schema",
-  );
+  exact(taxonomy.schema_version, viewKind === "coarse-material-policy-review"
+    ? "missioncore.lab-v1-terrain-policy-taxonomy/v1"
+    : "missioncore.lab-v1-vegetation-taxonomy/v1", "vegetation.route_video.taxonomy.schema");
   const classes = arrayValue(taxonomy.classes, "vegetation.route_video.taxonomy.classes")
     .map((value, expectedId): VegetationVideoSemanticClass => {
       const item = objectValue(value, `vegetation.route_video.taxonomy[${expectedId}]`);
@@ -296,36 +381,95 @@ function routeVideoValue(value: unknown): VegetationRouteVideo | null {
       if (color.length !== 3 || color.some((channel) => channel > 255)) {
         throw new VegetationShadowContractError("vegetation.route_video: taxonomy color invalid.");
       }
-      const disposition: VegetationVideoSemanticClass["disposition"] = expectedId === 0
-        ? "undefined"
-        : "prediction";
-      if (item.disposition !== disposition) {
+      const disposition = item.disposition;
+      if (
+        disposition !== "labeled"
+        && disposition !== "ambiguous"
+        && disposition !== "prediction"
+        && disposition !== "undefined"
+      ) {
         throw new VegetationShadowContractError("vegetation.route_video: taxonomy disposition changed.");
       }
+      if (
+        viewKind === "fine-semantic-prediction"
+        && disposition !== (expectedId === 0 ? "undefined" : "prediction")
+      ) {
+        throw new VegetationShadowContractError("vegetation.route_video: fine taxonomy disposition changed.");
+      }
+      const materialClass = item.material_class === null || item.material_class === undefined
+        ? null
+        : textValue(item.material_class, `vegetation.route_video.material[${expectedId}]`);
+      const evidenceState = item.evidence_state === null || item.evidence_state === undefined
+        ? null
+        : textValue(item.evidence_state, `vegetation.route_video.evidence[${expectedId}]`);
       return {
         classId,
         label: textValue(item.label, `vegetation.route_video.label[${expectedId}]`),
         colorRgb: color as unknown as readonly [number, number, number],
         disposition,
+        materialClass,
+        evidenceState,
       };
     });
-  if (classes.length !== 64) {
-    throw new VegetationShadowContractError("vegetation.route_video: taxonomy must contain 64 classes.");
+  const expectedClassCount = viewKind === "coarse-material-policy-review" ? 10 : 64;
+  if (classes.length !== expectedClassCount) {
+    throw new VegetationShadowContractError("vegetation.route_video: taxonomy size changed.");
+  }
+  if (
+    viewKind === "coarse-material-policy-review"
+    && (classes[9]?.disposition !== "undefined" || classes[9]?.evidenceState !== "UNOBSERVED")
+  ) {
+    throw new VegetationShadowContractError("vegetation.route_video: valid-FOV class changed.");
   }
   const aggregatePredictionPixels = arrayValue(
     row.aggregate_prediction_pixels,
     "vegetation.route_video.aggregate_prediction_pixels",
   ).map((value, index) => integerValue(value, `vegetation.route_video.pixels[${index}]`));
-  if (aggregatePredictionPixels.length !== 64) {
+  if (aggregatePredictionPixels.length !== expectedClassCount) {
     throw new VegetationShadowContractError("vegetation.route_video: class accounting changed.");
   }
   const maskArchive = objectValue(row.mask_archive, "vegetation.route_video.mask_archive");
-  exact(maskArchive.path, "video/ddrnet-semantic-masks.zip", "vegetation.route_video.mask_archive.path");
+  exact(maskArchive.path, viewKind === "coarse-material-policy-review"
+    ? "video/coarse-material-policy-masks.zip"
+    : "video/ddrnet-semantic-masks.zip", "vegetation.route_video.mask_archive.path");
   const archiveSha256 = textValue(maskArchive.sha256, "vegetation.route_video.mask_archive.sha256");
   if (!SHA256.test(archiveSha256)) {
     throw new VegetationShadowContractError("vegetation.route_video: archive digest invalid.");
   }
   integerValue(maskArchive.byte_length, "vegetation.route_video.mask_archive.byte_length");
+  let policyPresets: VegetationRouteVideo["policyPresets"] = null;
+  let fusionMode: VegetationRouteVideo["fusionMode"] = null;
+  let validFovMaskSha256: string | null = null;
+  if (viewKind === "coarse-material-policy-review") {
+    const validFov = objectValue(row.valid_fov, "vegetation.route_video.valid_fov");
+    exact(validFov.mask_path, "video/valid-fov-mask.png", "vegetation.route_video.valid_fov.path");
+    validFovMaskSha256 = textValue(
+      validFov.mask_sha256,
+      "vegetation.route_video.valid_fov.sha256",
+    );
+    if (!SHA256.test(validFovMaskSha256)) {
+      throw new VegetationShadowContractError("vegetation.route_video: valid-FOV digest invalid.");
+    }
+    exact(validFov.outside_valid_fov_class_id, 9, "vegetation.route_video.valid_fov.class_id");
+    const policy = objectValue(row.policy, "vegetation.route_video.policy");
+    const presets = objectValue(policy.presets, "vegetation.route_video.policy.presets");
+    policyPresets = Object.fromEntries(Object.entries(presets).map(([presetId, rawRules]) => {
+      const rules = objectValue(rawRules, `vegetation.route_video.policy.${presetId}`);
+      return [presetId, Object.fromEntries(Object.entries(rules).map(([material, action]) => [
+        material,
+        textValue(action, `vegetation.route_video.policy.${presetId}.${material}`),
+      ]))];
+    }));
+    const fusion = objectValue(row.fusion, "vegetation.route_video.fusion");
+    exact(fusion.pixel_raster_fusion, false, "vegetation.route_video.fusion.pixel_raster_fusion");
+    exact(fusion.camera_semantic_temporal_filter, "none", "vegetation.route_video.fusion.camera_filter");
+    exact(
+      fusion.mode,
+      "synchronised-multilayer-review",
+      "vegetation.route_video.fusion.mode",
+    );
+    fusionMode = "synchronised-multilayer-review";
+  }
   return {
     workerResultId,
     m47ReferenceGraphResultId,
@@ -335,12 +479,364 @@ function routeVideoValue(value: unknown): VegetationRouteVideo | null {
     height: 600,
     centerCropXyxy: [100, 0, 700, 600],
     outsideCropState: "undefined",
+    viewKind,
+    linkedTgsResultId,
     taxonomy: classes,
     aggregatePredictionPixels,
+    policyPresets,
+    fusionMode,
+    validFovMaskSha256,
   };
 }
 
-function parseResult(value: unknown, resultId: string): VegetationShadowResult {
+function mixedRouteReviewValue(
+  value: unknown,
+  resultId: string,
+  endpointRoot: string,
+): VegetationMixedRouteReview | null {
+  if (value === null || value === undefined) return null;
+  const row = objectValue(value, "vegetation.route_review");
+  exact(row.source_id, "RAVNOVES004TREE", "vegetation.route_review.source_id");
+  exact(row.frame_count, 10, "vegetation.route_review.frame_count");
+  exact(row.ground_truth, false, "vegetation.route_review.ground_truth");
+  exact(
+    row.selection_policy,
+    "same-scene-camera-lidar-aligned-review-islands/v1",
+    "vegetation.route_review.selection_policy",
+  );
+  const packId = textValue(row.pack_id, "vegetation.route_review.pack_id");
+  if (!/^mixed-route-review-pack-[a-f0-9]{64}$/.test(packId)) {
+    throw new VegetationShadowContractError("vegetation.route_review.pack_id: identity invalid.");
+  }
+  const models = objectValue(row.models, "vegetation.route_review.models");
+  const city = objectValue(models.city, "vegetation.route_review.models.city");
+  const vegetation = objectValue(models.vegetation, "vegetation.route_review.models.vegetation");
+  const tgsModel = objectValue(models.tgs, "vegetation.route_review.models.tgs");
+  exact(city.frames, 10, "vegetation.route_review.models.city.frames");
+  exact(vegetation.frames, 10, "vegetation.route_review.models.vegetation.frames");
+  exact(tgsModel.frames, 10, "vegetation.route_review.models.tgs.frames");
+  const cases = arrayValue(row.cases, "vegetation.route_review.cases").map((raw, index) => {
+    const item = objectValue(raw, `vegetation.route_review.cases[${index}]`);
+    const caseId = textValue(item.case_id, `vegetation.route_review.cases[${index}].case_id`);
+    if (caseId !== `route-${String(index + 1).padStart(2, "0")}`) {
+      throw new VegetationShadowContractError("vegetation.route_review.case order changed.");
+    }
+    const phaseValue = item.phase;
+    if (phaseValue !== "rural" && phaseValue !== "transition" && phaseValue !== "urban") {
+      throw new VegetationShadowContractError("vegetation.route_review.phase changed.");
+    }
+    const phase: VegetationMixedRouteCase["phase"] = phaseValue;
+    const assets = objectValue(item.assets, `vegetation.route_review.cases[${index}].assets`);
+    const projected = Object.fromEntries(["source", "city", "vegetation", "tgs"].map((key) => {
+      const descriptor = objectValue(assets[key], `vegetation.route_review.assets.${key}`);
+      const path = textValue(descriptor.path, `vegetation.route_review.assets.${key}.path`);
+      const digest = textValue(descriptor.sha256, `vegetation.route_review.assets.${key}.sha256`);
+      if (!SHA256.test(digest) || !path.startsWith(`route-review/${caseId}/`)) {
+        throw new VegetationShadowContractError(`vegetation.route_review.assets.${key}: proof invalid.`);
+      }
+      return [key, `${endpointRoot}/${encodeURIComponent(resultId)}/assets/${path
+        .split("/").map(encodeURIComponent).join("/")}`];
+    })) as Record<"source" | "city" | "vegetation" | "tgs", string>;
+    const tgs = objectValue(item.tgs, `vegetation.route_review.cases[${index}].tgs`);
+    const groundCells = integerValue(tgs.ground_cells, "vegetation.route_review.tgs.ground");
+    const occupiedCells = integerValue(tgs.occupied_cells, "vegetation.route_review.tgs.occupied");
+    const rejectedCells = integerValue(tgs.rejected_cells, "vegetation.route_review.tgs.rejected");
+    const unobservedCells = integerValue(tgs.unobserved_cells, "vegetation.route_review.tgs.unobserved");
+    if (groundCells + occupiedCells + rejectedCells + unobservedCells !== 2244) {
+      throw new VegetationShadowContractError("vegetation.route_review.tgs cell accounting changed.");
+    }
+    return {
+      caseId,
+      phase,
+      sourceSequence: integerValue(item.source_sequence, "vegetation.route_review.source_sequence"),
+      sessionSeconds: numberValue(item.session_seconds, "vegetation.route_review.session_seconds"),
+      assets: projected,
+      tgs: { groundCells, occupiedCells, rejectedCells, unobservedCells },
+    };
+  });
+  if (cases.length !== 10) {
+    throw new VegetationShadowContractError("vegetation.route_review.cases: expected 10 aligned islands.");
+  }
+  return {
+    sourceId: "RAVNOVES004TREE",
+    sessionId: textValue(row.session_id, "vegetation.route_review.session_id"),
+    packId,
+    frameCount: 10,
+    models: {
+      city: {
+        name: textValue(city.name, "vegetation.route_review.models.city.name"),
+        inferenceFps: numberValue(city.inference_fps, "vegetation.route_review.models.city.fps"),
+        endToEndP95Ms: numberValue(city.end_to_end_p95_ms, "vegetation.route_review.models.city.p95"),
+      },
+      vegetation: {
+        name: textValue(vegetation.name, "vegetation.route_review.models.vegetation.name"),
+        latencyP95Ms: numberValue(vegetation.latency_p95_ms, "vegetation.route_review.models.vegetation.p95"),
+      },
+      tgs: {
+        name: textValue(tgsModel.name, "vegetation.route_review.models.tgs.name"),
+        latencyP95Ms: numberValue(tgsModel.latency_p95_ms, "vegetation.route_review.models.tgs.p95"),
+        cellSizeM: numberValue(tgsModel.cell_size_m, "vegetation.route_review.models.tgs.cell"),
+        radiusM: numberValue(tgsModel.radius_m, "vegetation.route_review.models.tgs.radius"),
+      },
+    },
+    cases,
+  };
+}
+
+function fullRouteTaxonomyValue(
+  value: unknown,
+  label: string,
+  schema: string,
+  classCount: number,
+): readonly VegetationVideoSemanticClass[] {
+  const taxonomy = objectValue(value, `${label}.taxonomy`);
+  exact(taxonomy.schema_version, schema, `${label}.taxonomy.schema`);
+  const classes = arrayValue(taxonomy.classes, `${label}.taxonomy.classes`).map(
+    (raw, expectedId): VegetationVideoSemanticClass => {
+      const item = objectValue(raw, `${label}.taxonomy[${expectedId}]`);
+      const classId = integerValue(item.class_id, `${label}.class_id[${expectedId}]`);
+      if (classId !== expectedId) {
+        throw new VegetationShadowContractError(`${label}: taxonomy order changed.`);
+      }
+      const color = arrayValue(item.color_rgb, `${label}.color[${expectedId}]`)
+        .map((channel, index) => integerValue(channel, `${label}.color[${expectedId}][${index}]`));
+      if (color.length !== 3 || color.some((channel) => channel > 255)) {
+        throw new VegetationShadowContractError(`${label}: taxonomy color invalid.`);
+      }
+      const disposition = item.disposition;
+      if (
+        disposition !== "labeled"
+        && disposition !== "ambiguous"
+        && disposition !== "prediction"
+        && disposition !== "undefined"
+      ) {
+        throw new VegetationShadowContractError(`${label}: taxonomy disposition changed.`);
+      }
+      return {
+        classId,
+        label: textValue(item.label, `${label}.label[${expectedId}]`),
+        colorRgb: color as unknown as readonly [number, number, number],
+        disposition,
+        materialClass: item.material_class === null || item.material_class === undefined
+          ? null
+          : textValue(item.material_class, `${label}.material[${expectedId}]`),
+        evidenceState: item.evidence_state === null || item.evidence_state === undefined
+          ? null
+          : textValue(item.evidence_state, `${label}.evidence[${expectedId}]`),
+      };
+    },
+  );
+  if (classes.length !== classCount) {
+    throw new VegetationShadowContractError(`${label}: taxonomy size changed.`);
+  }
+  return classes;
+}
+
+function fullRouteLayerValue(
+  value: unknown,
+  layer: "city" | "vegetation",
+): VegetationFullRouteLayer {
+  const label = `vegetation.route_full_review.layers.${layer}`;
+  const row = objectValue(value, label);
+  const resultId = textValue(row.result_id, `${label}.result_id`);
+  const identity = layer === "city"
+    ? /^result-[a-f0-9]{64}$/
+    : /^lab-v1-ravnoves-video-ddrnet-[a-f0-9]{64}$/;
+  if (!identity.test(resultId)) {
+    throw new VegetationShadowContractError(`${label}: identity invalid.`);
+  }
+  exact(row.frame_count, 6830, `${label}.frame_count`);
+  const archive = objectValue(row.mask_archive, `${label}.mask_archive`);
+  exact(
+    archive.path,
+    layer === "city" ? "video/eomt-semantic-masks.zip" : "video/ddrnet-semantic-masks.zip",
+    `${label}.mask_archive.path`,
+  );
+  const digest = textValue(archive.sha256, `${label}.mask_archive.sha256`);
+  if (!SHA256.test(digest)) {
+    throw new VegetationShadowContractError(`${label}: archive digest invalid.`);
+  }
+  integerValue(archive.byte_length, `${label}.mask_archive.byte_length`);
+  return {
+    name: textValue(row.name, `${label}.name`),
+    resultId,
+    frameCount: 6830,
+    taxonomy: fullRouteTaxonomyValue(
+      row.taxonomy,
+      label,
+      layer === "city"
+        ? "missioncore.recorded-eomt-taxonomy/v1"
+        : "missioncore.lab-v1-vegetation-taxonomy/v1",
+      layer === "city" ? 16 : 64,
+    ),
+    inferenceFps: numberValue(row.inference_fps, `${label}.inference_fps`),
+    latencyP95Ms: numberValue(row.latency_p95_ms, `${label}.latency_p95_ms`),
+    peakReservedVramBytes: integerValue(
+      row.peak_reserved_vram_bytes,
+      `${label}.peak_reserved_vram_bytes`,
+    ),
+  };
+}
+
+function fullRouteReviewValue(value: unknown): VegetationFullRouteReview | null {
+  if (value === null || value === undefined) return null;
+  const row = objectValue(value, "vegetation.route_full_review");
+  exact(row.source_id, "RAVNOVES004TREE", "vegetation.route_full_review.source_id");
+  exact(
+    row.session_id,
+    "20260828T130511Z_viewer_live",
+    "vegetation.route_full_review.session_id",
+  );
+  exact(
+    row.source_job_id,
+    "recorded-camera-eb2783c5480d56bda07c8af0",
+    "vegetation.route_full_review.source_job_id",
+  );
+  exact(row.frame_count, 6830, "vegetation.route_full_review.frame_count");
+  exact(row.width, 800, "vegetation.route_full_review.width");
+  exact(row.height, 600, "vegetation.route_full_review.height");
+  exact(row.ground_truth, false, "vegetation.route_full_review.ground_truth");
+  const sourceJobInputSha256 = textValue(
+    row.source_job_input_sha256,
+    "vegetation.route_full_review.source_job_input_sha256",
+  );
+  const sourceStreamSha256 = textValue(
+    row.source_stream_sha256,
+    "vegetation.route_full_review.source_stream_sha256",
+  );
+  exact(
+    sourceJobInputSha256,
+    "eb2783c5480d56bda07c8af008dff5344d19dc550ef70fe2075d6f098f7cc715",
+    "vegetation.route_full_review.source_job_input_sha256",
+  );
+  exact(
+    sourceStreamSha256,
+    "e5eb017e2cc0f546736eda5235ca157b501913093cb64af5e548e335417e1bac",
+    "vegetation.route_full_review.source_stream_sha256",
+  );
+  exact(
+    row.recorded_media_source_id,
+    "recorded.camera.6a3945242828a038",
+    "vegetation.route_full_review.recorded_media_source_id",
+  );
+  const recordedMediaGenerationSha256 = textValue(
+    row.recorded_media_generation_sha256,
+    "vegetation.route_full_review.recorded_media_generation_sha256",
+  );
+  exact(
+    recordedMediaGenerationSha256,
+    "b073ea1e7babf1c77a664e1a5b95e3702d0e05b0e34c1e85a7c67a6f8b392ded",
+    "vegetation.route_full_review.recorded_media_generation_sha256",
+  );
+  if (
+    !SHA256.test(sourceJobInputSha256)
+    || !SHA256.test(sourceStreamSha256)
+    || !SHA256.test(recordedMediaGenerationSha256)
+  ) {
+    throw new VegetationShadowContractError("vegetation.route_full_review: source digest invalid.");
+  }
+  const timelineStartSeconds = numberValue(
+    row.timeline_start_seconds,
+    "vegetation.route_full_review.timeline_start_seconds",
+  );
+  const timelineEndSeconds = numberValue(
+    row.timeline_end_seconds,
+    "vegetation.route_full_review.timeline_end_seconds",
+  );
+  if (timelineEndSeconds <= timelineStartSeconds) {
+    throw new VegetationShadowContractError("vegetation.route_full_review: timeline invalid.");
+  }
+  const timeline = objectValue(row.timeline, "vegetation.route_full_review.timeline");
+  exact(
+    timeline.path,
+    "video/frame-source-times-ns.bin",
+    "vegetation.route_full_review.timeline.path",
+  );
+  exact(
+    timeline.encoding,
+    "uint64-le-nanoseconds",
+    "vegetation.route_full_review.timeline.encoding",
+  );
+  exact(timeline.frame_count, 6830, "vegetation.route_full_review.timeline.frame_count");
+  const timelineSha256 = textValue(
+    timeline.sha256,
+    "vegetation.route_full_review.timeline.sha256",
+  );
+  if (!SHA256.test(timelineSha256)) {
+    throw new VegetationShadowContractError("vegetation.route_full_review: timeline digest invalid.");
+  }
+  const timelineByteLength = integerValue(
+    timeline.byte_length,
+    "vegetation.route_full_review.timeline.byte_length",
+  );
+  exact(timelineByteLength, 6830 * 8, "vegetation.route_full_review.timeline.byte_length");
+  const decodeRepair = objectValue(
+    row.decode_repair,
+    "vegetation.route_full_review.decode_repair",
+  );
+  exact(decodeRepair.repaired_frame_count, 1, "vegetation.route_full_review.decode_repair.count");
+  exact(decodeRepair.sequence, 6092, "vegetation.route_full_review.decode_repair.sequence");
+  exact(
+    decodeRepair.method,
+    "duplicate-previous-decoded-frame",
+    "vegetation.route_full_review.decode_repair.method",
+  );
+  const repairProofs = objectValue(
+    decodeRepair.proofs,
+    "vegetation.route_full_review.decode_repair.proofs",
+  );
+  for (const [key, expectedPath] of Object.entries({
+    eomt: "proofs/decode_repair.json",
+    ddrnet: "proofs/ddrnet_decode_repair.json",
+  })) {
+    const proof = objectValue(
+      repairProofs[key],
+      `vegetation.route_full_review.decode_repair.proofs.${key}`,
+    );
+    exact(
+      proof.path,
+      expectedPath,
+      `vegetation.route_full_review.decode_repair.proofs.${key}.path`,
+    );
+    const digest = textValue(
+      proof.sha256,
+      `vegetation.route_full_review.decode_repair.proofs.${key}.sha256`,
+    );
+    if (!SHA256.test(digest)) {
+      throw new VegetationShadowContractError("vegetation.route_full_review: repair proof invalid.");
+    }
+  }
+  const layers = objectValue(row.layers, "vegetation.route_full_review.layers");
+  return {
+    sourceId: "RAVNOVES004TREE",
+    sessionId: "20260828T130511Z_viewer_live",
+    sourceJobId: "recorded-camera-eb2783c5480d56bda07c8af0",
+    sourceJobInputSha256,
+    sourceStreamSha256,
+    recordedMediaSourceId: "recorded.camera.6a3945242828a038",
+    recordedMediaGenerationSha256,
+    frameCount: 6830,
+    width: 800,
+    height: 600,
+    timelineStartSeconds,
+    timelineEndSeconds,
+    timelineArtifact: { sha256: timelineSha256, byteLength: timelineByteLength },
+    frameSourceTimesNs: [],
+    decodeRepair: {
+      repairedFrameCount: 1,
+      sequence: 6092,
+      method: "duplicate-previous-decoded-frame",
+    },
+    city: fullRouteLayerValue(layers.city, "city"),
+    vegetation: fullRouteLayerValue(layers.vegetation, "vegetation"),
+  };
+}
+
+function parseResult(
+  value: unknown,
+  resultId: string,
+  endpointRoot: string,
+): VegetationShadowResult {
   const payload = objectValue(value, "Vegetation LAB");
   exact(payload.schema_version, "missioncore.lab-v1-vegetation-shadow/v1", "vegetation.schema");
   exact(payload.result_id, resultId, "vegetation.result_id");
@@ -376,10 +872,15 @@ function parseResult(value: unknown, resultId: string): VegetationShadowResult {
     "vegetation.authority.camera_semantics_can_clear_rigid_geometry",
   );
   const routeCases = arrayValue(catalogs.ravnoves, "vegetation.catalogs.ravnoves")
-    .map((item) => visualCaseValue(item, resultId, "ravnoves"));
+    .map((item) => visualCaseValue(item, resultId, "ravnoves", endpointRoot));
   const validationCases = arrayValue(catalogs.goose, "vegetation.catalogs.goose")
-    .map((item) => visualCaseValue(item, resultId, "goose"));
-  if (routeCases.length !== 0 || validationCases.length !== 12) {
+    .map((item) => visualCaseValue(item, resultId, "goose", endpointRoot));
+  const routeReview = mixedRouteReviewValue(payload.route_review, resultId, endpointRoot);
+  const routeFullReview = fullRouteReviewValue(payload.route_full_review);
+  if (
+    routeCases.length !== 0
+    || (routeReview || routeFullReview ? validationCases.length !== 0 : validationCases.length !== 12)
+  ) {
     throw new VegetationShadowContractError("vegetation.catalogs: ожидалось 12 truth-backed GOOSE случаев без route viewer.");
   }
   return {
@@ -391,6 +892,8 @@ function parseResult(value: unknown, resultId: string): VegetationShadowResult {
     routeCases,
     validationCases,
     routeVideo: routeVideoValue(payload.route_video),
+    routeReview,
+    routeFullReview,
     limitations: arrayValue(payload.limitations, "vegetation.limitations")
       .map((item, index) => textValue(item, `vegetation.limitations[${index}]`)),
     visualShadowReady: true,
@@ -411,6 +914,23 @@ export function vegetationVideoMaskUrl(resultId: string, sequence: number): stri
   return `/api/v1/laboratory/vegetation-shadow/${encodeURIComponent(resultId)}/masks/${sequence}`;
 }
 
+export function vegetationFullRouteMaskUrl(
+  resultId: string,
+  layer: "city" | "vegetation",
+  sequence: number,
+): string {
+  if (
+    !RESULT_ID.test(resultId)
+    || (layer !== "city" && layer !== "vegetation")
+    || !Number.isInteger(sequence)
+    || sequence < 0
+    || sequence >= 6830
+  ) {
+    throw new VegetationShadowContractError("Vegetation full-route mask identity недопустима.");
+  }
+  return `/api/v1/laboratory/vegetation-shadow/${encodeURIComponent(resultId)}/route-masks/${layer}/${sequence}`;
+}
+
 export async function fetchVegetationShadowResult(
   resultId: string,
   {
@@ -428,5 +948,74 @@ export async function fetchVegetationShadowResult(
   if (!response.ok) {
     throw new VegetationShadowContractError(`Vegetation LAB недоступна: HTTP ${response.status}.`);
   }
-  return parseResult(await response.json(), resultId);
+  const result = parseResult(
+    await response.json(),
+    resultId,
+    "/api/v1/laboratory/vegetation-shadow",
+  );
+  if (!result.routeFullReview) return result;
+  const timelineResponse = await fetcher(
+    `/api/v1/laboratory/vegetation-shadow/${encodeURIComponent(resultId)}/route-timeline`,
+    { method: "GET", headers: { Accept: "application/octet-stream" }, signal },
+  );
+  if (!timelineResponse.ok) {
+    throw new VegetationShadowContractError(
+      `Vegetation LAB timeline недоступна: HTTP ${timelineResponse.status}.`,
+    );
+  }
+  if (
+    timelineResponse.headers.get("etag")
+    !== `"${result.routeFullReview.timelineArtifact.sha256}"`
+  ) {
+    throw new VegetationShadowContractError("Vegetation LAB timeline digest изменён.");
+  }
+  const timelinePayload = await timelineResponse.arrayBuffer();
+  if (timelinePayload.byteLength !== result.routeFullReview.timelineArtifact.byteLength) {
+    throw new VegetationShadowContractError("Vegetation LAB timeline size изменён.");
+  }
+  const timelineView = new DataView(timelinePayload);
+  const frameSourceTimesNs = Array.from({ length: result.routeFullReview.frameCount }, (_, index) => {
+    const value = Number(timelineView.getBigUint64(index * 8, true));
+    if (!Number.isSafeInteger(value)) {
+      throw new VegetationShadowContractError("Vegetation LAB timeline содержит unsafe time.");
+    }
+    return value;
+  });
+  if (
+    frameSourceTimesNs[0] !== Math.round(result.routeFullReview.timelineStartSeconds * 1_000_000_000)
+    || frameSourceTimesNs.some((time, index) => index > 0 && time <= frameSourceTimesNs[index - 1]!)
+  ) {
+    throw new VegetationShadowContractError("Vegetation LAB timeline нарушена.");
+  }
+  return {
+    ...result,
+    routeFullReview: { ...result.routeFullReview, frameSourceTimesNs },
+  };
+}
+
+export async function fetchVegetationBenchmarkResult(
+  resultId: string,
+  {
+    fetcher = fetch,
+    signal,
+  }: { fetcher?: LaboratoryFetch; signal?: AbortSignal } = {},
+): Promise<VegetationShadowResult> {
+  if (!BENCHMARK_RESULT_ID.test(resultId)) {
+    throw new VegetationShadowContractError("Vegetation benchmark identity недопустима.");
+  }
+  const endpointRoot = "/api/v1/laboratory/vegetation-benchmark";
+  const response = await fetcher(
+    `${endpointRoot}/${encodeURIComponent(resultId)}`,
+    { method: "GET", headers: { Accept: "application/json" }, signal },
+  );
+  if (!response.ok) {
+    throw new VegetationShadowContractError(
+      `Vegetation benchmark недоступен: HTTP ${response.status}.`,
+    );
+  }
+  const result = parseResult(await response.json(), resultId, endpointRoot);
+  if (result.routeVideo) {
+    throw new VegetationShadowContractError("Vegetation benchmark содержит route video.");
+  }
+  return result;
 }

apps/control-station/src/styles/m4-replay-threat.css

@@ -81,6 +81,21 @@
   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"] {

apps/control-station/src/workspaces/laboratory/AdvancedLaboratoryResult.tsx

@@ -51,6 +51,7 @@ import { M48TRiskQualityResultView } from "./M48TRiskQualityResult";
 import { M49TgsFailClosedResultView } from "./M49TgsFailClosedResult";
 import { M49TgsFullShadowResultView } from "./M49TgsFullShadowResult";
 import { VegetationShadowResultView } from "./VegetationShadowResult";
+import { VegetationBenchmarkResultView } from "./VegetationBenchmarkResult";
 
 export { isAdvancedLaboratoryWorkId };
 export type { AdvancedLaboratoryWorkId };
@@ -93,6 +94,9 @@ export function AdvancedLaboratoryResult({
   failedSessionId: string | null;
   replayError: string | null;
 }) {
+  if (workId === "lab-v1-vegetation-benchmark" && results.vegetationBenchmark) {
+    return <VegetationBenchmarkResultView rigLabel={rigLabel} result={results.vegetationBenchmark} />;
+  }
   if (workId === "lab-v1-vegetation-shadow" && results.vegetationShadow) {
     return <VegetationShadowResultView rigLabel={rigLabel} result={results.vegetationShadow} />;
   }

apps/control-station/src/workspaces/laboratory/M49TgsFullShadowEvidence.tsx

@@ -22,6 +22,7 @@ import {
 import {
   M4ReplayThreatVisual,
   type M4ReplayClassifiedSpatialFrame,
+  type M4ReplayThreatSemanticLayer,
 } from "./M4ReplayThreatVisual";
 
 const CLASSES: readonly RecordedEvidenceSemanticClass[] = [
@@ -42,7 +43,15 @@ function message(error: unknown): string {
     : "Полный TGS spatial frame недоступен.";
 }
 
-export function M49TgsFullShadowEvidence({ result }: { result: M49TgsFullShadowResult }) {
+export function M49TgsFullShadowEvidence({
+  result,
+  semanticOverride,
+  evidenceLabel = "M49 · full TGS shadow",
+}: {
+  result: M49TgsFullShadowResult;
+  semanticOverride?: M4ReplayThreatSemanticLayer;
+  evidenceLabel?: string;
+}) {
   const [activeSequence, setActiveSequence] = useState<number | null>(null);
   const [semantic, setSemantic] = useState<E47SemanticSlamResult | null>(null);
   const [semanticError, setSemanticError] = useState<string | null>(null);
@@ -191,18 +200,31 @@ export function M49TgsFullShadowEvidence({ result }: { result: M49TgsFullShadowR
   const handleSequenceChange = useCallback((sequence: number | null) => {
     setActiveSequence(sequence);
   }, []);
+  const semanticLayers = useMemo<readonly M4ReplayThreatSemanticLayer[]>(() => [
+    ...(semantic ? [{
+      id: "urban",
+      controlLabel: "ГОРОД · EoMT",
+      resultId: semantic.resultId,
+      taxonomy: semantic.taxonomy,
+      label: "EoMT Cityscapes semantic · recorded video",
+      maskAriaLabel: "EoMT urban semantic prediction",
+    }] : []),
+    ...(semanticOverride ? [{
+      ...semanticOverride,
+      id: semanticOverride.id ?? "vegetation",
+      controlLabel: semanticOverride.controlLabel ?? "ПРИРОДА · DDRNet",
+    }] : []),
+  ], [semantic, semanticOverride]);
 
   return (
     <>
       <M4ReplayThreatVisual
         resultId={result.source.linkedVisualResultId}
-        semantic={semantic ? {
-          resultId: semantic.resultId,
-          taxonomy: semantic.taxonomy,
-        } : undefined}
+        semanticLayers={semanticLayers}
+        initialSemanticLayerId={semanticOverride ? "vegetation" : "urban"}
         showReviewAnchorBoxes={false}
         reviewLabel="4 489 source-paced TGS frames"
-        evidenceLabel="M49 · full TGS shadow"
+        evidenceLabel={evidenceLabel}
         initialSpatialMode="3d"
         onActiveSequenceChange={handleSequenceChange}
         classifiedSpatialLayer={{

apps/control-station/src/workspaces/laboratory/M4ReplayThreatVisual.tsx

@@ -96,6 +96,8 @@ function SpatialState({ message: text }: { message: string }) {
 }
 
 export interface M4ReplayThreatSemanticLayer {
+  id?: string;
+  controlLabel?: string;
   resultId: string;
   spatialResultId?: string | null;
   maskUrl?: (sequence: number) => string;
@@ -155,6 +157,8 @@ const EMPTY_REVIEW_ANCHORS: readonly M4ReplayThreatReviewAnchor[] = [];
 export function M4ReplayThreatVisual({
   resultId,
   semantic,
+  semanticLayers,
+  initialSemanticLayerId,
   reviewAnchors = EMPTY_REVIEW_ANCHORS,
   showReviewAnchorBoxes = true,
   reviewLabel = "Контрольные примеры M4.8R1",
@@ -168,6 +172,8 @@ export function M4ReplayThreatVisual({
 }: {
   resultId: string;
   semantic?: M4ReplayThreatSemanticLayer;
+  semanticLayers?: readonly M4ReplayThreatSemanticLayer[];
+  initialSemanticLayerId?: string;
   reviewAnchors?: readonly M4ReplayThreatReviewAnchor[];
   showReviewAnchorBoxes?: boolean;
   reviewLabel?: string;
@@ -199,6 +205,35 @@ export function M4ReplayThreatVisual({
   ));
   const [expanded, setExpanded] = useState(false);
   const [selectedReviewAnchorIndex, setSelectedReviewAnchorIndex] = useState(0);
+  const availableSemanticLayers = useMemo<readonly M4ReplayThreatSemanticLayer[]>(
+    () => semanticLayers?.length ? semanticLayers : semantic ? [semantic] : [],
+    [semantic, semanticLayers],
+  );
+  const semanticLayerIdentity = availableSemanticLayers
+    .map((layer, index) => layer.id ?? `${layer.resultId}:${index}`)
+    .join("|");
+  const [selectedSemanticLayerId, setSelectedSemanticLayerId] = useState(
+    initialSemanticLayerId ?? "",
+  );
+  useEffect(() => {
+    if (!availableSemanticLayers.length) {
+      setSelectedSemanticLayerId("");
+      return;
+    }
+    const selectedStillExists = availableSemanticLayers.some(
+      (layer, index) => (layer.id ?? `${layer.resultId}:${index}`) === selectedSemanticLayerId,
+    );
+    if (selectedStillExists) return;
+    const preferred = initialSemanticLayerId
+      ? availableSemanticLayers.find((layer) => layer.id === initialSemanticLayerId)
+      : null;
+    const next = preferred ?? availableSemanticLayers[0]!;
+    const nextIndex = availableSemanticLayers.indexOf(next);
+    setSelectedSemanticLayerId(next.id ?? `${next.resultId}:${nextIndex}`);
+  }, [availableSemanticLayers, initialSemanticLayerId, semanticLayerIdentity, selectedSemanticLayerId]);
+  const activeSemantic = availableSemanticLayers.find(
+    (layer, index) => (layer.id ?? `${layer.resultId}:${index}`) === selectedSemanticLayerId,
+  ) ?? availableSemanticLayers[0];
   const metricSceneRef = useRef<LaboratoryMetricEvidenceSceneHandle | null>(null);
   const metadata = useM4ThreatTimelineMetadata(resultId, timelineEndpointRoot);
   const playbackRange = useMemo(() => metadata.timeline ? ({
@@ -298,19 +333,21 @@ export function M4ReplayThreatVisual({
     sequence: frame?.sequence ?? null,
     endpointRoot: timelineEndpointRoot,
   });
-  const semanticSpatialResultId = semantic
-    ? semantic.spatialResultId === undefined ? semantic.resultId : semantic.spatialResultId
+  const semanticSpatialResultId = activeSemantic
+    ? activeSemantic.spatialResultId === undefined
+      ? activeSemantic.resultId
+      : activeSemantic.spatialResultId
     : null;
   const spatialSemanticTaxonomy = useMemo<readonly E47SemanticClass[]>(
-    () => semanticSpatialResultId && semantic
-      ? semantic.taxonomy.map((item) => ({
+    () => semanticSpatialResultId && activeSemantic
+      ? activeSemantic.taxonomy.map((item) => ({
           classId: item.classId,
           label: item.label,
           disposition: item.disposition === "ambiguous" ? "ambiguous" : "labeled",
           colorRgb: item.colorRgb,
         }))
       : [],
-    [semantic, semanticSpatialResultId],
+    [activeSemantic, semanticSpatialResultId],
   );
   const semanticTimeline = useE47SemanticTimelineFrame({
     resultId: semanticSpatialResultId,
@@ -378,22 +415,22 @@ export function M4ReplayThreatVisual({
     );
   }, [frame, metadata.timeline, showReferenceMediaLayers, showStaticObstacles]);
   const activeBoxes = useMemo(
-    () => classifiedSpatialLayer || !showReferenceMediaLayers ? [] : [
+    () => !showReferenceMediaLayers ? [] : [
       ...boxes(frame?.cameraProposals ?? []),
       ...staticObstacleBoxes,
       ...reviewAnchorBoxes,
     ],
-    [classifiedSpatialLayer, frame, reviewAnchorBoxes, showReferenceMediaLayers, staticObstacleBoxes],
+    [frame, reviewAnchorBoxes, showReferenceMediaLayers, staticObstacleBoxes],
   );
   const semanticClasses = useMemo<readonly RecordedEvidenceSemanticClass[]>(
-    () => semantic?.taxonomy.map((item) => ({
+    () => activeSemantic?.taxonomy.map((item) => ({
       id: item.classId,
       label: `semantic: ${item.label}`,
     })) ?? [],
-    [semantic?.taxonomy],
+    [activeSemantic?.taxonomy],
   );
   const semanticPalette = useMemo<readonly RecordedEvidenceSemanticPaletteEntry[]>(
-    () => semantic?.taxonomy.map((item) => ({
+    () => activeSemantic?.taxonomy.map((item) => ({
       classId: item.classId,
       color: item.disposition === "undefined"
         ? { kind: "transparent" as const }
@@ -404,7 +441,7 @@ export function M4ReplayThreatVisual({
         ? 0
         : item.disposition === "ambiguous" ? 0.52 : 0.92,
     })) ?? [],
-    [semantic?.taxonomy],
+    [activeSemantic?.taxonomy],
   );
   const semanticFrame = semanticTimeline.activeFrame?.sequence === frame?.sequence
     ? semanticTimeline.activeFrame
@@ -422,7 +459,7 @@ export function M4ReplayThreatVisual({
       && lastSpatialSemanticFrameRef.current.frame.sequence === spatialFrame?.sequence
       ? lastSpatialSemanticFrameRef.current.frame
       : null;
-  const semanticIntegrityError = semantic && spatialFrame && spatialSemanticFrame && (
+  const semanticIntegrityError = activeSemantic && spatialFrame && spatialSemanticFrame && (
     spatialSemanticFrame.sourcePointCount !== spatialFrame.pointCloudSourceCount
     || spatialFrame.pointCloudSampleCount !== spatialFrame.pointCloudSourceCount
     || spatialFrame.pointCloudBodyXyzM.length !== spatialFrame.pointCloudSourceCount
@@ -431,7 +468,7 @@ export function M4ReplayThreatVisual({
     : null;
   const alignedSemanticPointIds = useMemo<readonly (number | null)[] | undefined>(() => {
     if (
-      !semantic
+      !activeSemantic
       || !showSpatialSemantic
       || !spatialFrame
       || !spatialSemanticFrame
@@ -441,7 +478,7 @@ export function M4ReplayThreatVisual({
       const status = spatialSemanticFrame.statusCodes[index];
       return status === 2 || status === 3 ? classId : null;
     });
-  }, [semantic, semanticIntegrityError, showSpatialSemantic, spatialFrame, spatialSemanticFrame]);
+  }, [activeSemantic, semanticIntegrityError, showSpatialSemantic, spatialFrame, spatialSemanticFrame]);
   const activeSpatialFrame = spatialFrame?.sequence === timelineFrame.activeSequence
     ? spatialFrame
     : null;
@@ -610,19 +647,19 @@ export function M4ReplayThreatVisual({
     },
   ), [metadata.timeline, spatialFrame, timelineFrame.availableFrames]);
   const semanticOverlay: RecordedEvidenceSemanticOverlay | undefined =
-    semantic && showMediaSemantic && frame
+    activeSemantic && showMediaSemantic && frame
       ? {
-          src: semantic.maskUrl?.(frame.sequence)
-            ?? e47SemanticMaskUrl(semantic.resultId, frame.sequence),
+          src: activeSemantic.maskUrl?.(frame.sequence)
+            ?? e47SemanticMaskUrl(activeSemantic.resultId, frame.sequence),
           prefetchSrcs: Array.from({ length: 12 }, (_, index) => index + 1)
             .map((offset) => frame.sequence + offset)
             .filter((sequence) => sequence < (metadata.timeline?.frameCount ?? 0))
-            .map((sequence) => semantic.maskUrl?.(sequence)
-              ?? e47SemanticMaskUrl(semantic.resultId, sequence)),
+            .map((sequence) => activeSemantic.maskUrl?.(sequence)
+              ?? e47SemanticMaskUrl(activeSemantic.resultId, sequence)),
           classes: semanticClasses,
           palette: semanticPalette,
           opacity: 0.9,
-          ariaLabel: `${semantic.maskAriaLabel ?? "Semantic prediction"} frame ${frame.sequence + 1}`,
+          ariaLabel: `${activeSemantic.maskAriaLabel ?? "Semantic prediction"} frame ${frame.sequence + 1}`,
         }
       : undefined;
   const accumulatedCameraPoints = cameraPointOverlay.overlay?.sequence === frame?.sequence
@@ -692,7 +729,7 @@ export function M4ReplayThreatVisual({
     </div>
   );
 
-  const mediaLayerControls = semantic
+  const mediaLayerControls = activeSemantic
     || (showReferenceMediaLayers && metadata.timeline?.cameraPointDelivery)
     || (showReferenceMediaLayers && metadata.timeline?.cameraObstacleProjectionDelivery) ? (
     <div
@@ -700,7 +737,7 @@ export function M4ReplayThreatVisual({
       role="group"
       aria-label="Слои камеры и видео"
     >
-      {semantic ? (
+      {activeSemantic ? (
         <Button
           size="compact"
           shape="pill"
@@ -711,6 +748,20 @@ export function M4ReplayThreatVisual({
           SEMANTICS
         </Button>
       ) : null}
+      {availableSemanticLayers.length > 1 ? (
+        <SegmentedControl
+          value={selectedSemanticLayerId}
+          items={availableSemanticLayers.map((layer, index) => ({
+            value: layer.id ?? `${layer.resultId}:${index}`,
+            label: layer.controlLabel ?? layer.label ?? `SEMANTIC ${index + 1}`,
+          }))}
+          label="Источник семантики"
+          onChange={(value) => {
+            setSelectedSemanticLayerId(value);
+            setShowMediaSemantic(true);
+          }}
+        />
+      ) : null}
       {showReferenceMediaLayers && metadata.timeline?.cameraPointDelivery ? (
         <Button
           size="compact"
@@ -1022,6 +1073,7 @@ export function M4ReplayThreatVisual({
           <div
             className="m4-replay-threat-visual__pane-toolbar"
             data-pane-toolbar="media"
+            data-multi-semantic={availableSemanticLayers.length > 1 ? "true" : undefined}
           >
             {mediaLayerControls}
             {mediaModeControls}
@@ -1238,8 +1290,8 @@ export function M4ReplayThreatVisual({
   return (
     <div className="l3-visual-audit m4-replay-threat-visual">
       <LaboratoryEvidenceViewer
-        label={semantic
-          ? semantic.label ?? "Semantic diagnostic replay"
+        label={activeSemantic
+          ? activeSemantic.label ?? "Semantic diagnostic replay"
           : `${evidenceLabel} recorded-realtime replay`}
         className="m4-replay-threat-evidence-viewer"
         mode={mediaMode ?? "none"}

apps/control-station/src/workspaces/laboratory/VegetationBenchmarkResult.tsx

@@ -0,0 +1,147 @@
+import {
+  LaboratoryEvidence,
+  LaboratoryResultSummary,
+  LaboratorySummary,
+  LaboratoryWorkTemplate,
+} from "../../components/laboratory/LaboratoryPresentation";
+import type { VegetationShadowResult } from "../../core/laboratory/vegetationShadow";
+import {
+  M48MaskComparisonVisual,
+  type M48MaskComparisonCase,
+} from "./M48FailureAtlasVisual";
+
+function decimal(value: number, digits = 1): string {
+  return value.toLocaleString("ru-RU", { maximumFractionDigits: digits });
+}
+
+const VEGETATION_LABELS: Readonly<Record<string, string>> = {
+  high_grass: "Высокая трава",
+  low_grass: "Низкая трава",
+  bush: "Куст",
+  tree_trunk: "Ствол дерева",
+  tree_crown: "Крона дерева",
+  hedge: "Живая изгородь",
+  forest: "Лесная растительность",
+  crops: "Посевы",
+};
+
+function comparisonCases(result: VegetationShadowResult): readonly M48MaskComparisonCase[] {
+  return result.validationCases.map((item) => {
+    const focus = item.focus!;
+    return {
+      caseId: item.caseId,
+      title: `${VEGETATION_LABELS[focus.className] ?? focus.className} · truth ${decimal(focus.truthFraction * 100, 1)}% кадра`,
+      sourceUrl: item.assets.source,
+      truthUrl: item.assets.truth,
+      predictions: {
+        ddrnet: item.assets.ddrnet,
+        ppliteseg: item.assets.ppliteseg,
+      },
+      errors: {
+        ddrnet: item.assets.ddrnet_error,
+        ppliteseg: item.assets.ppliteseg_error,
+      },
+    };
+  });
+}
+
+export function VegetationBenchmarkResultView({
+  rigLabel,
+  result,
+}: {
+  rigLabel: string;
+  result: VegetationShadowResult;
+}) {
+  const selected = result.candidates.find(
+    (candidate) => candidate.candidate === result.selectedCandidate,
+  )!;
+  const alternative = result.candidates.find(
+    (candidate) => candidate.candidate !== result.selectedCandidate,
+  )!;
+
+  return (
+    <LaboratoryWorkTemplate
+      summary={(
+        <LaboratorySummary
+          title="M4.8 · архивный benchmark растительности"
+          description="Отдельный truth-backed контур GOOSE для сравнения готовых fine-64 весов. Он не является частью RAVNOVES00 realtime LAB и открывается автономно без Worker 006."
+          status="ARCHIVE ANALYSIS · model qualification only · commands OFF"
+          statusTone="warning"
+          facts={[
+            { label: "Источник", value: "GOOSE validation · 962 размеченных кадра · 12 hard cases" },
+            { label: "Сравнение", value: "DDRNet-39 vs PPLiteSeg · official fine-64 weights" },
+            { label: "Кейсы", value: "трава · куст · ствол · крона · изгородь · лес · посевы" },
+            { label: "Authority", value: `${rigLabel} · MODEL QUALIFICATION ONLY · commands OFF` },
+          ]}
+          brief={{
+            question: "Какие готовые веса лучше различают проезжаемую траву, кусты и стволы на размеченных off-road кадрах?",
+            approach: "Обе модели прогнаны на 962 кадрах, а 12 визуальных кейсов выбраны детерминированно по truth-поддержке восьми растительных классов. Viewer показывает source, ручной truth, prediction и error.",
+            principalResult: `${selected.loadedModelName} лидирует по vegetation IoU: ${decimal(selected.vegetationMeanIouPercent, 2)}% против ${decimal(alternative.vegetationMeanIouPercent, 2)}%.`,
+            limitation: "GOOSE — внешний размеченный домен. Результат выбирает стартовые веса, но не доказывает качество на fisheye RAVNOVES00 и не даёт navigation authority.",
+          }}
+          method={{
+            completeness: "complete",
+            executionClass: "ai-inference",
+            pipelineId: "goose-fine64-ready-weights-benchmark-archive/v1",
+            components: result.candidates.map((candidate) => ({
+              kind: "model" as const,
+              name: candidate.loadedModelName,
+              version: candidate.candidate,
+              role: candidate.candidate === result.selectedCandidate
+                ? "selected vegetation candidate"
+                : "comparison candidate",
+              identitySha256: candidate.checkpointSha256,
+            })),
+          }}
+        />
+      )}
+      evidence={(
+        <LaboratoryEvidence
+          eyebrow="M4.8 · GOOSE VEGETATION HARD CASES"
+          title="TRUTH — ручная разметка · PREDICTION — ответ модели · ERROR — расхождение"
+          kind="diagnostic-model"
+          resizable
+        >
+          <M48MaskComparisonVisual
+            cases={comparisonCases(result)}
+            initialCandidate={result.selectedCandidate}
+          />
+        </LaboratoryEvidence>
+      )}
+      result={(
+        <LaboratoryResultSummary
+          title="DDRNet выбран как стартовый vegetation candidate"
+          status={`${selected.loadedModelName} · перенос на ровер не доказан`}
+          statusTone="warning"
+          metrics={[
+            {
+              label: "GOOSE mIoU",
+              value: `${decimal(selected.meanIouPercent, 2)}% / ${decimal(alternative.meanIouPercent, 2)}%`,
+              hint: `${selected.candidate} / ${alternative.candidate} · полный validation split`,
+            },
+            {
+              label: "Vegetation IoU",
+              value: `${decimal(selected.vegetationMeanIouPercent, 2)}% / ${decimal(alternative.vegetationMeanIouPercent, 2)}%`,
+              hint: "grass/vegetation/bush/tree и родственные fine-64 labels",
+            },
+            {
+              label: "Worker shadow p95",
+              value: `${decimal(selected.shadowLatencyP95Ms, 2)} / ${decimal(alternative.shadowLatencyP95Ms, 2)} ms`,
+              hint: "чистый inference · одна тяжёлая модель за раз",
+            },
+            {
+              label: "Peak VRAM",
+              value: `${decimal(selected.peakReservedVramBytes / 1024 ** 3, 2)} / ${decimal(alternative.peakReservedVramBytes / 1024 ** 3, 2)} GiB`,
+              hint: `${selected.candidate} / ${alternative.candidate} · RTX 4090`,
+            },
+          ]}
+          conclusion={{
+            proved: "Обе готовые fine-64 модели воспроизводимо запускаются; DDRNet лучше по aggregate vegetation IoU.",
+            notProved: "Не доказаны accuracy на нашем fisheye, temporal stability, collision safety и физическое поведение ровера.",
+            decision: "Хранить как архив квалификации весов. Проверку на RAVNOVES00 вести только в основной многослойной LAB.",
+          }}
+        />
+      )}
+    />
+  );
+}

apps/control-station/src/workspaces/laboratory/VegetationShadowResult.tsx

@@ -1,3 +1,8 @@
+import { useEffect, useMemo, useState } from "react";
+import { Icon, IconButton, StatusBadge } from "@nodedc/ui-react";
+
+import { LaboratoryEvidenceViewer } from "../../components/laboratory/LaboratoryEvidenceViewer";
+import { LaboratoryRecordedClipPlayer } from "../../components/laboratory/LaboratoryRecordedClipPlayer";
 import {
   LaboratoryEvidence,
   LaboratoryResultSummary,
@@ -5,48 +10,436 @@ import {
   LaboratoryWorkTemplate,
 } from "../../components/laboratory/LaboratoryPresentation";
 import {
+  RecordedEvidenceSemanticMaskOverlay,
+  type RecordedEvidenceSemanticClass,
+  type RecordedEvidenceSemanticPaletteEntry,
+} from "../../components/laboratory/RecordedEvidenceSemanticMaskOverlay";
+import {
+  vegetationFullRouteMaskUrl,
   vegetationVideoMaskUrl,
+  type VegetationFullRouteLayer,
+  type VegetationFullRouteReview,
+  type VegetationMixedRouteReview,
   type VegetationShadowResult,
 } from "../../core/laboratory/vegetationShadow";
+import { recordedObservationSources } from "../../core/observation/recordedObservationSources";
+import { resolveObservationSessionReplay } from "../../core/observation/useObservationSessions";
+import type { ObservationSourceDescriptor } from "../../core/runtime/contracts";
 import {
-  M48MaskComparisonVisual,
-  type M48MaskComparisonCase,
-} from "./M48FailureAtlasVisual";
+  fetchM49TgsFullShadowResult,
+  type M49TgsFullShadowResult,
+} from "../../core/laboratory/m49TgsFullShadow";
 import { M4ReplayThreatVisual } from "./M4ReplayThreatVisual";
+import { M49TgsFullShadowEvidence } from "./M49TgsFullShadowEvidence";
 
 function decimal(value: number, digits = 1): string {
   return value.toLocaleString("ru-RU", { maximumFractionDigits: digits });
 }
 
-const VEGETATION_LABELS: Readonly<Record<string, string>> = {
-  high_grass: "Высокая трава",
-  low_grass: "Низкая трава",
-  bush: "Куст",
-  tree_trunk: "Ствол дерева",
-  tree_crown: "Крона дерева",
-  hedge: "Живая изгородь",
-  forest: "Лесная растительность",
-  crops: "Посевы",
-};
+const MIXED_ROUTE_MODES = [
+  { value: "source", label: "SOURCE" },
+  { value: "city", label: "ГОРОД · EoMT" },
+  { value: "vegetation", label: "ПРИРОДА · DDRNet" },
+  { value: "tgs", label: "TGS" },
+] as const;
 
-function comparisonCases(result: VegetationShadowResult): readonly M48MaskComparisonCase[] {
-  return result.validationCases.map((item) => {
-    const focus = item.focus!;
-    return {
-      caseId: item.caseId,
-      title: `${VEGETATION_LABELS[focus.className] ?? focus.className} · truth ${decimal(focus.truthFraction * 100, 1)}% кадра`,
-      sourceUrl: item.assets.source,
-      truthUrl: item.assets.truth,
-      predictions: {
-        ddrnet: item.assets.ddrnet,
-        ppliteseg: item.assets.ppliteseg,
-      },
-      errors: {
-        ddrnet: item.assets.ddrnet_error,
-        ppliteseg: item.assets.ppliteseg_error,
-      },
-    };
-  });
+const FULL_ROUTE_MODES = [
+  { value: "source", label: "SOURCE" },
+  { value: "city", label: "ГОРОД · EoMT" },
+  { value: "vegetation", label: "ПРИРОДА · DDRNet" },
+] as const;
+
+function semanticPresentation(layer: VegetationFullRouteLayer): {
+  classes: readonly RecordedEvidenceSemanticClass[];
+  palette: readonly RecordedEvidenceSemanticPaletteEntry[];
+} {
+  return {
+    classes: layer.taxonomy.map((item) => ({ id: item.classId, label: item.label })),
+    palette: layer.taxonomy.map((item) => ({
+      classId: item.classId,
+      color: item.classId === 0
+        ? { kind: "transparent" as const }
+        : { kind: "diagnostic" as const, rgb: item.colorRgb },
+    })),
+  };
+}
+
+function FullRouteReviewEvidence({
+  resultId,
+  review,
+}: {
+  resultId: string;
+  review: VegetationFullRouteReview;
+}) {
+  const [sequence, setSequence] = useState(1);
+  const [playing, setPlaying] = useState(false);
+  const [playbackRate, setPlaybackRate] = useState(1);
+  const [mode, setMode] = useState<typeof FULL_ROUTE_MODES[number]["value"]>("vegetation");
+  const [expanded, setExpanded] = useState(false);
+  const [videoSource, setVideoSource] = useState<ObservationSourceDescriptor | null>(null);
+  const [videoError, setVideoError] = useState<string | null>(null);
+  const frames = useMemo(
+    () => review.frameSourceTimesNs.map((sourceTimeNs, index) => ({
+      sequence: index + 1,
+      sourceTimeNs,
+    })),
+    [review.frameSourceTimesNs],
+  );
+  const layer = mode === "source" ? null : review[mode];
+  const semantic = useMemo(() => layer ? semanticPresentation(layer) : null, [layer]);
+  const maskSequence = sequence - 1;
+  const prefetchSrcs = useMemo(() => layer
+    ? Array.from({ length: 8 }, (_, offset) => maskSequence + offset + 1)
+      .filter((candidate) => candidate < review.frameCount)
+      .map((candidate) => vegetationFullRouteMaskUrl(resultId, mode as "city" | "vegetation", candidate))
+    : [], [layer, maskSequence, mode, resultId, review.frameCount]);
+
+  useEffect(() => {
+    const controller = new AbortController();
+    setVideoSource(null);
+    setVideoError(null);
+    void resolveObservationSessionReplay(review.sessionId, { signal: controller.signal })
+      .then((launch) => {
+        const source = recordedObservationSources(launch).find((candidate) => (
+          candidate.id === review.recordedMediaSourceId
+          && candidate.modality === "video"
+          && candidate.semanticChannelId === "camera.video.recorded"
+          && candidate.delivery?.kind === "recorded-fmp4-manifest"
+          && candidate.delivery.manifestGenerationSha256 === review.recordedMediaGenerationSha256
+          && candidate.delivery.timelineStartSeconds === review.timelineStartSeconds
+          && candidate.delivery.timelineEndSeconds >= review.timelineEndSeconds
+        ));
+        if (!source) {
+          throw new Error("RIGHT-видео не совпало с sealed RAVNOVES004TREE timeline.");
+        }
+        if (!controller.signal.aborted) setVideoSource(source);
+      })
+      .catch((caught: unknown) => {
+        if (!controller.signal.aborted) {
+          setVideoError(caught instanceof Error ? caught.message : "Записанное видео недоступно.");
+        }
+      });
+    return () => controller.abort();
+  }, [
+    review.recordedMediaGenerationSha256,
+    review.recordedMediaSourceId,
+    review.sessionId,
+    review.timelineEndSeconds,
+    review.timelineStartSeconds,
+  ]);
+
+  return (
+    <LaboratoryEvidenceViewer
+      label="RAVNOVES004TREE full recorded review"
+      className="m48-atlas-visual"
+      mode={mode}
+      modes={FULL_ROUTE_MODES}
+      expanded={expanded}
+      onModeChange={setMode}
+      onExpandedChange={setExpanded}
+      chromeLayout="stacked"
+    >
+      {videoSource ? (
+        <LaboratoryRecordedClipPlayer
+          source={videoSource}
+          segmentCount={review.frameCount}
+          frames={frames}
+          sequence={sequence}
+          playing={playing}
+          playbackRate={playbackRate}
+          cameraPresentation="primary"
+          continuousPlayback
+          sourceCount={1}
+          onSequenceChange={setSequence}
+          onPlayingChange={setPlaying}
+          onPlaybackRateChange={setPlaybackRate}
+          cameraOverlay={(
+            <>
+              <div className="m48-clip-player__pane-label" data-pane="camera">
+                {mode === "source" ? "SOURCE" : `${mode === "city" ? "EoMT CITY" : "DDRNet NATURE"} · КАДР ${sequence}/${review.frameCount}`}
+              </div>
+              {layer && semantic ? (
+                <div className="m48-clip-player__overlay">
+                  <RecordedEvidenceSemanticMaskOverlay
+                    src={vegetationFullRouteMaskUrl(resultId, mode as "city" | "vegetation", maskSequence)}
+                    prefetchSrcs={prefetchSrcs}
+                    imageWidth={review.width}
+                    imageHeight={review.height}
+                    classes={semantic.classes}
+                    palette={semantic.palette}
+                    opacity={0.76}
+                    ariaLabel={`${layer.name} semantic prediction`}
+                  />
+                </div>
+              ) : null}
+            </>
+          )}
+        />
+      ) : (
+        <div className="m4-replay-threat-visual__pane-status" role={videoError ? "alert" : "status"}>
+          {videoError ?? "Открываем автономный recorded source…"}
+        </div>
+      )}
+    </LaboratoryEvidenceViewer>
+  );
+}
+
+function FullRouteReviewResult({
+  rigLabel,
+  resultId,
+  review,
+}: {
+  rigLabel: string;
+  resultId: string;
+  review: VegetationFullRouteReview;
+}) {
+  return (
+    <LaboratoryWorkTemplate
+      summary={(
+        <LaboratorySummary
+          title="LAB V1 · RAVNOVES004TREE · полный маршрут"
+          description="Существующий M4.7-шаблон воспроизводит всю запись и переключает два независимых sealed semantic-слоя: городской EoMT и природный DDRNet. Worker для открытия результата не нужен."
+          status="FULL RECORDED REVIEW · truth отсутствует · commands OFF"
+          statusTone="warning"
+          facts={[
+            { label: "Источник", value: `${review.sourceId} · ${review.frameCount}/${review.frameCount} frames` },
+            { label: "Город", value: `${review.city.name} · ${decimal(review.city.inferenceFps, 2)} fps` },
+            { label: "Природа", value: `${review.vegetation.name} · ${decimal(review.vegetation.inferenceFps, 2)} fps` },
+            { label: "Authority", value: `${rigLabel} · VISUAL REVIEW ONLY · commands OFF` },
+          ]}
+          brief={{
+            question: "Как оба semantic-кандидата ведут себя на полном переходе от сельской среды к городской?",
+            approach: "Все 6830 позиции одной recorded timeline последовательно прогнаны на Worker 006 и сохранены двумя независимыми архивами масок. В M4.7 переключается только видимый слой.",
+            principalResult: "Полная временная шкала доступна локально в SOURCE / EoMT CITY / DDRNet NATURE без обращения к Worker.",
+            limitation: "Ручной truth отсутствует. Один повреждённый H.264-пакет на позиции 6092 представлен предыдущим декодированным кадром и явно зафиксирован в proof. Полный TGS и кюветы этим прогоном не проверялись.",
+          }}
+          method={{
+            completeness: "complete",
+            executionClass: "ai-inference",
+            pipelineId: "ravnoves004tree-full-eomt-ddrnet-recorded-review/v1",
+            components: [
+              { kind: "model", name: review.city.name, version: "sealed Worker 006 run", role: "urban semantic review", identitySha256: null },
+              { kind: "model", name: review.vegetation.name, version: "GOOSE DDRNet-39", role: "vegetation semantic review", identitySha256: null },
+            ],
+          }}
+        />
+      )}
+      evidence={(
+        <LaboratoryEvidence
+          eyebrow="M4.7 TEMPLATE · RAVNOVES004TREE FULL VIDEO"
+          title="SOURCE / EoMT CITY / DDRNet NATURE · 6830/6830 · TRUTH отсутствует"
+          kind="diagnostic-model"
+          resizable
+        >
+          <FullRouteReviewEvidence resultId={resultId} review={review} />
+        </LaboratoryEvidence>
+      )}
+      result={(
+        <LaboratoryResultSummary
+          title="Полный двухслойный visual review собран; управление не авторизовано"
+          status="Recorded evidence ready · navigation/actuation OFF"
+          statusTone="warning"
+          metrics={[
+            { label: "Route masks", value: "6830/6830 × 2", hint: "sealed local archives · Worker не требуется" },
+            { label: "EoMT p95", value: `${decimal(review.city.latencyP95Ms, 2)} ms`, hint: "последовательный изолированный прогон" },
+            { label: "DDRNet p95", value: `${decimal(review.vegetation.latencyP95Ms, 2)} ms`, hint: "последовательный изолированный прогон" },
+            { label: "Decode repair", value: "1/6830", hint: "sequence 6092 · previous frame · sealed proof" },
+          ]}
+          conclusion={{
+            proved: "Городской EoMT и природный DDRNet воспроизводимо обработали полную запись и доступны в одном существующем M4.7 viewer.",
+            notProved: "Не доказаны truth accuracy, одновременный realtime-load, полный TGS, отрицательные препятствия и безопасное управление ровером.",
+            decision: "Использовать результат только как визуальную диагностику. Navigation/actuation оставить OFF; следующий gate — оценка временной стабильности и независимый person/vehicle STOP.",
+          }}
+        />
+      )}
+    />
+  );
+}
+
+function MixedRouteReviewEvidence({ review }: { review: VegetationMixedRouteReview }) {
+  const [index, setIndex] = useState(0);
+  const [mode, setMode] = useState<typeof MIXED_ROUTE_MODES[number]["value"]>("vegetation");
+  const [expanded, setExpanded] = useState(false);
+  const item = review.cases[index]!;
+  return (
+    <LaboratoryEvidenceViewer
+      label="RAVNOVES004TREE mixed route review"
+      className="m48-atlas-visual"
+      mode={mode}
+      modes={MIXED_ROUTE_MODES}
+      expanded={expanded}
+      onModeChange={setMode}
+      onExpandedChange={setExpanded}
+      chromeLayout="stacked"
+      actions={(
+        <>
+          <IconButton label="Предыдущая сцена" onClick={() => setIndex((index - 1 + review.cases.length) % review.cases.length)}>
+            <Icon name="chevron-left" size={16} />
+          </IconButton>
+          <IconButton label="Следующая сцена" onClick={() => setIndex((index + 1) % review.cases.length)}>
+            <Icon name="chevron-right" size={16} />
+          </IconButton>
+        </>
+      )}
+      overlay={(
+        <div className="m48-atlas-visual__case">
+          <StatusBadge tone={item.phase === "urban" ? "accent" : item.phase === "transition" ? "warning" : "neutral"}>
+            {item.phase.toUpperCase()} · {index + 1}/{review.cases.length}
+          </StatusBadge>
+          <strong>sequence {item.sourceSequence} · +{decimal(item.sessionSeconds, 2)} s</strong>
+          <small>
+            TGS: {item.tgs.groundCells} ground · {item.tgs.occupiedCells} occupied · {item.tgs.unobservedCells} unobserved
+          </small>
+        </div>
+      )}
+    >
+      <div className="recorded-evidence-image-scene">
+        <img src={item.assets[mode]} alt="" draggable={false} />
+      </div>
+    </LaboratoryEvidenceViewer>
+  );
+}
+
+function MixedRouteReviewResult({
+  rigLabel,
+  review,
+}: {
+  rigLabel: string;
+  review: VegetationMixedRouteReview;
+}) {
+  return (
+    <LaboratoryWorkTemplate
+      summary={(
+        <LaboratorySummary
+          title="LAB V1 · RAVNOVES004TREE · село → город"
+          description="Существующий LAB-шаблон показывает 10 синхронных camera/LiDAR сцен одной записи. EoMT и DDRNet остаются независимыми слоями; TGS показывает отдельную геометрию и не может быть очищен семантической маской."
+          status="BOUNDED RECORDED REVIEW · truth отсутствует · commands OFF"
+          statusTone="warning"
+          facts={[
+            { label: "Источник", value: `${review.sourceId} · ${review.frameCount} camera/LiDAR islands` },
+            { label: "Переход", value: "5 rural · 1 transition · 4 urban" },
+            { label: "Слои", value: "SOURCE · EoMT CITY · DDRNet VEGETATION · causal TGS" },
+            { label: "Authority", value: `${rigLabel} · VISUAL REVIEW ONLY · commands OFF` },
+          ]}
+          brief={{
+            question: "Сохраняются ли городская семантика, растительность и геометрия при переходе из сельской среды в город?",
+            approach: "Выбраны десять соседних с исходными сцен camera-кадров, каждый синхронизирован с LiDAR в пределах 100 мс. Все три вычислительных слоя прогнаны на Worker 006 и запечатаны локально.",
+            principalResult: "Все 10 сцен обработаны EoMT, DDRNet и causal TGS. Слои можно переключать без наложения цветов и без зависимости LAB от воркера.",
+            limitation: "Это bounded islands без ручной truth. DDRNet шумит по подтипам растительности; TGS не доказывает обнаружение кювета или отрицательного препятствия.",
+          }}
+          method={{
+            completeness: "complete",
+            executionClass: "ai-inference",
+            pipelineId: "ravnoves004tree-eomt-ddrnet-causal-tgs-review/v1",
+            components: [
+              { kind: "model", name: review.models.city.name, version: "sealed Worker run", role: "urban semantic review", identitySha256: null },
+              { kind: "model", name: review.models.vegetation.name, version: "GOOSE DDRNet-39", role: "vegetation semantic review", identitySha256: null },
+              { kind: "algorithm", name: review.models.tgs.name, version: "TRAVEL compatibility runner", role: "independent local geometry", identitySha256: null },
+            ],
+          }}
+        />
+      )}
+      evidence={(
+        <LaboratoryEvidence
+          eyebrow="M4.7 TEMPLATE · RAVNOVES004TREE"
+          title="SOURCE / ГОРОД / ПРИРОДА / TGS · 10/10 · TRUTH отсутствует"
+          kind="diagnostic-model"
+          resizable
+        >
+          <MixedRouteReviewEvidence review={review} />
+        </LaboratoryEvidence>
+      )}
+      result={(
+        <LaboratoryResultSummary
+          title="Переход село → город воспроизведён; safety gate не закрыт"
+          status="Review ready · navigation/actuation OFF"
+          statusTone="warning"
+          metrics={[
+            { label: "Aligned scenes", value: "10/10", hint: "camera + LiDAR + pose · автономный archive" },
+            { label: "EoMT end-to-end p95", value: `${decimal(review.models.city.endToEndP95Ms, 2)} ms`, hint: `${decimal(review.models.city.inferenceFps, 2)} fps в изолированном прогоне` },
+            { label: "DDRNet inference p95", value: `${decimal(review.models.vegetation.latencyP95Ms, 2)} ms`, hint: "candidate review · не совместный realtime stack" },
+            { label: "TGS p95", value: `${decimal(review.models.tgs.latencyP95Ms, 2)} ms`, hint: `${review.models.tgs.cellSizeM} m cells · ${review.models.tgs.radiusM} m radius` },
+          ]}
+          conclusion={{
+            proved: "Оба semantic слоя и causal TGS воспроизводимо работают на сельской, переходной и городской части новой записи.",
+            notProved: "Не доказаны accuracy без truth, временная стабильность по всему видео, детект кюветов и безопасное совместное realtime-управление ровером.",
+            decision: "Оставить navigation/actuation OFF. Следующий короткий gate — непрерывный realtime-load двух моделей плюс независимый person/vehicle STOP; кюветы проверять отдельной записью.",
+          }}
+        />
+      )}
+    />
+  );
+}
+
+function VegetationRouteEvidence({ result }: { result: VegetationShadowResult }) {
+  const route = result.routeVideo!;
+  const [tgs, setTgs] = useState<M49TgsFullShadowResult | null>(null);
+  const [tgsError, setTgsError] = useState<string | null>(null);
+
+  useEffect(() => {
+    const controller = new AbortController();
+    setTgs(null);
+    setTgsError(null);
+    if (!route.linkedTgsResultId) return () => controller.abort();
+    void fetchM49TgsFullShadowResult(route.linkedTgsResultId, {
+      signal: controller.signal,
+    }).then((next) => {
+      if (controller.signal.aborted) return;
+      if (next.source.linkedVisualResultId !== route.baseM4ResultId) {
+        throw new Error("TGS и camera timeline имеют разные source identities.");
+      }
+      setTgs(next);
+    }).catch((caught: unknown) => {
+      if (!controller.signal.aborted) {
+        setTgsError(caught instanceof Error ? caught.message : "Sealed TGS недоступен.");
+      }
+    });
+    return () => controller.abort();
+  }, [route.baseM4ResultId, route.linkedTgsResultId]);
+
+  const semantic = {
+    id: "vegetation",
+    controlLabel: "ПРИРОДА · DDRNet",
+    resultId: route.workerResultId,
+    spatialResultId: null,
+    taxonomy: route.taxonomy,
+    maskUrl: (sequence: number) => vegetationVideoMaskUrl(result.resultId, sequence),
+    label: "DDRNet coarse vegetation material · recorded video",
+    maskAriaLabel: "DDRNet vegetation material prediction",
+  } as const;
+
+  if (route.linkedTgsResultId && tgs) {
+    return (
+      <M49TgsFullShadowEvidence
+        result={tgs}
+        semanticOverride={semantic}
+        evidenceLabel="LAB V1 · EoMT + DDRNet + YOLOX + TGS"
+      />
+    );
+  }
+  if (route.linkedTgsResultId && !tgsError) {
+    return (
+      <div className="m4-replay-threat-visual__pane-status" role="status">
+        Открываем sealed EoMT, TGS и coarse vegetation timeline…
+      </div>
+    );
+  }
+  return (
+    <>
+      <M4ReplayThreatVisual
+        resultId={route.baseM4ResultId}
+        evidenceLabel="LAB V1 · DDRNet"
+        showReferenceMediaLayers
+        showSpatialOverlaySummary={false}
+        semantic={semantic}
+      />
+      {tgsError ? (
+        <div className="m4-replay-threat-visual__pane-status" role="alert">
+          TGS слой недоступен: {tgsError}
+        </div>
+      ) : null}
+    </>
+  );
 }
 
 export function VegetationShadowResultView({
@@ -56,143 +449,129 @@ export function VegetationShadowResultView({
   rigLabel: string;
   result: VegetationShadowResult;
 }) {
+  if (result.routeFullReview) {
+    return (
+      <FullRouteReviewResult
+        rigLabel={rigLabel}
+        resultId={result.resultId}
+        review={result.routeFullReview}
+      />
+    );
+  }
+  if (result.routeReview) {
+    return <MixedRouteReviewResult rigLabel={rigLabel} review={result.routeReview} />;
+  }
+  const route = result.routeVideo;
   const selected = result.candidates.find(
     (candidate) => candidate.candidate === result.selectedCandidate,
   )!;
-  const alternative = result.candidates.find(
-    (candidate) => candidate.candidate !== result.selectedCandidate,
-  )!;
+
   return (
     <LaboratoryWorkTemplate
       summary={(
         <LaboratorySummary
-          title="LAB V1 · готовые модели растительности"
-          description={result.routeVideo
-            ? "M4.8 сохраняет truth-backed сравнение моделей, а штатный M4.7 viewer показывает фактический DDRNet prediction на всей записи RAVNOVES00. Все 4489 масок запечатаны локально и открываются без Worker 006."
-            : "Штатный M4.8-инструмент сравнивает две готовые fine-64 модели на полном GOOSE validation split и на 12 truth-backed hard cases, выбранных только по наличию нужной растительности. Sealed evidence открывается локально без Worker 006."}
-          status={result.routeVideo
-            ? "DDRNet full-video prediction ready · route truth отсутствует"
-            : "Truth-backed model comparison · route transfer не принят"}
+          title="LAB V1 · карта ровера · город + растительность"
+          description="Один recorded-контур RAVNOVES00 синхронно показывает городской EoMT, природный DDRNet, frozen YOLOX detections и causal TGS. Семантические маски переключаются, чтобы их цвета не скрывали друг друга; геометрическое veto остаётся независимым."
+          status={route
+            ? "MULTILAYER RECORDED REVIEW · commands OFF · route truth отсутствует"
+            : "ROUTE EVIDENCE MISSING · commands OFF"}
           statusTone="warning"
           facts={[
-            { label: "Источник", value: "GOOSE validation · 962 размеченных кадра · 12 vegetation hard cases" },
-            { label: "Сравнение", value: "DDRNet-39 vs PPLiteSeg · official fine-64 weights" },
-            { label: "Кейсы", value: "трава · куст · ствол · крона · изгородь · лес · посевы" },
-            ...(result.routeVideo ? [{
-              label: "Видео",
-              value: "RAVNOVES00 · 4489/4489 DDRNet masks · exact recorded sequence",
-            }] : []),
-            { label: "Authority", value: `${rigLabel} · MODEL QUALIFICATION ONLY · commands OFF` },
+            { label: "Источник", value: "RAVNOVES00 · sensor.camera.right · 4489 recorded frames" },
+            { label: "Город", value: "EoMT Cityscapes · sealed E47 semantic archive" },
+            { label: "Растительность", value: "DDRNet-39 fine-64 → coarse mission-neutral materials" },
+            { label: "Safety", value: "YOLOX object boxes + causal TGS · semantic masks не снимают veto" },
+            { label: "Authority", value: `${rigLabel} · VISUAL REVIEW ONLY · commands OFF` },
           ]}
           brief={{
-            question: "Какие готовые веса лучше различают проезжаемую траву, кусты и стволы на размеченных off-road кадрах?",
-            approach: "Обе модели последовательно прогнаны в одном изолированном CUDA-runtime на 962 кадрах. 12 визуальных кейсов выбраны детерминированно по truth-поддержке восьми растительных классов; один M4.8 viewer показывает source, truth, prediction и material-error для выбранной модели.",
-            principalResult: `${selected.loadedModelName} лидирует по vegetation IoU: ${decimal(selected.vegetationMeanIouPercent, 2)}% против ${decimal(alternative.vegetationMeanIouPercent, 2)}%. ${result.routeVideo ? "Его фактическая temporal stability теперь видна на всех 4489 кадрах штатного recorded viewer." : "Ошибки по каждому типу проверяются в одном штатном инструменте."}`,
-            limitation: "GOOSE — внешний размеченный домен; RAVNOVES00 — наш fisheye, но без ручной truth-разметки. Full-video слой показывает prediction, а не доказывает правильность. Папоротник отдельным классом отсутствует.",
+            question: "Можно ли одновременно видеть городской и природный semantic stack, не теряя независимую геометрическую защиту?",
+            approach: "EoMT и DDRNet сохранены как два независимых sealed слоя на одной M4 timeline. В штатном M4.7 viewer пользователь переключает только отображаемую маску; YOLOX и TGS остаются активными слоями evidence.",
+            principalResult: route
+              ? "Оба semantic archive доступны в одном viewer. Это не пиксельный fusion и не единая новая модель: городской и природный ответы остаются раздельными."
+              : "Route archive для этой immutable identity отсутствует.",
+            limitation: "RAVNOVES00 не имеет ручной truth. DDRNet заметно прыгает между HIGH GRASS, WOODY и UNKNOWN; поэтому subtype нельзя подавать напрямую в planner. Отсутствие класса никогда не означает свободный путь.",
           }}
           method={{
-            completeness: "complete",
+            completeness: route ? "complete" : "legacy-partial",
             executionClass: "ai-inference",
-            pipelineId: "goose-fine64-ready-weights-to-ravnoves-policy-shadow/v1",
-            components: result.candidates.map((candidate) => ({
-              kind: "model" as const,
-              name: candidate.loadedModelName,
-              version: candidate.candidate,
-              role: candidate.candidate === result.selectedCandidate ? "selected policy provider" : "comparison candidate",
-              identitySha256: candidate.checkpointSha256,
-            })),
+            pipelineId: "ravnoves-eomt-ddrnet-yolox-causal-tgs-recorded-review/v1",
+            components: [
+              {
+                kind: "model",
+                name: "EoMT Cityscapes semantic",
+                version: "sealed E47 archive",
+                role: "urban semantic review",
+                identitySha256: null,
+              },
+              {
+                kind: "model",
+                name: selected.loadedModelName,
+                version: selected.candidate,
+                role: "vegetation material candidate",
+                identitySha256: selected.checkpointSha256,
+              },
+              {
+                kind: "algorithm",
+                name: "Frozen YOLOX + causal TGS",
+                version: "linked M4/M4.9 archives",
+                role: "independent object and geometry veto",
+                identitySha256: null,
+              },
+            ],
           }}
         />
       )}
-      evidence={(
-        <>
-          <LaboratoryEvidence
-            eyebrow="M4.8 · GOOSE VEGETATION HARD CASES"
-            title="ERROR: красный — пропуск · жёлтый — лишнее · фиолетовый — перепутан тип · зелёный — совпадение"
-            kind="diagnostic-model"
-            resizable
-          >
-            <M48MaskComparisonVisual
-              cases={comparisonCases(result)}
-              initialCandidate={result.selectedCandidate}
-            />
-          </LaboratoryEvidence>
-          {result.routeVideo ? (
-            <LaboratoryEvidence
-              eyebrow="M4.7 · RAVNOVES00 FULL VIDEO"
-              title="DDRNet PREDICTION · 4489/4489 кадров · TRUTH для этой записи отсутствует"
-              kind="diagnostic-model"
-              resizable
-            >
-              <M4ReplayThreatVisual
-                resultId={result.routeVideo.baseM4ResultId}
-                evidenceLabel="LAB V1 · DDRNet"
-                showReferenceMediaLayers={false}
-                showSpatialOverlaySummary={false}
-                semantic={{
-                  resultId: result.routeVideo.workerResultId,
-                  spatialResultId: null,
-                  taxonomy: result.routeVideo.taxonomy,
-                  maskUrl: (sequence) => vegetationVideoMaskUrl(result.resultId, sequence),
-                  label: "DDRNet vegetation prediction · recorded video",
-                  maskAriaLabel: "DDRNet vegetation prediction",
-                }}
-              />
-            </LaboratoryEvidence>
-          ) : null}
-        </>
+      evidence={route ? (
+        <LaboratoryEvidence
+          eyebrow="M4.7 · RAVNOVES00 FULL VIDEO"
+          title="EoMT CITY / DDRNet VEGETATION + YOLOX + CAUSAL TGS · 4489/4489 · TRUTH отсутствует"
+          kind="diagnostic-model"
+          resizable
+        >
+          <VegetationRouteEvidence result={result} />
+        </LaboratoryEvidence>
+      ) : (
+        <LaboratoryEvidence
+          eyebrow="M4.7 · RAVNOVES00 FULL VIDEO"
+          title="ROUTE ARCHIVE отсутствует"
+          kind="diagnostic-model"
+        >
+          <div className="m4-replay-threat-visual__pane-status" role="alert">
+            Для этой immutable identity нет полного route video evidence.
+          </div>
+        </LaboratoryEvidence>
       )}
       result={(
         <LaboratoryResultSummary
-          title="DDRNet — стартовые веса; перенос на ровер ещё не доказан"
-          status={`${selected.loadedModelName} выбран только как vegetation candidate`}
+          title="Многослойный visual review собран; управление не авторизовано"
+          status="Semantics advisory · YOLOX/TGS veto cannot be cleared"
           statusTone="warning"
           metrics={[
             {
-              label: "GOOSE mIoU",
-              value: `${decimal(selected.meanIouPercent, 2)}% / ${decimal(alternative.meanIouPercent, 2)}%`,
-              hint: `${selected.candidate} / ${alternative.candidate} · полный validation split`,
+              label: "Route masks",
+              value: route ? `${route.frameCount}/${route.frameCount}` : "0/4489",
+              hint: "sealed local playback · Worker для открытия не нужен",
             },
             {
-              label: "Vegetation IoU",
-              value: `${decimal(selected.vegetationMeanIouPercent, 2)}% / ${decimal(alternative.vegetationMeanIouPercent, 2)}%`,
-              hint: "агрегация классов grass/vegetation/bush/tree и родственных fine-64 labels",
+              label: "Semantic sources",
+              value: route ? "2 independent layers" : "0",
+              hint: "EoMT CITY / DDRNet VEGETATION · display switches, evidence does not fuse",
             },
             {
-              label: "Worker shadow p95",
-              value: `${decimal(selected.shadowLatencyP95Ms, 2)} / ${decimal(alternative.shadowLatencyP95Ms, 2)} ms`,
-              hint: "чистый inference · одна тяжёлая модель за раз",
+              label: "Vegetation worker p95",
+              value: `${decimal(selected.shadowLatencyP95Ms, 2)} ms`,
+              hint: "изолированный DDRNet inference; не совместный realtime stack",
             },
             {
-              label: "Cold prewarm",
-              value: `${decimal(selected.shadowPrewarmLatencyMs, 1)} / ${decimal(alternative.shadowPrewarmLatencyMs, 1)} ms`,
-              hint: "один явный inference до допуска кадров; исключён из steady-state p95",
+              label: "Vegetation peak VRAM",
+              value: `${decimal(selected.peakReservedVramBytes / 1024 ** 3, 2)} GiB`,
+              hint: "DDRNet candidate на Worker 006",
             },
-            {
-              label: "Worker throughput",
-              value: `${decimal(selected.shadowThroughputFps, 1)} / ${decimal(alternative.shadowThroughputFps, 1)} FPS`,
-              hint: "изолированный Worker 006 · не realtime graph целиком",
-            },
-            {
-              label: "Peak VRAM",
-              value: `${decimal(selected.peakReservedVramBytes / 1024 ** 3, 2)} / ${decimal(alternative.peakReservedVramBytes / 1024 ** 3, 2)} GiB`,
-              hint: `${selected.candidate} / ${alternative.candidate} · RTX 4090`,
-            },
-            {
-              label: "Hard-case evidence",
-              value: "12 truth-backed cases",
-              hint: "8 vegetation strata · Worker для открытия не требуется",
-            },
-            ...(result.routeVideo ? [{
-              label: "Route video",
-              value: "4489/4489 masks",
-              hint: "DDRNet prediction · exact sequence · Worker-independent playback",
-            }] : []),
           ]}
           conclusion={{
-            proved: "Обе официальные fine-64 модели воспроизводимо запускаются на Worker 006; DDRNet лучше по aggregate vegetation IoU. Truth-backed hard cases прямо показывают траву, кусты и стволы, а не случайные автомобили и здания.",
-            notProved: "Не доказаны accuracy на нашем fisheye-домене, папоротник как отдельный материал, collision safety и physical-live поведение ровера. Видео позволяет увидеть temporal stability, но без truth не превращает её в метрику качества.",
-            decision: "Смотреть полный prediction на видео и собирать конкретные temporal/domain failure cases. DDRNet остаётся diagnostic candidate; LiDAR/TGS fail-closed геометрию не ослаблять.",
+            proved: "На одной recorded timeline доступны городской EoMT, природный DDRNet, YOLOX detections и causal TGS; LAB автономна от Worker.",
+            notProved: "Не доказаны совместный live-runtime EoMT+DDRNet, truth accuracy на fisheye, стабильные vegetation subtypes и безопасное управление ровером.",
+            decision: "Использовать маски только для диагностики. Следующий qualification gate — motion-aware temporal vegetation fusion и отдельный совместный realtime load test; до него planner/actuation остаются OFF.",
           }}
         />
       )}

apps/control-station/src/workspaces/laboratory/annotation/useL34AnnotationCapability.tsx

@@ -1,4 +1,4 @@
-import { useCallback, useEffect, useState, type ReactNode } from "react";
+import { useCallback, useEffect, useMemo, useState, type ReactNode } from "react";
 
 import type { L34RightYoloxTruthIslandResult } from "../../../core/laboratory/l34RightYoloxTruthIsland";
 import type { L34DResult } from "../../../core/laboratory/l34dCumulativePostprocessing";
@@ -28,19 +28,19 @@ export function useL34AnnotationCapability({
 }): ReactNode {
   const [open, setOpen] = useState(false);
   const openWorkspace = useCallback(() => setOpen(true), []);
-  const available = selectedWorkId === "l34-right-yolox-truth-island-freeze"
-    && l34Result
-    ? { resultId: l34Result.resultId, workflow: "assisted-candidate" as const }
-    : selectedWorkId === "e46-detector-truth-island" && e46Result
-      ? { resultId: e46Result.resultId, workflow: "independent-blind" as const }
-      : selectedWorkId === "e46a-ai-engineering-preannotation" && e46aResult
-        ? { resultId: e46aResult.resultId, workflow: "engineering-preannotation" as const }
-      : selectedWorkId === "l34d-cumulative-postprocessing-candidate"
-      && l34dResult
-      ? { resultId: l34dResult.resultId, workflow: "prediction-hidden" as const }
-      : selectedWorkId === "l34e-self-review-diagnostic" && l34eResult
-        ? { resultId: l34eResult.resultId, workflow: "adjudication" as const }
-        : null;
+  const available = useMemo(() => (
+    selectedWorkId === "l34-right-yolox-truth-island-freeze" && l34Result
+      ? { resultId: l34Result.resultId, workflow: "assisted-candidate" as const }
+      : selectedWorkId === "e46-detector-truth-island" && e46Result
+        ? { resultId: e46Result.resultId, workflow: "independent-blind" as const }
+        : selectedWorkId === "e46a-ai-engineering-preannotation" && e46aResult
+          ? { resultId: e46aResult.resultId, workflow: "engineering-preannotation" as const }
+          : selectedWorkId === "l34d-cumulative-postprocessing-candidate" && l34dResult
+            ? { resultId: l34dResult.resultId, workflow: "prediction-hidden" as const }
+            : selectedWorkId === "l34e-self-review-diagnostic" && l34eResult
+              ? { resultId: l34eResult.resultId, workflow: "adjudication" as const }
+              : null
+  ), [e46Result, e46aResult, l34Result, l34dResult, l34eResult, selectedWorkId]);
 
   useEffect(() => {
     if (!available) {

apps/control-station/src/workspaces/laboratory/laboratoryArchiveProfiles.ts

@@ -10,6 +10,7 @@ export type LaboratoryProfileId =
   | "rig-camera-local-surface-v1"
   | "rig-track-geometry-temporal-v1"
   | "rig-ravnoves-perception-gate-v1"
+  | "rig-goose-vegetation-benchmark-v1"
   | "rig-pointpillars-transfer-v1"
   | "rig-right-yolox-lidar-range-v1"
   | "rig-nvidia-ready-stack-v1"
@@ -63,12 +64,19 @@ interface KnownWorkDefinition {
 const rig = (rigLabel: string): string => rigLabel.trim() || "Сенсорный риг";
 
 const KNOWN_WORKS: Readonly<Record<Exclude<LaboratoryWorkId, `session:${string}`>, KnownWorkDefinition>> = {
+  "lab-v1-vegetation-benchmark": {
+    profileId: "rig-goose-vegetation-benchmark-v1",
+    profileName: (rigLabel) => `${rig(rigLabel)} · GOOSE vegetation archive`,
+    experimentId: "lab-v1-vegetation-benchmark-archive",
+    experimentName: "DDRNet vs PPLiteSeg · truth-backed archival comparison",
+    variantName: "M4.8 · GOOSE truth · архивный анализ моделей",
+  },
   "lab-v1-vegetation-shadow": {
     profileId: "rig-ravnoves-perception-gate-v1",
-    profileName: (rigLabel) => `${rig(rigLabel)} · GOOSE vegetation qualification`,
+    profileName: (rigLabel) => `${rig(rigLabel)} · RAVNOVES00 rover perception gate`,
     experimentId: "lab-v1-vegetation-mission-policy",
-    experimentName: "DDRNet vs PPLiteSeg · truth-backed vegetation hard cases",
-    variantName: "LAB V1 · готовые vegetation weights · GOOSE truth",
+    experimentName: "RAVNOVES00 · city + vegetation + TGS review",
+    variantName: "LAB V1 · EoMT + DDRNet + YOLOX + TGS · commands OFF",
   },
   "m48-object-centric-quality": {
     profileId: "rig-dual-evidence-virtual-corridor-v1",

apps/control-station/src/workspaces/laboratory/useAdvancedLaboratoryCatalog.ts

@@ -18,6 +18,7 @@ function mergeResults(
   next: AdvancedLaboratoryResults,
 ): AdvancedLaboratoryResults {
   return {
+    vegetationBenchmark: next.vegetationBenchmark ?? current.vegetationBenchmark,
     vegetationShadow: next.vegetationShadow ?? current.vegetationShadow,
     m47Graph: next.m47Graph ?? current.m47Graph,
     m48: next.m48 ?? current.m48,
@@ -122,6 +123,7 @@ export function useAdvancedLaboratoryCatalog({
     const indexedResultId = index.find((item) => item.workId === selectedWorkId)?.resultId;
     if (
       [
+        "lab-v1-vegetation-benchmark",
         "lab-v1-vegetation-shadow",
         "m47-reference-graph-shadow",
         "m48-object-centric-quality",

apps/control-station/test/m49TgsFullShadow.test.mjs

@@ -108,7 +108,14 @@ test("M4.9T5 viewer prefers autonomous chunks and keeps a sealed legacy fallback
   assert.doesNotMatch(source, /centersXyM\.map\(/);
   assert.match(source, /fetchE47SemanticSlamResult/);
   assert.match(source, /next\.baseM4ResultId !== result\.source\.linkedVisualResultId/);
-  assert.match(source, /semantic=\{semantic \? \{/);
+  assert.match(source, /semanticLayers=\{semanticLayers\}/);
+  assert.match(source, /ГОРОД · EoMT/);
+  assert.match(source, /ПРИРОДА · DDRNet/);
+  assert.match(source, /semanticOverride/);
+  assert.doesNotMatch(source, /if \(semanticOverride\) return/);
+  assert.match(visual, /label="Источник семантики"/);
+  assert.match(visual, /availableSemanticLayers\.length > 1/);
+  assert.doesNotMatch(visual, /classifiedSpatialLayer \|\| !showReferenceMediaLayers \? \[\]/);
   assert.match(
     visual,
     /classifiedSpatialFrame\s*&&\s*classifiedSpatialFrame\.sampleAvailable !== false/,

apps/control-station/test/simulationWorkspace.test.mjs

@@ -179,8 +179,33 @@ test("PlayCanvas owns the realtime scene graph without an iframe or React entity
   assert.match(ugv, /desiredSpeed = forwardInput \* maxSpeed/);
   assert.match(ugv, /maximumAcceleration = clamp\(1\.4 \+ maxSpeed \* 0\.35, 1\.8, 4\.2\)/);
   assert.match(ugv, /SERVICE_BRAKE_DECELERATION_MPS2 = 1\.8/);
-  assert.match(ugv, /horizontalSpeed - deceleration \* Math\.max\(0, deltaSeconds\)/);
-  assert.match(ugv, /this\.vehicle\.setBrake\(0, index\)/);
+  assert.match(ugv, /PARKING_BRAKE_HOLD_DECELERATION_MPS2 = 6/);
+  assert.match(ugv, /PARKING_BRAKE_ENGAGE_SPEED_MPS = 0\.08/);
+  assert.match(ugv, /TYRE_FRICTION_SLIP = 8\.5/);
+  assert.match(ugv, /TYRE_STATIC_FRICTION_COEFFICIENT = 0\.95/);
+  assert.match(ugv, /TYRE_KINETIC_FRICTION_COEFFICIENT = 0\.78/);
+  assert.match(ugv, /TYRE_CONTACT_VELOCITY_RESPONSE_PER_SECOND = 10/);
+  assert.match(ugv, /GRAVITY_METERS_PER_SECOND_SQUARED = 9\.81/);
+  assert.match(ugv, /holding = !braking && forwardInput === 0 && turnInput === 0/);
+  assert.match(ugv, /longitudinalSpeedMetersPerSecond/);
+  assert.match(ugv, /parkingBrakeEngaged = holding/);
+  assert.match(ugv, /this\.settings\.massKg \* brakeDeceleration/);
+  assert.match(ugv, /this\.vehicle\.setBrake\(wheelBrakeForce, index\)/);
+  assert.match(ugv, /set_m_frictionSlip\(\s*parkingBrakeEngaged \? 0 : TYRE_FRICTION_SLIP/);
+  assert.match(ugv, /applyParkingTyreContact/);
+  assert.match(ugv, /wheel\.get_m_wheelsSuspensionForce\(\)/);
+  assert.doesNotMatch(ugv, /get_m_isInContact/);
+  assert.match(ugv, /normalForce < MIN_TYRE_NORMAL_FORCE_NEWTONS/);
+  assert.match(ugv, /lateralGravityAcceleration/);
+  assert.match(ugv, /longitudinalGravityAcceleration/);
+  assert.match(ugv, /TYRE_CONTACT_VELOCITY_RESPONSE_PER_SECOND \* lateralSlipSpeed/);
+  assert.match(ugv, /TYRE_CONTACT_VELOCITY_RESPONSE_PER_SECOND \* longitudinalSlipSpeed/);
+  assert.match(ugv, /Math\.hypot\(trialLateralForce, trialLongitudinalForce\)/);
+  assert.match(ugv, /body\.applyImpulse\(this\.tyreImpulseNative, this\.tyreRelativePositionNative\)/);
+  assert.doesNotMatch(ugv, /horizontalSpeed - deceleration \* Math\.max\(0, deltaSeconds\)/);
+  assert.match(ugv, /rollingFriction: 0\.12/);
+  assert.match(ugv, /angularDamping: 0\.6/);
+  assert.match(ugv, /wheel\.set_m_frictionSlip\(TYRE_FRICTION_SLIP\)/);
   assert.doesNotMatch(ugv, /massKg \* 3/);
   assert.match(ugv, /pureTurn = !braking && forwardInput === 0 && turnInput !== 0/);
   assert.match(ugv, /desiredYawRate = -turnInput \* maxTurnRate/);

apps/control-station/test/vegetationShadow.test.mjs

@@ -5,7 +5,9 @@ import { after, before, test } from "node:test";
 import { createServer } from "vite";
 
 let server;
+let fetchVegetationBenchmarkResult;
 let fetchVegetationShadowResult;
+let vegetationFullRouteMaskUrl;
 
 before(async () => {
   server = await createServer({
@@ -13,7 +15,11 @@ before(async () => {
     logLevel: "silent",
     server: { middlewareMode: true },
   });
-  ({ fetchVegetationShadowResult } = await server.ssrLoadModule(
+  ({
+    fetchVegetationBenchmarkResult,
+    fetchVegetationShadowResult,
+    vegetationFullRouteMaskUrl,
+  } = await server.ssrLoadModule(
     "/src/core/laboratory/vegetationShadow.ts",
   ));
 });
@@ -23,6 +29,7 @@ after(async () => {
 });
 
 const resultId = `lab-v1-vegetation-shadow-${"a".repeat(64)}`;
+const benchmarkResultId = `lab-v1-vegetation-benchmark-${"d".repeat(64)}`;
 
 function candidate(candidateKey, vegetationIou) {
   return {
@@ -104,45 +111,157 @@ function routeVideo() {
   };
 }
 
+function coarseRouteVideo() {
+  return {
+    ...routeVideo(),
+    view_kind: "coarse-material-policy-review",
+    linked_tgs_result_id: `m49-tgs-full-shadow-${"2".repeat(64)}`,
+    taxonomy: {
+      schema_version: "missioncore.lab-v1-terrain-policy-taxonomy/v1",
+      classes: Array.from({ length: 10 }, (_, classId) => ({
+        class_id: classId,
+        label: `policy-${classId}`,
+        color_rgb: [classId, classId, classId],
+        disposition: classId === 0 ? "ambiguous" : classId === 9 ? "undefined" : "prediction",
+        material_class: classId === 0 || classId === 9 ? null : "grass",
+        evidence_state: classId === 0 || classId === 9 ? "UNOBSERVED" : "SUPPORTED_GROUND",
+      })),
+    },
+    aggregate_prediction_pixels: Array(10).fill(0),
+    mask_archive: {
+      path: "video/coarse-material-policy-masks.zip",
+      sha256: "8".repeat(64),
+      byte_length: 2048,
+    },
+    valid_fov: {
+      mask_path: "video/valid-fov-mask.png",
+      mask_sha256: "7".repeat(64),
+      outside_valid_fov_class_id: 9,
+    },
+    policy: {
+      presets: {
+        urban: { grass: "NO_GO" },
+        rural: { grass: "HIGH_COST" },
+        offroad: { grass: "HIGH_COST" },
+      },
+    },
+    fusion: {
+      mode: "synchronised-multilayer-review",
+      pixel_raster_fusion: false,
+      camera_semantic_temporal_filter: "none",
+    },
+  };
+}
+
+function fullRouteReview() {
+  const layer = (kind) => ({
+    name: kind === "city" ? "EoMT Cityscapes" : "ddrnet_39",
+    result_id: kind === "city"
+      ? `result-${"2".repeat(64)}`
+      : `lab-v1-ravnoves-video-ddrnet-${"3".repeat(64)}`,
+    frame_count: 6830,
+    taxonomy: {
+      schema_version: kind === "city"
+        ? "missioncore.recorded-eomt-taxonomy/v1"
+        : "missioncore.lab-v1-vegetation-taxonomy/v1",
+      classes: Array.from({ length: kind === "city" ? 16 : 64 }, (_, classId) => ({
+        class_id: classId,
+        label: classId === 0 ? "undefined" : `${kind}-${classId}`,
+        color_rgb: [classId, classId, classId],
+        disposition: classId === 0 ? "undefined" : "prediction",
+      })),
+    },
+    mask_archive: {
+      path: kind === "city"
+        ? "video/eomt-semantic-masks.zip"
+        : "video/ddrnet-semantic-masks.zip",
+      sha256: "4".repeat(64),
+      byte_length: 4096,
+    },
+    inference_fps: 9.5,
+    latency_p95_ms: 101.2,
+    peak_reserved_vram_bytes: 3_000_000_000,
+  });
+  return {
+    source_id: "RAVNOVES004TREE",
+    session_id: "20260828T130511Z_viewer_live",
+    source_job_id: "recorded-camera-eb2783c5480d56bda07c8af0",
+    source_job_input_sha256: "eb2783c5480d56bda07c8af008dff5344d19dc550ef70fe2075d6f098f7cc715",
+    source_stream_sha256: "e5eb017e2cc0f546736eda5235ca157b501913093cb64af5e548e335417e1bac",
+    recorded_media_source_id: "recorded.camera.6a3945242828a038",
+    recorded_media_generation_sha256: "b073ea1e7babf1c77a664e1a5b95e3702d0e05b0e34c1e85a7c67a6f8b392ded",
+    frame_count: 6830,
+    width: 800,
+    height: 600,
+    timeline_start_seconds: 39.215263458,
+    timeline_end_seconds: 757.260263458,
+    timeline: {
+      path: "video/frame-source-times-ns.bin",
+      sha256: "5".repeat(64),
+      byte_length: 6830 * 8,
+      encoding: "uint64-le-nanoseconds",
+      frame_count: 6830,
+    },
+    ground_truth: false,
+    decode_repair: {
+      repaired_frame_count: 1,
+      sequence: 6092,
+      method: "duplicate-previous-decoded-frame",
+      proofs: {
+        eomt: { path: "proofs/decode_repair.json", sha256: "7".repeat(64) },
+        ddrnet: { path: "proofs/ddrnet_decode_repair.json", sha256: "8".repeat(64) },
+      },
+    },
+    layers: { city: layer("city"), vegetation: layer("vegetation") },
+  };
+}
+
+function labPayload(route = routeVideo()) {
+  return {
+    schema_version: "missioncore.lab-v1-vegetation-shadow/v1",
+    result_id: resultId,
+    created_at_utc: "2026-08-27T20:00:00Z",
+    status: "visual-shadow-ready-policy-not-authorized",
+    ground_truth: false,
+    identity: { selected_candidate: "ddrnet" },
+    metrics: {
+      candidates: {
+        ddrnet: candidate("ddrnet", 0.64),
+        ppliteseg: candidate("ppliteseg", 0.61),
+      },
+    },
+    decision: {
+      selected_candidate: "ddrnet",
+      visual_shadow_ready: true,
+      mission_policy_ready_for_configuration: true,
+      navigation_accepted: false,
+      production_accepted: false,
+    },
+    limitations: ["shadow only"],
+    authority: {
+      commands_enabled: false,
+      navigation_or_safety_accepted: false,
+      actuation_accepted: false,
+      camera_semantics_can_clear_rigid_geometry: false,
+    },
+    catalogs: {
+      goose: Array.from({ length: 12 }, (_, index) => visualCase("goose", index)),
+      ravnoves: [],
+    },
+    route_video: route,
+    access: "read-only",
+  };
+}
+
 test("vegetation LAB keeps autonomous assets and fail-closed authority", async () => {
   let requestedUrl = "";
   const result = await fetchVegetationShadowResult(resultId, {
     fetcher: async (url) => {
       requestedUrl = String(url);
-      return new Response(JSON.stringify({
-        schema_version: "missioncore.lab-v1-vegetation-shadow/v1",
-        result_id: resultId,
-        created_at_utc: "2026-08-27T20:00:00Z",
-        status: "visual-shadow-ready-policy-not-authorized",
-        ground_truth: false,
-        identity: { selected_candidate: "ddrnet" },
-        metrics: {
-          candidates: {
-            ddrnet: candidate("ddrnet", 0.64),
-            ppliteseg: candidate("ppliteseg", 0.61),
-          },
-        },
-        decision: {
-          selected_candidate: "ddrnet",
-          visual_shadow_ready: true,
-          mission_policy_ready_for_configuration: true,
-          navigation_accepted: false,
-          production_accepted: false,
-        },
-        limitations: ["shadow only"],
-        authority: {
-          commands_enabled: false,
-          navigation_or_safety_accepted: false,
-          actuation_accepted: false,
-          camera_semantics_can_clear_rigid_geometry: false,
-        },
-        catalogs: {
-          goose: Array.from({ length: 12 }, (_, index) => visualCase("goose", index)),
-          ravnoves: [],
-        },
-        route_video: routeVideo(),
-        access: "read-only",
-      }), { status: 200, headers: { "Content-Type": "application/json" } });
+      return new Response(JSON.stringify(labPayload()), {
+        status: 200,
+        headers: { "Content-Type": "application/json" },
+      });
     },
   });
   assert.equal(
@@ -154,6 +273,8 @@ test("vegetation LAB keeps autonomous assets and fail-closed authority", async (
   assert.equal(result.routeCases.length, 0);
   assert.equal(result.validationCases.length, 12);
   assert.equal(result.routeVideo.frameCount, 4489);
+  assert.equal(result.routeVideo.viewKind, "fine-semantic-prediction");
+  assert.equal(result.routeVideo.linkedTgsResultId, null);
   assert.equal(result.routeVideo.taxonomy[0].disposition, "undefined");
   assert.equal(result.validationCases[0].focus.className, "high_grass");
   assert.match(result.validationCases[0].assets.ddrnet_error, /\/assets\/visual\/goose\//);
@@ -165,15 +286,109 @@ test("vegetation LAB keeps autonomous assets and fail-closed authority", async (
   });
 });
 
-test("vegetation LAB reuses the admitted M4.8 and M4.7 instruments", async () => {
-  const resultSource = await readFile(
-    new URL("../src/workspaces/laboratory/VegetationShadowResult.tsx", import.meta.url),
-    "utf8",
+test("vegetation LAB parses coarse material policy and sealed TGS binding", async () => {
+  const result = await fetchVegetationShadowResult(resultId, {
+    fetcher: async () => new Response(JSON.stringify(labPayload(coarseRouteVideo())), {
+      status: 200,
+      headers: { "Content-Type": "application/json" },
+    }),
+  });
+  assert.equal(result.routeVideo.viewKind, "coarse-material-policy-review");
+  assert.match(result.routeVideo.linkedTgsResultId, /^m49-tgs-full-shadow-/);
+  assert.equal(result.routeVideo.taxonomy.length, 10);
+  assert.equal(result.routeVideo.taxonomy[0].evidenceState, "UNOBSERVED");
+  assert.equal(result.routeVideo.policyPresets.urban.grass, "NO_GO");
+  assert.equal(result.routeVideo.fusionMode, "synchronised-multilayer-review");
+});
+
+test("vegetation LAB parses the full 004 pass inside the existing result contract", async () => {
+  const payload = {
+    ...labPayload(null),
+    catalogs: { goose: [], ravnoves: [] },
+    route_full_review: fullRouteReview(),
+  };
+  const timeline = new ArrayBuffer(6830 * 8);
+  const timelineView = new DataView(timeline);
+  for (let index = 0; index < 6830; index += 1) {
+    timelineView.setBigUint64(
+      index * 8,
+      BigInt(39_215_263_458 + index * 100_000_000),
+      true,
+    );
+  }
+  const result = await fetchVegetationShadowResult(resultId, {
+    fetcher: async (url) => String(url).endsWith("/route-timeline")
+      ? new Response(timeline, {
+        status: 200,
+        headers: {
+          "Content-Type": "application/octet-stream",
+          ETag: `"${"5".repeat(64)}"`,
+        },
+      })
+      : new Response(JSON.stringify(payload), {
+        status: 200,
+        headers: { "Content-Type": "application/json" },
+      }),
+  });
+  assert.equal(result.routeVideo, null);
+  assert.equal(result.routeFullReview.frameCount, 6830);
+  assert.equal(result.routeFullReview.city.taxonomy.length, 16);
+  assert.equal(result.routeFullReview.vegetation.taxonomy.length, 64);
+  assert.equal(result.routeFullReview.decodeRepair.sequence, 6092);
+  assert.equal(result.routeFullReview.frameSourceTimesNs.length, 6830);
+  assert.equal(
+    vegetationFullRouteMaskUrl(resultId, "vegetation", 6829),
+    `/api/v1/laboratory/vegetation-shadow/${resultId}/route-masks/vegetation/6829`,
   );
-  assert.match(resultSource, /M48MaskComparisonVisual/);
+});
+
+test("vegetation GOOSE benchmark opens through its separate archival endpoint", async () => {
+  let requestedUrl = "";
+  const result = await fetchVegetationBenchmarkResult(benchmarkResultId, {
+    fetcher: async (url) => {
+      requestedUrl = String(url);
+      return new Response(JSON.stringify({
+        ...labPayload(null),
+        result_id: benchmarkResultId,
+      }), {
+        status: 200,
+        headers: { "Content-Type": "application/json" },
+      });
+    },
+  });
+  assert.equal(
+    requestedUrl,
+    `/api/v1/laboratory/vegetation-benchmark/${benchmarkResultId}`,
+  );
+  assert.equal(result.routeVideo, null);
+  assert.equal(result.validationCases.length, 12);
+});
+
+test("vegetation realtime LAB and archival benchmark use separate admitted instruments", async () => {
+  const [resultSource, benchmarkSource] = await Promise.all([
+    readFile(
+      new URL("../src/workspaces/laboratory/VegetationShadowResult.tsx", import.meta.url),
+      "utf8",
+    ),
+    readFile(
+      new URL("../src/workspaces/laboratory/VegetationBenchmarkResult.tsx", import.meta.url),
+      "utf8",
+    ),
+  ]);
+  assert.doesNotMatch(resultSource, /M48MaskComparisonVisual/);
   assert.match(resultSource, /M4ReplayThreatVisual/);
-  assert.equal(resultSource.match(/<LaboratoryEvidence\b/g)?.length, 2);
-  assert.match(resultSource, /showReferenceMediaLayers=\{false\}/);
+  assert.match(resultSource, /M49TgsFullShadowEvidence/);
+  assert.match(resultSource, /semanticOverride/);
+  assert.match(resultSource, /EoMT CITY \/ DDRNet VEGETATION/);
+  assert.equal(resultSource.match(/<LaboratoryEvidence\b/g)?.length, 4);
+  assert.match(resultSource, /RAVNOVES004TREE mixed route review/);
+  assert.match(resultSource, /RAVNOVES004TREE full recorded review/);
+  assert.match(resultSource, /LaboratoryRecordedClipPlayer/);
+  assert.match(resultSource, /className="m48-clip-player__overlay"/);
+  assert.match(resultSource, /linkedTgsResultId/);
+  assert.match(benchmarkSource, /M48MaskComparisonVisual/);
+  assert.doesNotMatch(benchmarkSource, /M49TgsFullShadowEvidence/);
+  assert.equal(benchmarkSource.match(/<LaboratoryEvidence\b/g)?.length, 1);
   assert.doesNotMatch(resultSource, /VegetationRouteVisual|urban\/rural\/off-road presets/);
   await assert.rejects(
     access(new URL("../src/workspaces/laboratory/VegetationShadowVisual.tsx", import.meta.url)),

config/laboratories/lab-v1-vegetation-benchmark.json

@@ -0,0 +1,10 @@
+{
+  "schema_version": "missioncore.laboratory-evidence-definition/v1",
+  "work_id": "lab-v1-vegetation-benchmark",
+  "evidence": {
+    "runtime_relative_root": "lab-v1-vegetation-benchmark/results",
+    "result_id_prefix": "lab-v1-vegetation-benchmark",
+    "document_name": "result.json",
+    "schema_version": "missioncore.lab-v1-vegetation-shadow/v1"
+  }
+}

config/laboratory-execution.json

@@ -212,6 +212,7 @@
     }
   ],
   "legacy_work_ids": [
+    "lab-v1-vegetation-benchmark",
     "m48r3-static-occupancy-shadow",
     "m47-reference-graph-shadow",
     "e31-source-binding",

config/laboratory-value-review.json

@@ -282,10 +282,17 @@
       "lifecycle": "current",
       "visual_evidence": "available"
     },
+    {
+      "catalog_id": "lab-v1-vegetation-benchmark",
+      "evidence_id": "lab-v1-vegetation-benchmark-a8944d6c2d1102d81da78bcb4963760c9288db0421d9f2686afcbdd14b610d3d",
+      "signal": "progress",
+      "lifecycle": "current",
+      "visual_evidence": "available"
+    },
     {
       "catalog_id": "lab-v1-vegetation-shadow",
-      "evidence_id": "lab-v1-vegetation-shadow-ad4d9fbbb21ff8a270b77f559b4e78dcdaf0455afd61afb5033009623984e554",
-      "signal": "failed",
+      "evidence_id": "lab-v1-vegetation-shadow-d179462134967ace1c5ebd6fbdbdd8659905d390484b9c01ea7930f083bb74d1",
+      "signal": "progress",
       "lifecycle": "current",
       "visual_evidence": "available"
     }

config/perception/lab-v1-ravnoves004tree-full-video-source-v1.json

@@ -0,0 +1,19 @@
+{
+  "schema_version": "missioncore.lab-v1-ravnoves-source/v1",
+  "profile_id": "ravnoves004tree-full-video-source/v1",
+  "source": {
+    "source_id": "RAVNOVES004TREE/right-e5eb017e2cc0f546736eda5235ca157b501913093cb64af5e548e335417e1bac",
+    "source_sha256": "e5eb017e2cc0f546736eda5235ca157b501913093cb64af5e548e335417e1bac",
+    "source_job_id": "recorded-camera-eb2783c5480d56bda07c8af0",
+    "source_job_input_sha256": "eb2783c5480d56bda07c8af008dff5344d19dc550ef70fe2075d6f098f7cc715",
+    "session_id": "20260828T130511Z_viewer_live",
+    "base_m4_result_id": null,
+    "expected_width": 800,
+    "expected_height": 600,
+    "expected_frame_count": 6830,
+    "timeline_start_seconds": 39.215263458,
+    "timeline_end_seconds": 757.260263458,
+    "frame_indices": [],
+    "crop_contract": "center-600-square-to-512; outside-crop-is-undefined"
+  }
+}

config/perception/lab-v1-vegetation-integrated-multirate-phased-shadow-v3.json

@@ -0,0 +1,82 @@
+{
+  "schema_version": "missioncore.lab-v1-vegetation-integrated-shadow-profile/v3",
+  "profile_id": "lab-v1-ravnoves00-ddrnet-m49-integrated-multirate-phased-shadow/v3",
+  "source": {
+    "source_id": "RAVNOVES00",
+    "expected_timeline_frames": 4489,
+    "requested_source_rate_hz": 12.0,
+    "shared_start_barrier": true,
+    "ground_truth_available": false
+  },
+  "stages": {
+    "m49_graph_tgs": {
+      "profile": "m49-tgs-integrated-graph-shadow-v1.json",
+      "profile_sha256": "b61e018b2d04eec58802e2d4186ce7a3dd3a15b254db106b57b609e903eeef80",
+      "candidate": "frozen-native-rf-detr-plus-cpu-tgs",
+      "parameters_unchanged": true,
+      "timeline_rate_hz": 12.0
+    },
+    "vegetation": {
+      "candidate_id": "ddrnet_39-goose-fine-64",
+      "candidate_key": "ddrnet",
+      "checkpoint_sha256": "b99c2838051bcd7b092fd3970aa62a77d5c0bbb809c9b9afb2ff4b0ebdaa4ee6",
+      "config_sha256": "96a427a8baae387b827ec9c0bf7ca42e3fb9114b8fa9a8671bbc9d10877670b9",
+      "policy_sha256": "b75c4ac841d7b4bcc57f7a9c8417ca2317d8ecfa499e72a9af8a8591a2ec0d35",
+      "provider_map_sha256": "f2b69046b6a740fd9532d2d88e7fabae7c20fb662f783c9502adc9026406f352",
+      "container_image": "ndc/mission-core-lab-v1-goose:sg3.2.0-cu117-v1",
+      "container_image_id": "sha256:591cb382c099eeb05e7ec16e2371e0b2da54d2bb5c49ec0f4ac88dbf72b0f0cd",
+      "timeline_rate_hz": 12.0,
+      "inference_rate_hz": 6.0,
+      "inference_stride": 2,
+      "inference_phase_offset_ms": 40.0,
+      "held_evidence_fail_closed": true,
+      "semantic_output_persisted": false,
+      "one_heavy_vegetation_candidate_at_a_time": true
+    }
+  },
+  "acceptance": {
+    "minimum_graph_world_state_fps": 11.209069,
+    "minimum_vegetation_timeline_fps": 11.209069,
+    "minimum_vegetation_inference_fps": 5.604534,
+    "maximum_vegetation_inference_completion_p95_ms": 125.0,
+    "maximum_semantic_evidence_source_age_ms": 125.0,
+    "maximum_combined_output_age_p99_ms": 125.0,
+    "capacity_drop_count_max": 0,
+    "unaccounted_frame_count_max": 0
+  },
+  "telemetry": {
+    "sample_interval_seconds": 1.0,
+    "required_roles": [
+      "graph",
+      "triton",
+      "tgs",
+      "vegetation"
+    ]
+  },
+  "invariants": {
+    "raw_fisheye_immutable": true,
+    "reference_graph_parameters_unchanged": true,
+    "tgs_parameters_unchanged": true,
+    "ddrnet_parameters_unchanged": true,
+    "safety_layers_remain_12hz": true,
+    "vegetation_gpu_phase_follows_safety_detector": true,
+    "held_semantic_evidence_is_advisory_only": true,
+    "vegetation_source_buffer_bounded": true,
+    "vegetation_full_route_rgb_prefetch_allowed": false,
+    "ppliteseg_concurrent_run_allowed": false,
+    "camera_semantics_can_clear_rigid_geometry": false,
+    "canonical_triton_mutation_allowed": false,
+    "runtime_shared_source_frame_target": true,
+    "gauss_or_playcanvas_in_scope": false
+  },
+  "authority": {
+    "visual_quality_accepted": false,
+    "route_truth_available": false,
+    "traversability_accepted": false,
+    "physical_free_space_accepted": false,
+    "commands_enabled": false,
+    "actuation_allowed": false,
+    "navigation_or_safety_accepted": false,
+    "production_accepted": false
+  }
+}

config/perception/lab-v1-vegetation-integrated-multirate-shadow-v2.json

@@ -0,0 +1,80 @@
+{
+  "schema_version": "missioncore.lab-v1-vegetation-integrated-shadow-profile/v2",
+  "profile_id": "lab-v1-ravnoves00-ddrnet-m49-integrated-multirate-shadow/v2",
+  "source": {
+    "source_id": "RAVNOVES00",
+    "expected_timeline_frames": 4489,
+    "requested_source_rate_hz": 12.0,
+    "shared_start_barrier": true,
+    "ground_truth_available": false
+  },
+  "stages": {
+    "m49_graph_tgs": {
+      "profile": "m49-tgs-integrated-graph-shadow-v1.json",
+      "profile_sha256": "b61e018b2d04eec58802e2d4186ce7a3dd3a15b254db106b57b609e903eeef80",
+      "candidate": "frozen-native-rf-detr-plus-cpu-tgs",
+      "parameters_unchanged": true,
+      "timeline_rate_hz": 12.0
+    },
+    "vegetation": {
+      "candidate_id": "ddrnet_39-goose-fine-64",
+      "candidate_key": "ddrnet",
+      "checkpoint_sha256": "b99c2838051bcd7b092fd3970aa62a77d5c0bbb809c9b9afb2ff4b0ebdaa4ee6",
+      "config_sha256": "96a427a8baae387b827ec9c0bf7ca42e3fb9114b8fa9a8671bbc9d10877670b9",
+      "policy_sha256": "b75c4ac841d7b4bcc57f7a9c8417ca2317d8ecfa499e72a9af8a8591a2ec0d35",
+      "provider_map_sha256": "f2b69046b6a740fd9532d2d88e7fabae7c20fb662f783c9502adc9026406f352",
+      "container_image": "ndc/mission-core-lab-v1-goose:sg3.2.0-cu117-v1",
+      "container_image_id": "sha256:591cb382c099eeb05e7ec16e2371e0b2da54d2bb5c49ec0f4ac88dbf72b0f0cd",
+      "timeline_rate_hz": 12.0,
+      "inference_rate_hz": 6.0,
+      "inference_stride": 2,
+      "held_evidence_fail_closed": true,
+      "semantic_output_persisted": false,
+      "one_heavy_vegetation_candidate_at_a_time": true
+    }
+  },
+  "acceptance": {
+    "minimum_graph_world_state_fps": 11.209069,
+    "minimum_vegetation_timeline_fps": 11.209069,
+    "minimum_vegetation_inference_fps": 5.604534,
+    "maximum_vegetation_inference_completion_p95_ms": 125.0,
+    "maximum_semantic_evidence_source_age_ms": 125.0,
+    "maximum_combined_output_age_p99_ms": 125.0,
+    "capacity_drop_count_max": 0,
+    "unaccounted_frame_count_max": 0
+  },
+  "telemetry": {
+    "sample_interval_seconds": 1.0,
+    "required_roles": [
+      "graph",
+      "triton",
+      "tgs",
+      "vegetation"
+    ]
+  },
+  "invariants": {
+    "raw_fisheye_immutable": true,
+    "reference_graph_parameters_unchanged": true,
+    "tgs_parameters_unchanged": true,
+    "ddrnet_parameters_unchanged": true,
+    "safety_layers_remain_12hz": true,
+    "held_semantic_evidence_is_advisory_only": true,
+    "vegetation_source_buffer_bounded": true,
+    "vegetation_full_route_rgb_prefetch_allowed": false,
+    "ppliteseg_concurrent_run_allowed": false,
+    "camera_semantics_can_clear_rigid_geometry": false,
+    "canonical_triton_mutation_allowed": false,
+    "runtime_shared_source_frame_target": true,
+    "gauss_or_playcanvas_in_scope": false
+  },
+  "authority": {
+    "visual_quality_accepted": false,
+    "route_truth_available": false,
+    "traversability_accepted": false,
+    "physical_free_space_accepted": false,
+    "commands_enabled": false,
+    "actuation_allowed": false,
+    "navigation_or_safety_accepted": false,
+    "production_accepted": false
+  }
+}

config/perception/lab-v1-vegetation-integrated-shadow-v1.json

@@ -0,0 +1,71 @@
+{
+  "schema_version": "missioncore.lab-v1-vegetation-integrated-shadow-profile/v1",
+  "profile_id": "lab-v1-ravnoves00-ddrnet-m49-integrated-shadow/v1",
+  "source": {
+    "source_id": "RAVNOVES00",
+    "expected_timeline_frames": 4489,
+    "requested_source_rate_hz": 12.0,
+    "shared_start_barrier": true,
+    "ground_truth_available": false
+  },
+  "stages": {
+    "m49_graph_tgs": {
+      "profile": "m49-tgs-integrated-graph-shadow-v1.json",
+      "profile_sha256": "b61e018b2d04eec58802e2d4186ce7a3dd3a15b254db106b57b609e903eeef80",
+      "candidate": "frozen-native-rf-detr-plus-cpu-tgs",
+      "parameters_unchanged": true
+    },
+    "vegetation": {
+      "candidate_id": "ddrnet_39-goose-fine-64",
+      "candidate_key": "ddrnet",
+      "checkpoint_sha256": "b99c2838051bcd7b092fd3970aa62a77d5c0bbb809c9b9afb2ff4b0ebdaa4ee6",
+      "config_sha256": "96a427a8baae387b827ec9c0bf7ca42e3fb9114b8fa9a8671bbc9d10877670b9",
+      "policy_sha256": "b75c4ac841d7b4bcc57f7a9c8417ca2317d8ecfa499e72a9af8a8591a2ec0d35",
+      "provider_map_sha256": "f2b69046b6a740fd9532d2d88e7fabae7c20fb662f783c9502adc9026406f352",
+      "container_image": "ndc/mission-core-lab-v1-goose:sg3.2.0-cu117-v1",
+      "container_image_id": "sha256:591cb382c099eeb05e7ec16e2371e0b2da54d2bb5c49ec0f4ac88dbf72b0f0cd",
+      "semantic_output_persisted": false,
+      "one_heavy_vegetation_candidate_at_a_time": true
+    }
+  },
+  "acceptance": {
+    "minimum_graph_world_state_fps": 11.209069,
+    "minimum_vegetation_fps": 11.209069,
+    "maximum_vegetation_completion_p95_ms": 125.0,
+    "maximum_combined_output_age_p99_ms": 125.0,
+    "capacity_drop_count_max": 0,
+    "unaccounted_frame_count_max": 0
+  },
+  "telemetry": {
+    "sample_interval_seconds": 1.0,
+    "required_roles": [
+      "graph",
+      "triton",
+      "tgs",
+      "vegetation"
+    ]
+  },
+  "invariants": {
+    "raw_fisheye_immutable": true,
+    "reference_graph_parameters_unchanged": true,
+    "tgs_parameters_unchanged": true,
+    "ddrnet_parameters_unchanged": true,
+    "vegetation_source_buffer_bounded": true,
+    "vegetation_full_route_rgb_prefetch_allowed": false,
+    "ppliteseg_concurrent_run_allowed": false,
+    "camera_semantics_can_clear_rigid_geometry": false,
+    "canonical_triton_mutation_allowed": false,
+    "runtime_shared_source_frame_target": true,
+    "gauss_or_playcanvas_in_scope": false
+  },
+  "authority": {
+    "visual_quality_accepted": false,
+    "route_truth_available": false,
+    "traversability_accepted": false,
+    "physical_free_space_accepted": false,
+    "commands_enabled": false,
+    "actuation_allowed": false,
+    "navigation_or_safety_accepted": false,
+    "production_accepted": false
+  }
+}

config/perception/mixed-route-tgs-review-v1.json

@@ -0,0 +1,68 @@
+{
+  "schema_version": "missioncore.mixed-route-tgs-review-profile/v1",
+  "profile_id": "ravnoves004tree-mixed-route-tgs-review/v1",
+  "source": {
+    "source_id": "RAVNOVES004TREE",
+    "session_id": "20260828T130511Z_viewer_live",
+    "review_pack_id": "mixed-route-review-pack-a8d245eb08a9581a994c4ae5ad242fec20f02c7c512c5ca5d3a6dd9464012753",
+    "source_pack_id": "mixed-route-lidar-pack-e3fe195588cc4a2ec17e15af6f46582ed71c9bed643943779c4ed5e565a3c839",
+    "source_pack_sha256": "10c759463da7711fbbe67e70df931597d85ab21325f7f8026e2c945b677e1bc6",
+    "input_coordinate_frame": "map-gravity-local-translation-only"
+  },
+  "tgs": {
+    "max_range_m": 80.0,
+    "min_range_m": 1.0,
+    "resolution_m": 8.0,
+    "num_iterations": 3,
+    "num_lowest_representative_points": 5,
+    "minimum_points": 10,
+    "seed_threshold_m": 0.5,
+    "distance_threshold_m": 0.125,
+    "outlier_threshold_m": 0.3,
+    "normal_threshold": 0.94,
+    "weight_threshold": 200.0,
+    "lcc_normal_similarity": 0.03,
+    "lcc_planar_distance_m": 0.1,
+    "obstacle_height_m": 1.0,
+    "refine_mode": true
+  },
+  "profiles": {
+    "current_increment": {
+      "role": "diagnostic-current-evidence"
+    },
+    "causal_rolling_1s": {
+      "role": "primary-local-evidence",
+      "history_seconds": 1.0,
+      "local_radius_m": 12.0
+    }
+  },
+  "costmap": {
+    "coordinate_frame": "map-gravity-local",
+    "cell_size_m": 0.45,
+    "radius_m": 12.0,
+    "state_priority": [
+      "NONGROUND_OCCUPIED",
+      "UNKNOWN_REJECTED",
+      "GROUND_SUPPORT",
+      "UNOBSERVED"
+    ]
+  },
+  "state_codes": {
+    "UNOBSERVED": 0,
+    "GROUND_SUPPORT": 1,
+    "NONGROUND_OCCUPIED": 2,
+    "UNKNOWN_REJECTED": 3
+  },
+  "invariants": {
+    "all_eligible_input_points_accounted": true,
+    "aos_allowed": false,
+    "lidar_orientation_applied_to_tgs_input": false,
+    "map_gravity_axis_preserved": true,
+    "missing_support_means_free": false,
+    "unobserved_cells_are_emitted": true,
+    "camera_projection_is_authoritative": false,
+    "future_frames_used": false,
+    "gpu_allowed": false,
+    "navigation_or_actuation_allowed": false
+  }
+}

experiments/perception/prepare_mixed_route_lidar_pack.py

@@ -0,0 +1,418 @@
+#!/usr/bin/env python3
+"""Publish LiDAR/pose evidence aligned to an immutable mixed-route review pack."""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import os
+import shutil
+import tempfile
+from datetime import UTC, datetime
+from pathlib import Path
+from typing import Any
+
+import numpy as np
+from fuse_e6_tracking_lidar import CameraAnchor, _lidar_samples
+
+from k1link.compute.jobs import validate_camera_compute_job
+from k1link.device_plugins.xgrids_k1.analyze.calibrated_overlay import (
+    _load_calibration_snapshot,
+)
+from k1link.device_plugins.xgrids_k1.analyze.calibrated_projection import (
+    Kb4ProjectionProfile,
+)
+from k1link.device_plugins.xgrids_k1.mqtt.capture import read_capture_clock_origin
+from k1link.device_plugins.xgrids_k1.protocol.streams import decode_lio_pcl
+from k1link.device_plugins.xgrids_k1.viewer.replay import iter_replay_messages
+
+SCHEMA = "missioncore.mixed-route-lidar-pack/v1"
+REVIEW_SCHEMA = "missioncore.mixed-route-review-pack/v1"
+MAXIMUM_LIDAR_CAMERA_DELTA_MS = 100.0
+MAXIMUM_POSE_POINT_DELTA_MS = 100.0
+CAUSAL_HISTORY_SECONDS = 1.0
+
+
+class MixedRouteLidarPackError(RuntimeError):
+    """The recorded route cannot satisfy the selected LiDAR evidence contract."""
+
+
+def _canonical_json(value: object) -> bytes:
+    return json.dumps(
+        value,
+        ensure_ascii=False,
+        sort_keys=True,
+        separators=(",", ":"),
+        allow_nan=False,
+    ).encode("utf-8")
+
+
+def _sha256(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as stream:
+        for chunk in iter(lambda: stream.read(1024 * 1024), b""):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+def _arguments() -> argparse.Namespace:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--job", type=Path, required=True)
+    parser.add_argument("--session", type=Path, required=True)
+    parser.add_argument("--review-pack", type=Path, required=True)
+    parser.add_argument("--calibration", type=Path, required=True)
+    parser.add_argument("--output-root", type=Path, required=True)
+    return parser.parse_args()
+
+
+def _read_review_pack(root: Path) -> tuple[dict[str, Any], list[dict[str, Any]]]:
+    resolved = root.resolve(strict=True)
+    manifest_path = resolved / "manifest.json"
+    try:
+        manifest = json.loads(manifest_path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError) as exc:
+        raise MixedRouteLidarPackError("mixed-route review manifest is invalid") from exc
+    identity = manifest.get("identity") if isinstance(manifest, dict) else None
+    timeline = manifest.get("timeline") if isinstance(manifest, dict) else None
+    frames = manifest.get("frames") if isinstance(manifest, dict) else None
+    if (
+        manifest.get("schema_version") != REVIEW_SCHEMA
+        or not isinstance(identity, dict)
+        or identity.get("schema_version") != REVIEW_SCHEMA
+        or identity.get("ground_truth") is not False
+        or not isinstance(timeline, dict)
+        or not isinstance(frames, list)
+        or manifest.get("frame_count") != len(frames)
+        or not frames
+    ):
+        raise MixedRouteLidarPackError("mixed-route review contract changed")
+    timeline_path = resolved / str(timeline.get("path"))
+    if (
+        not timeline_path.is_file()
+        or timeline.get("sha256") != _sha256(timeline_path)
+        or timeline.get("byte_length") != timeline_path.stat().st_size
+    ):
+        raise MixedRouteLidarPackError("mixed-route review timeline changed")
+    rows: list[dict[str, Any]] = []
+    previous_seconds = -1.0
+    with timeline_path.open(encoding="utf-8") as stream:
+        for expected, line in enumerate(stream):
+            try:
+                row = json.loads(line)
+            except json.JSONDecodeError as exc:
+                raise MixedRouteLidarPackError("mixed-route timeline JSON is invalid") from exc
+            seconds = row.get("session_seconds") if isinstance(row, dict) else None
+            if (
+                not isinstance(row, dict)
+                or row.get("frame_index") != expected
+                or row.get("sequence") != expected + 1
+                or row.get("source_sequence") != row.get("source_frame_index") + 1
+                or not isinstance(seconds, (int, float))
+                or isinstance(seconds, bool)
+                or float(seconds) <= previous_seconds
+            ):
+                raise MixedRouteLidarPackError("mixed-route timeline row changed")
+            rows.append(row)
+            previous_seconds = float(seconds)
+    if len(rows) != len(frames):
+        raise MixedRouteLidarPackError("mixed-route timeline is incomplete")
+    for frame in frames:
+        path = resolved / str(frame.get("path"))
+        if (
+            not path.is_file()
+            or frame.get("byte_length") != path.stat().st_size
+            or frame.get("sha256") != _sha256(path)
+        ):
+            raise MixedRouteLidarPackError("mixed-route source frame changed")
+    return manifest, rows
+
+
+def _causal_history_clouds(
+    raw_path: Path,
+    *,
+    origin_monotonic_ns: int,
+    sample_seconds: list[float],
+) -> list[np.ndarray]:
+    grouped: list[list[np.ndarray]] = [[] for _ in sample_seconds]
+    last = sample_seconds[-1]
+    for message in iter_replay_messages(raw_path):
+        monotonic_ns = message.received_monotonic_ns
+        if not isinstance(monotonic_ns, int) or monotonic_ns < origin_monotonic_ns:
+            raise MixedRouteLidarPackError("MQTT replay message has no compatible clock")
+        seconds = (monotonic_ns - origin_monotonic_ns) / 1e9
+        if seconds > last:
+            break
+        if not message.topic.endswith("/lio_pcl"):
+            continue
+        matching = [
+            index
+            for index, sample_time in enumerate(sample_seconds)
+            if sample_time - CAUSAL_HISTORY_SECONDS <= seconds <= sample_time
+        ]
+        if not matching:
+            continue
+        frame = decode_lio_pcl(message.payload)
+        cloud = np.asarray(
+            [point.scaled_xyz(frame.header.scaler) for point in frame.points],
+            dtype=np.float32,
+        ).reshape((-1, 3))
+        if cloud.shape[0] == 0 or not np.isfinite(cloud).all():
+            raise MixedRouteLidarPackError("causal LiDAR history is empty or non-finite")
+        for index in matching:
+            grouped[index].append(cloud)
+    result: list[np.ndarray] = []
+    for clouds in grouped:
+        if not clouds:
+            raise MixedRouteLidarPackError("selected frame has no causal LiDAR history")
+        result.append(np.concatenate(clouds))
+    return result
+
+
+def prepare(
+    *,
+    job_root: Path,
+    session_root: Path,
+    review_pack_root: Path,
+    calibration_root: Path,
+    output_root: Path,
+) -> Path:
+    job = validate_camera_compute_job(job_root)
+    session = session_root.resolve(strict=True)
+    if not session.is_dir() or session.name != job.session_id:
+        raise MixedRouteLidarPackError("camera job and observation session differ")
+    review, timeline = _read_review_pack(review_pack_root)
+    review_identity = review["identity"]
+    if (
+        review_identity.get("job_id") != job.job_id
+        or review_identity.get("input_sha256") != job.input_sha256
+        or review_identity.get("session_id") != job.session_id
+        or review_identity.get("source_id") != job.source_id
+        or review_identity.get("codec_epoch") != job.codec_epoch
+    ):
+        raise MixedRouteLidarPackError("review pack and camera job differ")
+
+    calibration, calibration_sha256 = _load_calibration_snapshot(
+        calibration_root.resolve(strict=True)
+    )
+    projection = Kb4ProjectionProfile.from_factory_calibration(calibration, job.source_id)
+    capture_root = session / "captures" / "mqtt_live"
+    origin_path = capture_root / "mqtt.timeline.origin.json"
+    origin = read_capture_clock_origin(origin_path)
+    anchors = [
+        CameraAnchor(
+            frame_index=int(row["frame_index"]),
+            source_frame_index=int(row["source_frame_index"]),
+            host_session_seconds=(
+                int(row["host_monotonic_ns"]) - origin.started_monotonic_ns
+            )
+            / 1e9,
+            video_session_seconds=float(row["session_seconds"]),
+        )
+        for row in timeline
+    ]
+    if any(
+        anchor.host_session_seconds != anchor.video_session_seconds
+        for anchor in anchors
+    ):
+        raise MixedRouteLidarPackError("review timeline does not use host arrival time")
+    samples = list(
+        _lidar_samples(
+            capture_root / "mqtt.raw.k1mqtt",
+            anchors,
+            origin_monotonic_ns=origin.started_monotonic_ns,
+            maximum_lidar_camera_delta_s=MAXIMUM_LIDAR_CAMERA_DELTA_MS / 1000.0,
+            maximum_pose_point_delta_s=MAXIMUM_POSE_POINT_DELTA_MS / 1000.0,
+        )
+    )
+    if len(samples) != len(anchors):
+        raise MixedRouteLidarPackError("LiDAR sampler did not account for every anchor")
+
+    count = len(anchors)
+    available = np.zeros((count,), dtype=np.bool_)
+    offsets = [0]
+    clouds: list[np.ndarray] = []
+    positions = np.full((count, 3), np.nan, dtype=np.float64)
+    quaternions = np.full((count, 4), np.nan, dtype=np.float64)
+    lidar_delta = np.full((count,), np.nan, dtype=np.float64)
+    pose_delta = np.full((count,), np.nan, dtype=np.float64)
+    sample_seconds: list[float] = []
+    for index, (anchor, sample) in enumerate(zip(anchors, samples, strict=True)):
+        if sample is None:
+            offsets.append(offsets[-1])
+            sample_seconds.append(float("nan"))
+            continue
+        cloud = np.asarray(
+            [
+                point.scaled_xyz(sample.point_frame.header.scaler)
+                for point in sample.point_frame.points
+            ],
+            dtype=np.float32,
+        ).reshape((-1, 3))
+        if cloud.shape[0] == 0 or not np.isfinite(cloud).all():
+            raise MixedRouteLidarPackError("selected LiDAR sample is empty or non-finite")
+        available[index] = True
+        clouds.append(cloud)
+        offsets.append(offsets[-1] + cloud.shape[0])
+        positions[index] = sample.pose_frame.position_xyz
+        quaternions[index] = sample.pose_frame.orientation_xyzw
+        lidar_delta[index] = (
+            sample.point_session_seconds - anchor.host_session_seconds
+        ) * 1000.0
+        pose_delta[index] = (
+            sample.pose_session_seconds - sample.point_session_seconds
+        ) * 1000.0
+        sample_seconds.append(sample.point_session_seconds)
+
+    if not available.all() or not np.isfinite(np.asarray(sample_seconds)).all():
+        raise MixedRouteLidarPackError(
+            "every mixed-route review island must have a temporally admissible LiDAR sample"
+        )
+    history_clouds = _causal_history_clouds(
+        capture_root / "mqtt.raw.k1mqtt",
+        origin_monotonic_ns=origin.started_monotonic_ns,
+        sample_seconds=sample_seconds,
+    )
+    history_offsets = [0]
+    for cloud in history_clouds:
+        history_offsets.append(history_offsets[-1] + cloud.shape[0])
+
+    identity = {
+        "schema_version": SCHEMA,
+        "job_id": job.job_id,
+        "input_sha256": job.input_sha256,
+        "session_id": job.session_id,
+        "source_id": job.source_id,
+        "camera_slot": "camera_1",
+        "calibration_sha256": calibration_sha256,
+        "review_pack_id": review["pack_id"],
+        "review_pack_identity_sha256": review["identity_sha256"],
+        "selected_source_frame_indices": [
+            int(row["source_frame_index"]) for row in timeline
+        ],
+        "frame_count": count,
+        "available_lidar_frames": int(available.sum()),
+        "point_count": int(offsets[-1]),
+        "causal_history_seconds": CAUSAL_HISTORY_SECONDS,
+        "causal_history_point_count": int(history_offsets[-1]),
+        "temporal_policy": {
+            "binding": "nearest-host-arrival-best-effort",
+            "maximum_lidar_camera_delta_ms": MAXIMUM_LIDAR_CAMERA_DELTA_MS,
+            "maximum_pose_point_delta_ms": MAXIMUM_POSE_POINT_DELTA_MS,
+            "clock_source": "recorded-host-monotonic-arrival",
+        },
+        "projection": {
+            "model": "kb4",
+            "width": projection.width,
+            "height": projection.height,
+            "source_coordinates": "k1-map",
+            "target_camera": job.source_id,
+        },
+        "ground_truth": False,
+        "authority": {
+            "navigation_or_safety_accepted": False,
+            "actuation_allowed": False,
+        },
+        "producer_sha256": _sha256(Path(__file__).resolve(strict=True)),
+    }
+    identity_sha256 = hashlib.sha256(_canonical_json(identity)).hexdigest()
+    pack_id = f"mixed-route-lidar-pack-{identity_sha256}"
+    parent = output_root.resolve()
+    parent.mkdir(mode=0o700, parents=True, exist_ok=True)
+    final = parent / pack_id
+    if final.exists():
+        return final
+    staging = Path(tempfile.mkdtemp(prefix=f".{pack_id}.", dir=parent))
+    published = False
+    try:
+        arrays_path = staging / "lidar-pack.npz"
+        np.savez_compressed(
+            arrays_path,
+            frame_indices=np.arange(count, dtype=np.int64),
+            source_frame_indices=np.asarray(
+                [row["source_frame_index"] for row in timeline], dtype=np.int64
+            ),
+            session_seconds=np.asarray(
+                [anchor.video_session_seconds for anchor in anchors], dtype=np.float64
+            ),
+            host_session_seconds=np.asarray(
+                [anchor.host_session_seconds for anchor in anchors], dtype=np.float64
+            ),
+            lidar_session_seconds=np.asarray(sample_seconds, dtype=np.float64),
+            sample_available=available,
+            cloud_offsets=np.asarray(offsets, dtype=np.int64),
+            cloud_points_map=(
+                np.concatenate(clouds) if clouds else np.empty((0, 3), dtype=np.float32)
+            ),
+            pose_positions_map=positions,
+            pose_quaternions_map_from_lidar=quaternions,
+            lidar_camera_delta_ms=lidar_delta,
+            pose_point_delta_ms=pose_delta,
+            causal_history_seconds=np.asarray(
+                [CAUSAL_HISTORY_SECONDS], dtype=np.float64
+            ),
+            causal_history_offsets=np.asarray(history_offsets, dtype=np.int64),
+            causal_history_points_map=np.concatenate(history_clouds),
+            intrinsic_fx_fy_cx_cy=np.asarray(
+                projection.intrinsic_fx_fy_cx_cy, dtype=np.float64
+            ),
+            distortion_kb4=np.asarray(projection.distortion_kb4, dtype=np.float64),
+            t_camera_from_lidar=np.asarray(projection.t_camera_from_lidar, dtype=np.float64),
+        )
+        manifest = {
+            "schema_version": SCHEMA,
+            "pack_id": pack_id,
+            "identity_sha256": identity_sha256,
+            "identity": identity,
+            "created_at_utc": datetime.now(UTC)
+            .isoformat(timespec="milliseconds")
+            .replace("+00:00", "Z"),
+            "classification": "private-recorded-sensor-review-input",
+            "ground_truth": False,
+            "artifact": {
+                "path": arrays_path.name,
+                "media_type": "application/x-npz",
+                "byte_length": arrays_path.stat().st_size,
+                "sha256": _sha256(arrays_path),
+            },
+        }
+        (staging / "manifest.json").write_text(
+            json.dumps(manifest, ensure_ascii=False, sort_keys=True, indent=2) + "\n",
+            encoding="utf-8",
+        )
+        os.replace(staging, final)
+        published = True
+    finally:
+        if not published:
+            shutil.rmtree(staging, ignore_errors=True)
+    return final
+
+
+def main() -> int:
+    args = _arguments()
+    output = prepare(
+        job_root=args.job,
+        session_root=args.session,
+        review_pack_root=args.review_pack,
+        calibration_root=args.calibration,
+        output_root=args.output_root,
+    )
+    manifest = json.loads((output / "manifest.json").read_text(encoding="utf-8"))
+    print(
+        json.dumps(
+            {
+                "pack_id": manifest["pack_id"],
+                "output": str(output),
+                "frames": manifest["identity"]["frame_count"],
+                "lidar_frames": manifest["identity"]["available_lidar_frames"],
+                "points": manifest["identity"]["point_count"],
+                "artifact_sha256": manifest["artifact"]["sha256"],
+            },
+            sort_keys=True,
+        )
+    )
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

experiments/perception/worker/Invoke-E4FullSessionSegmentation.ps1

@@ -187,12 +187,15 @@ Write-Output "PHASE=e4-preflight-complete"
 $runToken = [Guid]::NewGuid().ToString("N")
 $workRoot = Join-Path $tmpRoot ("{0}-e4-{1}" -f $job.job_id, $runToken)
 $framesRoot = Join-Path $workRoot "frames"
+$decodedFramesRoot = Join-Path $workRoot "decoded-by-pts"
 $streamPath = Join-Path $workRoot "camera.mp4"
-$ptsPath = Join-Path $workRoot "pts.json"
+$packetsPath = Join-Path $workRoot "packets.csv"
+$decodeRepairPath = Join-Path $workRoot "decode-repair.json"
 $timelinePath = Join-Path $workRoot "timeline.jsonl"
 $publishRoot = Join-Path $derivedRoot (".{0}-e4-{1}.publish" -f $job.job_id, $runToken)
 $stagingRoot = Join-Path $publishRoot "output"
 $null = New-Item -ItemType Directory -Path $framesRoot
+$null = New-Item -ItemType Directory -Path $decodedFramesRoot
 $null = New-Item -ItemType Directory -Path $publishRoot
 $totalWatch = [Diagnostics.Stopwatch]::StartNew()
 $completed = $false
@@ -230,29 +233,69 @@ try {
 
     $extractWatch = [Diagnostics.Stopwatch]::StartNew()
     Write-Output "PHASE=e4-frame-extraction-start"
-    & ffmpeg -hide_banner -loglevel fatal -i $streamPath -map 0:v:0 -fps_mode passthrough -frames:v $activeFrameCount (Join-Path $framesRoot "frame-%06d.png")
+    & ffprobe -v error -select_streams v:0 -show_packets -show_entries packet=pts,flags -of csv=p=0 -o $packetsPath $streamPath
+    Assert-LastExitCode "LAB E4 packet timestamp probe"
+    $packetRows = @(Get-Content -LiteralPath $packetsPath | Select-Object -First $activeFrameCount)
+    if ($packetRows.Count -ne $activeFrameCount) {
+        throw "LAB E4 packet count differs from the requested camera epoch"
+    }
+
+    & ffmpeg -hide_banner -loglevel error `
+        -hwaccel cuda -hwaccel_output_format cuda -c:v h264_cuvid `
+        -err_detect ignore_err -flags +output_corrupt -copyts `
+        -i $streamPath -map 0:v:0 -vf "hwdownload,format=nv12" `
+        -fps_mode passthrough -enc_time_base demux -frames:v $activeFrameCount `
+        -frame_pts 1 (Join-Path $decodedFramesRoot "frame-%d.png")
     Assert-LastExitCode "LAB E4 camera extraction"
-    & ffprobe -v error -select_streams v:0 -show_entries frame=best_effort_timestamp_time -of json $streamPath | Set-Content -LiteralPath $ptsPath -Encoding utf8
-    Assert-LastExitCode "LAB E4 camera timestamp probe"
+
+    $decodedCount = @(Get-ChildItem -LiteralPath $decodedFramesRoot -File -Filter "frame-*.png").Count
+    $repairs = @()
+    $packetPts = @()
+    for ($index = 0; $index -lt $activeFrameCount; $index++) {
+        $columns = ([string]$packetRows[$index]).Split(",")
+        if ($columns.Count -lt 2) {
+            throw "LAB E4 packet timestamp row is malformed"
+        }
+        $pts = [int64]::Parse($columns[0].Trim(), [Globalization.CultureInfo]::InvariantCulture)
+        $packetPts += $pts
+        $decodedPath = Join-Path $decodedFramesRoot ("frame-{0}.png" -f $pts)
+        $canonicalPath = Join-Path $framesRoot ("frame-{0:D6}.png" -f ($index + 1))
+        if (Test-Path -LiteralPath $decodedPath -PathType Leaf) {
+            Move-Item -LiteralPath $decodedPath -Destination $canonicalPath
+            continue
+        }
+        if ($index -eq 0 -or $repairs.Count -ge 1) {
+            throw "LAB E4 source contains more than one recoverable decoder gap"
+        }
+        $previousPath = Join-Path $framesRoot ("frame-{0:D6}.png" -f $index)
+        Copy-Item -LiteralPath $previousPath -Destination $canonicalPath
+        $repairs += [ordered]@{
+            sequence = $index + 1
+            packet_pts = $pts
+            method = "duplicate-previous-decoded-frame"
+        }
+    }
 
     $decodedFrames = @(Get-ChildItem -LiteralPath $framesRoot -File -Filter "frame-*.png")
-    $ptsDocument = Get-Content -LiteralPath $ptsPath -Raw | ConvertFrom-Json
-    $pts = @($ptsDocument.frames)
-    if ($decodedFrames.Count -ne $activeFrameCount -or $pts.Count -lt $activeFrameCount) {
+    if ($decodedFrames.Count -ne $activeFrameCount) {
         throw "Decoded LAB E4 frame count differs from the requested camera epoch"
     }
-    $firstEpochSeconds = [double]::Parse(
-        ([string]$pts[0].best_effort_timestamp_time).Trim(),
-        [Globalization.CultureInfo]::InvariantCulture
-    )
+    $decodeRepair = [ordered]@{
+        schema_version = "missioncore.recorded-video-decode-repair/v1"
+        decoder = "ffmpeg-h264_cuvid-output-corrupt"
+        packets_requested = $activeFrameCount
+        frames_decoded = $decodedCount
+        repaired_frame_count = $repairs.Count
+        repairs = $repairs
+    }
+    $decodeRepair | ConvertTo-Json -Depth 8 | Set-Content -LiteralPath $decodeRepairPath -Encoding utf8
+
+    $firstPacketPts = [int64]$packetPts[0]
     $previousEpochSeconds = -1.0
     $timelineWriter = [IO.StreamWriter]::new($timelinePath, $false, [Text.UTF8Encoding]::new($false))
     try {
         for ($index = 0; $index -lt $activeFrameCount; $index++) {
-            $epochSeconds = [double]::Parse(
-                ([string]$pts[$index].best_effort_timestamp_time).Trim(),
-                [Globalization.CultureInfo]::InvariantCulture
-            ) - $firstEpochSeconds
+            $epochSeconds = ([int64]$packetPts[$index] - $firstPacketPts) / 90000.0
             if ($epochSeconds -le $previousEpochSeconds -or $epochSeconds -gt ($timelineDuration + 0.001)) {
                 throw "Decoded LAB E4 timestamps are not strictly monotonic inside the camera timeline"
             }
@@ -313,6 +356,7 @@ try {
     Write-Output ("PHASE=e4-inference-start FRAMES={0}" -f $activeFrameCount)
     & docker @runArgs
     Assert-LastExitCode "LAB E4 semantic inference"
+    Copy-Item -LiteralPath $decodeRepairPath -Destination (Join-Path $stagingRoot "decode-repair.json")
     $freeBytesPostInference = Assert-FreeSpace "post-inference"
     Write-Output "PHASE=e4-inference-complete"
 

experiments/perception/worker/Invoke-LabV1VegetationGooseBenchmark.ps1

@@ -12,7 +12,18 @@ param(
 
     [string]$OutputRoot = "D:\NDC_MISSIONCORE\runtime\experiments\lab-v1-vegetation",
 
-    [string]$RavnovesVideo = "D:\NDC_MISSIONCORE\runtime\experiments\e46e\inputs\right-cadd1696ff000904eb78633a0a8418104b8024f178b91f3421789021ccb160e8.mp4"
+    [string]$RavnovesVideo = "D:\NDC_MISSIONCORE\runtime\experiments\e46e\inputs\right-cadd1696ff000904eb78633a0a8418104b8024f178b91f3421789021ccb160e8.mp4",
+
+    [string]$RavnovesSourceId = "RAVNOVES00/right-cadd1696ff000904eb78633a0a8418104b8024f178b91f3421789021ccb160e8",
+
+    [string]$RavnovesSha256 = "cadd1696ff000904eb78633a0a8418104b8024f178b91f3421789021ccb160e8",
+
+    [ValidateRange(1, 1000000)]
+    [int]$RavnovesExpectedFrameCount = 4489,
+
+    [string]$RavnovesBaseM4ResultId = "m4-threat-replay-2a953c5f27f2a5b1dddc5c658c1de2c323d7796084a099c024987a1da03aa324",
+
+    [string]$RavnovesSourceProfile = ""
 )
 
 Set-StrictMode -Version Latest
@@ -38,6 +49,31 @@ $configRoot = Join-Path $ToolRoot "config"
 $benchmarkConfig = Join-Path $configRoot "lab-v1-goose-vegetation-benchmark-v1.json"
 $policyConfig = Join-Path $configRoot "lab-v1-vegetation-mission-policy-v1.json"
 $providerMapConfig = Join-Path $configRoot "lab-v1-vegetation-provider-label-map-v1.json"
+$ravnovesProfileDocument = $null
+if (-not [string]::IsNullOrWhiteSpace($RavnovesSourceProfile)) {
+    $resolvedProfile = (Resolve-Path -LiteralPath $RavnovesSourceProfile).Path
+    if (-not $resolvedProfile.StartsWith($ToolRoot, [StringComparison]::OrdinalIgnoreCase)) {
+        throw "RAVNOVES source profile must stay under ToolRoot"
+    }
+    $ravnovesProfileDocument = Get-Content -LiteralPath $resolvedProfile -Raw | ConvertFrom-Json
+    $source = $ravnovesProfileDocument.source
+    if (
+        $ravnovesProfileDocument.schema_version -ne "missioncore.lab-v1-ravnoves-source/v1" -or
+        $null -eq $source -or
+        [string]::IsNullOrWhiteSpace([string]$source.source_id) -or
+        [string]$source.source_sha256 -notmatch "^[a-f0-9]{64}$" -or
+        [int]$source.expected_width -ne 800 -or
+        [int]$source.expected_height -ne 600 -or
+        [int]$source.expected_frame_count -lt 1 -or
+        [string]$source.crop_contract -ne "center-600-square-to-512; outside-crop-is-undefined"
+    ) {
+        throw "RAVNOVES source profile is incompatible"
+    }
+    $RavnovesSourceId = [string]$source.source_id
+    $RavnovesSha256 = [string]$source.source_sha256
+    $RavnovesExpectedFrameCount = [int]$source.expected_frame_count
+    $RavnovesBaseM4ResultId = [string]$source.base_m4_result_id
+}
 $datasetRoot = Join-Path $AssetRoot "goose-2d\validation"
 $checkpointRelative = if ($candidateKey -eq "ddrnet") {
     "models\goose\ddrnet_class_512.pth"
@@ -51,7 +87,6 @@ $expectedCheckpointSha256 = if ($candidateKey -eq "ddrnet") {
     "6dd412c0c99115e359896c4cab43a8e6bce9e09b843e7fa885fe597b0a6121cd"
 }
 $expectedCheckpointBytes = if ($candidateKey -eq "ddrnet") { 259419077 } else { 98208249 }
-$ravnovesSha256 = "cadd1696ff000904eb78633a0a8418104b8024f178b91f3421789021ccb160e8"
 $frameIndices = @(0, 253, 512, 768, 1024, 1536, 2048, 2560, 3072, 3584, 4096, 4488)
 $dockerConfig = "D:\NDC_MISSIONCORE\datasets\state\lab-v1-vegetation\docker-config"
 
@@ -110,6 +145,18 @@ function Invoke-IsolatedRun {
         [string]$FramesRoot = ""
     )
     $containerName = "ndc-lab-v1-goose-$candidateKey-$([Guid]::NewGuid().ToString('N').Substring(0, 10))"
+    $activeConfigRoot = $configRoot
+    if ($RunMode -eq "ravnoves-video" -and $null -ne $ravnovesProfileDocument) {
+        $activeConfigRoot = Join-Path $RunRoot "effective-config"
+        New-Item -ItemType Directory -Path $activeConfigRoot | Out-Null
+        Copy-Item -LiteralPath $policyConfig -Destination $activeConfigRoot
+        Copy-Item -LiteralPath $providerMapConfig -Destination $activeConfigRoot
+        $benchmark = Get-Content -LiteralPath $benchmarkConfig -Raw | ConvertFrom-Json
+        $benchmark.ravnoves = $ravnovesProfileDocument.source
+        $benchmark | ConvertTo-Json -Depth 32 | Set-Content -LiteralPath (
+            Join-Path $activeConfigRoot "lab-v1-goose-vegetation-benchmark-v1.json"
+        ) -Encoding utf8
+    }
     $visualCount = if ($RunMode -eq "ravnoves-video") { 0 } else { 12 }
     $arguments = @(
         "run", "--rm", "--name", $containerName,
@@ -125,7 +172,7 @@ function Invoke-IsolatedRun {
         "--env", "HOME=/tmp",
         "--mount", "type=bind,src=$datasetRoot,dst=/data/goose,readonly",
         "--mount", "type=bind,src=$checkpoint,dst=/models/candidate.pth,readonly",
-        "--mount", "type=bind,src=$configRoot,dst=/config,readonly",
+        "--mount", "type=bind,src=$activeConfigRoot,dst=/config,readonly",
         "--mount", "type=bind,src=$RunRoot,dst=/output",
         $image,
         "--mode", $RunMode,
@@ -147,15 +194,27 @@ function Invoke-IsolatedRun {
         $tail = @($arguments[$mountIndex..($arguments.Count - 1)])
         $arguments = $head + @("--mount", "type=bind,src=$FramesRoot,dst=/input,readonly") + $tail
     }
-    & docker @arguments
-    if ($LASTEXITCODE -ne 0) {
-        throw "LAB V1 container failed with exit code $LASTEXITCODE"
+    $dockerExitCode = -1
+    $previousErrorActionPreference = $ErrorActionPreference
+    try {
+        # Windows PowerShell exposes native stderr as ErrorRecord objects. Model
+        # libraries legitimately emit warnings there, so merge the stream and
+        # fail only on the native process exit code.
+        $ErrorActionPreference = "Continue"
+        & docker @arguments 2>&1 | ForEach-Object { Write-Output $_ }
+        $dockerExitCode = $LASTEXITCODE
+    }
+    finally {
+        $ErrorActionPreference = $previousErrorActionPreference
+    }
+    if ($dockerExitCode -ne 0) {
+        throw "LAB V1 container failed with exit code $dockerExitCode"
     }
 }
 
 function Export-RavnovesFrames {
     param([string]$Destination)
-    Assert-FileIdentity -Path $RavnovesVideo -ExpectedBytes (Get-Item -LiteralPath $RavnovesVideo).Length -ExpectedSha256 $ravnovesSha256
+    Assert-FileIdentity -Path $RavnovesVideo -ExpectedBytes (Get-Item -LiteralPath $RavnovesVideo).Length -ExpectedSha256 $RavnovesSha256
     New-Item -ItemType Directory -Path $Destination | Out-Null
     $expression = ($frameIndices | ForEach-Object { "eq(n\,$_ )" }) -join "+"
     $temporaryPattern = Join-Path $Destination "selected-%03d.png"
@@ -175,14 +234,68 @@ function Export-RavnovesFrames {
 
 function Export-RavnovesVideoFrames {
     param([string]$Destination)
-    Assert-FileIdentity -Path $RavnovesVideo -ExpectedBytes (Get-Item -LiteralPath $RavnovesVideo).Length -ExpectedSha256 $ravnovesSha256
+    Assert-FileIdentity -Path $RavnovesVideo -ExpectedBytes (Get-Item -LiteralPath $RavnovesVideo).Length -ExpectedSha256 $RavnovesSha256
     New-Item -ItemType Directory -Path $Destination | Out-Null
-    & ffmpeg -hide_banner -loglevel error -i $RavnovesVideo -map 0:v:0 -fps_mode passthrough (Join-Path $Destination "frame-%06d.png")
+    $decodedRoot = "{0}-decoded-by-pts" -f $Destination
+    $packetsPath = "{0}-packets.csv" -f $Destination
+    New-Item -ItemType Directory -Path $decodedRoot | Out-Null
+    & ffprobe -v error -select_streams v:0 -show_packets -show_entries packet=pts,flags -of csv=p=0 -o $packetsPath $RavnovesVideo
+    if ($LASTEXITCODE -ne 0) {
+        throw "RAVNOVES full-video packet probe failed"
+    }
+    $packetRows = @(Get-Content -LiteralPath $packetsPath | Select-Object -First $RavnovesExpectedFrameCount)
+    if ($packetRows.Count -ne $RavnovesExpectedFrameCount) {
+        throw "RAVNOVES full-video packet sequence changed"
+    }
+    & ffmpeg -hide_banner -loglevel error `
+        -hwaccel cuda -hwaccel_output_format cuda -c:v h264_cuvid `
+        -err_detect ignore_err -flags +output_corrupt -copyts `
+        -i $RavnovesVideo -map 0:v:0 -vf "hwdownload,format=nv12" `
+        -fps_mode passthrough -enc_time_base demux -frames:v $RavnovesExpectedFrameCount `
+        -frame_pts 1 (Join-Path $decodedRoot "frame-%d.png")
     if ($LASTEXITCODE -ne 0) {
         throw "RAVNOVES full-video frame extraction failed"
     }
+    $decodedCount = @(Get-ChildItem -LiteralPath $decodedRoot -File -Filter "frame-*.png").Count
+    $repairs = @()
+    for ($index = 0; $index -lt $RavnovesExpectedFrameCount; $index++) {
+        $columns = ([string]$packetRows[$index]).Split(",")
+        if ($columns.Count -lt 2) {
+            throw "RAVNOVES full-video packet row is malformed"
+        }
+        $pts = [int64]::Parse($columns[0].Trim(), [Globalization.CultureInfo]::InvariantCulture)
+        $decodedPath = Join-Path $decodedRoot ("frame-{0}.png" -f $pts)
+        $canonicalPath = Join-Path $Destination ("frame-{0:D6}.png" -f ($index + 1))
+        if (Test-Path -LiteralPath $decodedPath -PathType Leaf) {
+            Move-Item -LiteralPath $decodedPath -Destination $canonicalPath
+            continue
+        }
+        if ($index -eq 0 -or $repairs.Count -ge 1) {
+            throw "RAVNOVES source contains more than one recoverable decoder gap"
+        }
+        $previousPath = Join-Path $Destination ("frame-{0:D6}.png" -f $index)
+        Copy-Item -LiteralPath $previousPath -Destination $canonicalPath
+        $repairs += [ordered]@{
+            sequence = $index + 1
+            packet_pts = $pts
+            method = "duplicate-previous-decoded-frame"
+        }
+    }
+    Remove-Item -LiteralPath $decodedRoot -Recurse -Force
+    Remove-Item -LiteralPath $packetsPath -Force
+    [ordered]@{
+        schema_version = "missioncore.recorded-video-decode-repair/v1"
+        decoder = "ffmpeg-h264_cuvid-output-corrupt"
+        packets_requested = $RavnovesExpectedFrameCount
+        frames_decoded = $decodedCount
+        repaired_frame_count = $repairs.Count
+        repairs = $repairs
+    } | ConvertTo-Json -Depth 8 | Set-Content -LiteralPath (
+        Join-Path (Split-Path $Destination -Parent) "decode-repair.json"
+    ) -Encoding utf8
     $frames = @(Get-ChildItem -LiteralPath $Destination -File -Filter "frame-*.png" | Sort-Object Name)
-    if ($frames.Count -ne 4489 -or $frames[0].Name -ne "frame-000001.png" -or $frames[-1].Name -ne "frame-004489.png") {
+    $lastFrameName = "frame-{0:D6}.png" -f $RavnovesExpectedFrameCount
+    if ($frames.Count -ne $RavnovesExpectedFrameCount -or $frames[0].Name -ne "frame-000001.png" -or $frames[-1].Name -ne $lastFrameName) {
         throw "RAVNOVES full-video frame sequence changed"
     }
 }
@@ -244,6 +357,9 @@ try {
         $framesRoot = Join-Path $runRoot "input-frames"
         Export-RavnovesVideoFrames -Destination $framesRoot
         Invoke-IsolatedRun -RunMode "ravnoves-video" -RunRoot $runRoot -Limit 0 -FramesRoot $framesRoot
+        Copy-Item -LiteralPath (Join-Path $runRoot "decode-repair.json") -Destination (
+            Join-Path $runRoot "result\decode-repair.json"
+        )
         Remove-Item -LiteralPath $framesRoot -Recurse -Force
     }
 }

experiments/perception/worker/Invoke-M49TgsIntegratedGraphShadow.ps1

@@ -12,6 +12,10 @@ param(
     [string]$RunId,
     [ValidateRange(1.0, 120.0)]
     [double]$SourceRateHz = 12.0,
+    [switch]$VegetationLoadGate,
+    [string]$VegetationAssetRoot = (
+        "D:\NDC_MISSIONCORE\datasets\vegetation-v1\observed-2026-08-27"
+    ),
     [string]$OutputRoot = (
         "D:\NDC_MISSIONCORE\runtime\results\m49-tgs-integrated-graph-shadow"
     )
@@ -23,6 +27,8 @@ $TravelImageTag = "ndc/mission-core-m49-t3-travel:20260826"
 $TravelImageId = "sha256:7b412020f4d8392d1d1ed1b33beadc44140f0ea8f781e62dd69796042334300f"
 $ParityImageTag = "ndc-mission-core-m48t-upstream-parity:1.9.4-cu130"
 $ParityImageId = "sha256:ceb13548617e4bd3f619766bfdff00af3fa5160946b367828da6d2233dcdcba0"
+$VegetationImageTag = "ndc/mission-core-lab-v1-goose:sg3.2.0-cu117-v1"
+$VegetationImageId = "sha256:591cb382c099eeb05e7ec16e2371e0b2da54d2bb5c49ec0f4ac88dbf72b0f0cd"
 $RuntimeImage = (
     "nvcr.io/nvidia/tritonserver:26.06-py3@" +
     "sha256:58df7489c3f2276f9591d500a012dee03e23d35543ce3c390b4c001e6bf90794"
@@ -98,12 +104,20 @@ function Wait-Healthy([string]$Name) {
 function Wait-SharedReady(
     [string]$GraphReady,
     [string]$TgsReady,
+    [string]$VegetationReady,
     [string]$GraphName,
-    [string]$TgsName
+    [string]$TgsName,
+    [string]$VegetationName
 ) {
     $deadline = [DateTimeOffset]::UtcNow.AddMinutes(10)
-    while (-not ((Test-Path -LiteralPath $GraphReady) -and (Test-Path -LiteralPath $TgsReady))) {
-        foreach ($name in @($GraphName, $TgsName)) {
+    $requiredFiles = @($GraphReady, $TgsReady)
+    $requiredContainers = @($GraphName, $TgsName)
+    if (-not [string]::IsNullOrWhiteSpace($VegetationReady)) {
+        $requiredFiles += $VegetationReady
+        $requiredContainers += $VegetationName
+    }
+    while ($requiredFiles.Where({ -not (Test-Path -LiteralPath $_) }).Count -gt 0) {
+        foreach ($name in $requiredContainers) {
             $container = Get-Container $name
             if (-not $container.State.Running) {
                 & docker logs $name
@@ -128,15 +142,25 @@ $runCandidate = Join-Path $output $RunId
 if (Test-Path -LiteralPath $runCandidate) { throw "M49 integrated output already exists" }
 $null = New-Item -ItemType Directory -Path $runCandidate
 $runOutput = Resolve-DDirectory $runCandidate "M49 integrated run output" $false
-foreach ($directory in @("bin", "control", "graph", "tgs")) {
+foreach ($directory in @("bin", "control", "graph", "tgs", "vegetation")) {
     $null = New-Item -ItemType Directory -Path (Join-Path $runOutput $directory)
 }
 
 $releaseDocument = Get-Content -LiteralPath (Join-Path $payload "release.json") -Raw | ConvertFrom-Json
+$expectedReleaseSchema = if ($VegetationLoadGate) {
+    "missioncore.lab-v1-vegetation-integrated-worker-release/v3"
+} else {
+    "missioncore.m49-tgs-integrated-graph-worker-release/v1"
+}
+$expectedTransition = if ($VegetationLoadGate) {
+    "lab-v1-vegetation-m49-integrated-multirate-phased-shadow/v3"
+} else {
+    "m49-tgs-native-risk-integrated-shadow/v1"
+}
 if (
-    $releaseDocument.schema_version -cne "missioncore.m49-tgs-integrated-graph-worker-release/v1" -or
+    $releaseDocument.schema_version -cne $expectedReleaseSchema -or
     $releaseDocument.worker_id -cne "worker-006" -or
-    $releaseDocument.transition -cne "m49-tgs-native-risk-integrated-shadow/v1"
+    $releaseDocument.transition -cne $expectedTransition
 ) { throw "M49 integrated release contract changed" }
 foreach ($property in $releaseDocument.files.PSObject.Properties) {
     $path = Join-Path $payload $property.Name
@@ -146,6 +170,9 @@ foreach ($property in $releaseDocument.files.PSObject.Properties) {
 }
 $wheelSha256 = [string]$releaseDocument.files."nodedc_mission_core-0.1.0-py3-none-any.whl".sha256
 $runnerSha256 = [string]$releaseDocument.files."run_m48s_reference_graph_shadow_worker.py".sha256
+$vegetationRunnerSha256 = if ($VegetationLoadGate) {
+    [string]$releaseDocument.files."run_vegetation_integrated_load.py".sha256
+} else { "" }
 
 $source = [ordered]@{
     CameraIndex = (
@@ -178,6 +205,27 @@ foreach ($entry in $source.GetEnumerator()) {
 if ((Get-Sha256 $source.SourcePack) -cne [string]$releaseDocument.source_pack_sha256) {
     throw "RAVNOVES00 source pack digest changed"
 }
+$videoSha256 = [string]$releaseDocument.video_sha256
+if ((Get-Sha256 $source.Video) -cne $videoSha256) {
+    throw "RAVNOVES00 video digest changed"
+}
+
+$vegetation = $null
+if ($VegetationLoadGate) {
+    $vegetationRoot = Resolve-DDirectory $VegetationAssetRoot "vegetation asset root" $false
+    $vegetation = [ordered]@{
+        Dataset = Resolve-DDirectory (
+            (Join-Path $vegetationRoot "goose-2d\validation")
+        ) "GOOSE validation root" $false
+        Checkpoint = Resolve-DFile (
+            (Join-Path $vegetationRoot "models\goose\ddrnet_class_512.pth")
+        ) "DDRNet checkpoint"
+    }
+    if (
+        (Get-Sha256 $vegetation.Checkpoint) -cne
+        "b99c2838051bcd7b092fd3970aa62a77d5c0bbb809c9b9afb2ff4b0ebdaa4ee6"
+    ) { throw "DDRNet checkpoint SHA-256 changed" }
+}
 
 $nativeConfig = Resolve-DFile (
     (Join-Path $payload "rf_detr_large_native_kb4_config.pbtxt")
@@ -207,12 +255,17 @@ $pillow = Resolve-DDirectory (
 
 Assert-Image $TravelImageTag $TravelImageId
 Assert-Image $ParityImageTag $ParityImageId
+if ($VegetationLoadGate) { Assert-Image $VegetationImageTag $VegetationImageId }
 & docker image inspect $RuntimeImage *> $null
 Assert-LastExitCode "pinned runtime image inspection"
 $os = Get-CimInstance Win32_OperatingSystem
 $freeMemoryGiB = [double]$os.FreePhysicalMemory / 1MB
-if ($freeMemoryGiB -lt 24.0) {
-    throw ("M49 integrated shadow requires 24 GiB free memory; observed {0:N2} GiB" -f $freeMemoryGiB)
+$requiredMemoryGiB = if ($VegetationLoadGate) { 32.0 } else { 24.0 }
+if ($freeMemoryGiB -lt $requiredMemoryGiB) {
+    throw (
+        "M49 integrated shadow requires {0:N0} GiB free memory; observed {1:N2} GiB" -f
+        $requiredMemoryGiB, $freeMemoryGiB
+    )
 }
 $canonicalBefore = Get-Container "ndc-mission-core-triton"
 if (-not $canonicalBefore.State.Running -or $canonicalBefore.State.Health.Status -cne "healthy") {
@@ -225,9 +278,12 @@ $compileName = "ndc-mission-core-m49-integrated-compile-$RunId"
 $tritonName = "ndc-mission-core-m49-integrated-triton-$RunId"
 $graphName = "ndc-mission-core-m49-integrated-graph-$RunId"
 $tgsName = "ndc-mission-core-m49-integrated-tgs-$RunId"
+$vegetationName = "ndc-mission-core-m49-integrated-vegetation-$RunId"
 $analyzeName = "ndc-mission-core-m49-integrated-analyze-$RunId"
 $evidenceName = "ndc-mission-core-m49-integrated-evidence-$RunId"
+$vegetationEvidenceName = "ndc-mission-core-m49-integrated-vegetation-evidence-$RunId"
 $containers = @($prepareName, $compileName, $tritonName, $graphName, $tgsName, $analyzeName, $evidenceName)
+if ($VegetationLoadGate) { $containers += @($vegetationName, $vegetationEvidenceName) }
 foreach ($name in $containers) {
     if (& docker ps -a --format "{{.Names}}" --filter "name=^/$name$") {
         throw "M49 integrated container name already exists: $name"
@@ -324,7 +380,7 @@ try {
 
     & docker create --name $tgsName --network none --cpus 16 --memory 24g `
         --read-only --security-opt "no-new-privileges:true" --cap-drop ALL `
-        --pids-limit 256 --tmpfs "/tmp:rw,noexec,nosuid,size=1g" `
+        --pids-limit 256 --tmpfs "/tmp:rw,noexec,nosuid,size=2g" `
         -e ("M49_SOURCE_RATE_HZ={0}" -f $rate) `
         --entrypoint /bin/bash `
         --volume ($dockerRelease + ":/release:ro") `
@@ -332,24 +388,78 @@ try {
         $TravelImageTag /release/run_tgs_integrated_shadow.sh *> $null
     Assert-LastExitCode "M49 integrated TGS creation"
 
+    if ($VegetationLoadGate) {
+        $dockerVegetationDataset = Convert-ToDockerPath $vegetation.Dataset
+        $dockerVegetationCheckpoint = Convert-ToDockerPath $vegetation.Checkpoint
+        & docker create --name $vegetationName --network none --cpus 8 --memory 10g `
+            --gpus all --read-only --security-opt "no-new-privileges:true" --cap-drop ALL `
+            --pids-limit 512 --tmpfs "/tmp:rw,noexec,nosuid,size=2g" `
+            -e "HOME=/tmp" `
+            --entrypoint conda `
+            --volume ($dockerRelease + ":/release:ro") `
+            --volume ($dockerRun + ":/shared:rw") `
+            --volume ($dockerVegetationDataset + ":/data/goose:ro") `
+            --volume ($dockerVegetationCheckpoint + ":/models/candidate.pth:ro") `
+            --volume ((Convert-ToDockerPath $source.Video) + ":/source/right.mp4:ro") `
+            $VegetationImageTag run --no-capture-output --name goose python `
+            /release/run_vegetation_integrated_load.py `
+            --config /release/lab-v1-goose-vegetation-benchmark-v1.json `
+            --policy /release/lab-v1-vegetation-mission-policy-v1.json `
+            --provider-map /release/lab-v1-vegetation-provider-label-map-v1.json `
+            --checkpoint /models/candidate.pth `
+            --dataset-root /data/goose `
+            --video /source/right.mp4 `
+            --video-sha256 $videoSha256 `
+            --runtime-video-cache /tmp/vegetation-right.mp4 `
+            --source-rate-hz $rate `
+            --inference-stride 2 `
+            --inference-phase-offset-ms 40.0 `
+            --minimum-effective-timeline-fps 11.209069 `
+            --minimum-effective-inference-fps 5.604534 `
+            --maximum-inference-completion-p95-ms 125.0 `
+            --maximum-evidence-source-age-ms 125.0 `
+            --shared-start-ready-file /shared/control/vegetation.ready `
+            --shared-start-file /shared/control/start.signal `
+            --frame-ledger /shared/vegetation/frames.jsonl `
+            --output /shared/vegetation/result.json `
+            --release-sha256 $ExpectedArtifactSha256 *> $null
+        Assert-LastExitCode "M49 integrated vegetation creation"
+    }
+
     & docker start $graphName *> $null
     Assert-LastExitCode "M49 integrated graph start"
     & docker start $tgsName *> $null
     Assert-LastExitCode "M49 integrated TGS start"
+    if ($VegetationLoadGate) {
+        & docker start $vegetationName *> $null
+        Assert-LastExitCode "M49 integrated vegetation start"
+    }
     $graphReady = Join-Path $runOutput "control\graph.ready"
     $tgsReady = Join-Path $runOutput "control\tgs.ready"
-    Wait-SharedReady $graphReady $tgsReady $graphName $tgsName
+    $vegetationReady = if ($VegetationLoadGate) {
+        Join-Path $runOutput "control\vegetation.ready"
+    } else { "" }
+    Wait-SharedReady $graphReady $tgsReady $vegetationReady $graphName $tgsName $vegetationName
     [DateTimeOffset]::UtcNow.ToString("o") | Set-Content -LiteralPath (
         Join-Path $runOutput "control\start.signal"
     ) -Encoding utf8
 
     $telemetryPath = Join-Path $runOutput "container-telemetry.jsonl"
+    $m49TelemetryPath = if ($VegetationLoadGate) {
+        Join-Path $runOutput "m49-container-telemetry.jsonl"
+    } else { $telemetryPath }
     while ($true) {
         $graphState = Get-Container $graphName
         $tgsState = Get-Container $tgsName
+        $vegetationState = if ($VegetationLoadGate) {
+            Get-Container $vegetationName
+        } else { $null }
         $running = @()
         if ($graphState.State.Running) { $running += $graphName }
         if ($tgsState.State.Running) { $running += $tgsName }
+        if ($VegetationLoadGate -and $vegetationState.State.Running) {
+            $running += $vegetationName
+        }
         if ((Get-Container $tritonName).State.Running) { $running += $tritonName }
         if ($running.Count -gt 0) {
             $stats = @((& docker stats --no-stream --format "{{json .}}" @running))
@@ -362,10 +472,12 @@ try {
                     "tgs"
                 } elseif ($value.Name -ceq $tritonName) {
                     "triton"
+                } elseif ($VegetationLoadGate -and $value.Name -ceq $vegetationName) {
+                    "vegetation"
                 } else {
                     throw "Unknown M49 telemetry container"
                 }
-                [ordered]@{
+                $telemetryRow = [ordered]@{
                     observed_utc = [DateTimeOffset]::UtcNow.ToString("o")
                     role = $role
                     name = [string]$value.Name
@@ -373,23 +485,46 @@ try {
                     memory_usage = [string]$value.MemUsage
                     memory_percent = [string]$value.MemPerc
                     pids = [string]$value.PIDs
-                } | ConvertTo-Json -Compress | Out-File -LiteralPath $telemetryPath -Encoding utf8 -Append
+                } | ConvertTo-Json -Compress
+                $telemetryRow | Out-File -LiteralPath $telemetryPath -Encoding utf8 -Append
+                if ($VegetationLoadGate -and $role -cne "vegetation") {
+                    $telemetryRow | Out-File -LiteralPath $m49TelemetryPath -Encoding utf8 -Append
+                }
             }
         }
-        if (-not $graphState.State.Running -and -not $tgsState.State.Running) { break }
+        $vegetationStopped = -not $VegetationLoadGate -or -not $vegetationState.State.Running
+        if (
+            -not $graphState.State.Running -and
+            -not $tgsState.State.Running -and
+            $vegetationStopped
+        ) { break }
         Start-Sleep -Seconds 1
     }
     $graphExit = [int](Get-Container $graphName).State.ExitCode
     $tgsExit = [int](Get-Container $tgsName).State.ExitCode
+    $vegetationExit = if ($VegetationLoadGate) {
+        [int](Get-Container $vegetationName).State.ExitCode
+    } else { 0 }
     $previousErrorAction = $ErrorActionPreference
     $ErrorActionPreference = "Continue"
     $graphLogs = & docker logs $graphName 2>&1
     $tgsLogs = & docker logs $tgsName 2>&1
+    $vegetationLogs = if ($VegetationLoadGate) {
+        & docker logs $vegetationName 2>&1
+    } else { @() }
     $ErrorActionPreference = $previousErrorAction
     $graphLogs | Set-Content -LiteralPath (Join-Path $runOutput "graph.log") -Encoding utf8
     $tgsLogs | Set-Content -LiteralPath (Join-Path $runOutput "tgs.log") -Encoding utf8
+    if ($VegetationLoadGate) {
+        $vegetationLogs | Set-Content -LiteralPath (
+            Join-Path $runOutput "vegetation.log"
+        ) -Encoding utf8
+    }
     if ($graphExit -ne 0) { throw "M49 integrated graph failed with exit code $graphExit" }
     if ($tgsExit -ne 0) { throw "M49 integrated TGS failed with exit code $tgsExit" }
+    if ($vegetationExit -ne 0) {
+        throw "M49 integrated vegetation failed with exit code $vegetationExit"
+    }
 
     & docker run --rm --name $analyzeName --network none --cpus 8 --memory 16g `
         --entrypoint python3 `
@@ -401,6 +536,12 @@ try {
         --output-root /shared/tgs/evidence
     Assert-LastExitCode "M49 integrated TGS evidence analysis"
 
+    $m49ResultPath = if ($VegetationLoadGate) {
+        "/shared/m49-result.json"
+    } else { "/shared/result.json" }
+    $dockerM49TelemetryPath = if ($VegetationLoadGate) {
+        "/shared/m49-container-telemetry.jsonl"
+    } else { "/shared/container-telemetry.jsonl" }
     & docker run --rm --name $evidenceName --network none --cpus 4 --memory 8g `
         --entrypoint python3 `
         --volume ($dockerRelease + ":/release:ro") `
@@ -411,10 +552,28 @@ try {
         --graph-frames /shared/graph/frames.jsonl `
         --tgs-result /shared/tgs/evidence/result.json `
         --tgs-timing /shared/tgs/tgs-full-timing.tsv `
-        --telemetry /shared/container-telemetry.jsonl `
-        --output /shared/result.json `
+        --telemetry $dockerM49TelemetryPath `
+        --output $m49ResultPath `
         --release-sha256 $ExpectedArtifactSha256
     Assert-LastExitCode "M49 integrated evidence gate"
+
+    if ($VegetationLoadGate) {
+        & docker run --rm --name $vegetationEvidenceName --network none --cpus 4 --memory 8g `
+            --entrypoint python3 `
+            --volume ($dockerRelease + ":/release:ro") `
+            --volume ($dockerRun + ":/shared:rw") `
+            $ParityImageTag /release/build_vegetation_integrated_graph_evidence.py `
+            --profile /release/lab-v1-vegetation-integrated-multirate-phased-shadow-v3.json `
+            --m49-result /shared/m49-result.json `
+            --graph-frames /shared/graph/frames.jsonl `
+            --tgs-timing /shared/tgs/tgs-full-timing.tsv `
+            --vegetation-result /shared/vegetation/result.json `
+            --vegetation-frames /shared/vegetation/frames.jsonl `
+            --telemetry /shared/container-telemetry.jsonl `
+            --output /shared/result.json `
+            --release-sha256 $ExpectedArtifactSha256
+        Assert-LastExitCode "M49 integrated vegetation evidence gate"
+    }
 } finally {
     foreach ($name in $containers) { Remove-ExactContainer $name }
     $canonicalAfter = Get-Container "ndc-mission-core-triton"
@@ -432,7 +591,11 @@ if (-not (Test-Path -LiteralPath $resultPath -PathType Leaf)) {
 }
 $result = Get-Content -LiteralPath $resultPath -Raw | ConvertFrom-Json
 $summary = [ordered]@{
-    schema_version = "missioncore.m49-tgs-integrated-graph-worker-summary/v1"
+    schema_version = if ($VegetationLoadGate) {
+        "missioncore.lab-v1-vegetation-integrated-worker-summary/v3"
+    } else {
+        "missioncore.m49-tgs-integrated-graph-worker-summary/v1"
+    }
     worker_id = "worker-006"
     run_id = $RunId
     code_revision = [string]$releaseDocument.code_revision
@@ -443,6 +606,7 @@ $summary = [ordered]@{
     free_memory_gib_before = [math]::Round($freeMemoryGiB, 6)
     result_id = [string]$result.result_id
     result_status = [string]$result.status
+    vegetation_load_gate = [bool]$VegetationLoadGate
     canonical_triton_id = $canonicalId
     canonical_triton_health = "healthy"
     gauss_or_playcanvas_action = "none"

experiments/perception/worker/lab_v1_vegetation_goose/run_mixed_route_ddrnet_islands.py

@@ -0,0 +1,340 @@
+#!/usr/bin/env python3
+"""Run DDRNet on an immutable mixed-route camera review pack."""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import math
+import platform
+import statistics
+import time
+from pathlib import Path, PurePosixPath
+from typing import Any
+
+import numpy as np
+import torch
+from PIL import Image
+from run_goose_vegetation_benchmark import (
+    CLASS_COUNT,
+    expand_mask,
+    infer,
+    load_mapping,
+    load_model,
+    percentile,
+    preprocess,
+    read_json,
+    save_image,
+    sha256,
+    stable_digest,
+    validate_contracts,
+)
+
+SCHEMA = "missioncore.mixed-route-ddrnet-islands/v1"
+PACK_SCHEMA = "missioncore.mixed-route-review-pack/v1"
+AUTHORITY = {
+    "ground_truth": False,
+    "candidate_accepted": False,
+    "navigation_or_safety_accepted": False,
+    "camera_semantics_can_clear_rigid_geometry": False,
+    "actuation_allowed": False,
+}
+
+
+class MixedRouteDdrnetError(RuntimeError):
+    """The route pack or DDRNet evidence changed or is incomplete."""
+
+
+def arguments() -> argparse.Namespace:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--pack", type=Path, required=True)
+    parser.add_argument("--config", type=Path, required=True)
+    parser.add_argument("--policy", type=Path, required=True)
+    parser.add_argument("--provider-map", type=Path, required=True)
+    parser.add_argument("--checkpoint", type=Path, required=True)
+    parser.add_argument("--dataset-root", type=Path, required=True)
+    parser.add_argument("--output", type=Path, required=True)
+    return parser.parse_args()
+
+
+def canonical_json(value: object) -> bytes:
+    return json.dumps(
+        value,
+        ensure_ascii=False,
+        sort_keys=True,
+        separators=(",", ":"),
+        allow_nan=False,
+    ).encode("utf-8")
+
+
+def object_value(value: object, label: str) -> dict[str, Any]:
+    if not isinstance(value, dict) or not all(isinstance(key, str) for key in value):
+        raise MixedRouteDdrnetError(f"{label} must be an object")
+    return value
+
+
+def load_pack(root: Path) -> tuple[dict[str, Any], list[dict[str, Any]]]:
+    pack = root.resolve(strict=True)
+    if not pack.is_dir() or pack.is_symlink():
+        raise MixedRouteDdrnetError("mixed-route review pack is unavailable")
+    manifest_path = pack / "manifest.json"
+    manifest = object_value(
+        json.loads(manifest_path.read_text(encoding="utf-8")),
+        "mixed-route manifest",
+    )
+    identity = object_value(manifest.get("identity"), "mixed-route identity")
+    identity_sha256 = manifest.get("identity_sha256")
+    frames = manifest.get("frames")
+    frame_count = manifest.get("frame_count")
+    if (
+        manifest.get("schema_version") != PACK_SCHEMA
+        or identity.get("schema_version") != PACK_SCHEMA
+        or not isinstance(identity_sha256, str)
+        or hashlib.sha256(canonical_json(identity)).hexdigest() != identity_sha256
+        or manifest.get("pack_id") != f"mixed-route-review-pack-{identity_sha256}"
+        or identity.get("ground_truth") is not False
+        or object_value(identity.get("authority"), "mixed-route authority").get(
+            "navigation_or_safety_accepted"
+        )
+        is not False
+        or not isinstance(frame_count, int)
+        or isinstance(frame_count, bool)
+        or not 1 <= frame_count <= 64
+        or not isinstance(frames, list)
+        or len(frames) != frame_count
+    ):
+        raise MixedRouteDdrnetError("mixed-route review pack identity changed")
+    timeline_descriptor = object_value(manifest.get("timeline"), "mixed-route timeline")
+    timeline_path = pack / "timeline.jsonl"
+    if (
+        timeline_descriptor.get("path") != timeline_path.name
+        or timeline_path.stat().st_size != timeline_descriptor.get("byte_length")
+        or sha256(timeline_path) != timeline_descriptor.get("sha256")
+    ):
+        raise MixedRouteDdrnetError("mixed-route timeline proof changed")
+    rows: list[dict[str, Any]] = []
+    with timeline_path.open(encoding="utf-8") as stream:
+        for expected, line in enumerate(stream):
+            row = object_value(json.loads(line), "mixed-route timeline row")
+            seconds = row.get("session_seconds")
+            if (
+                row.get("frame_index") != expected
+                or row.get("sequence") != expected + 1
+                or not isinstance(row.get("source_sequence"), int)
+                or row.get("source_frame_index") != row["source_sequence"] - 1
+                or not isinstance(seconds, (int, float))
+                or isinstance(seconds, bool)
+                or (rows and float(seconds) <= float(rows[-1]["session_seconds"]))
+            ):
+                raise MixedRouteDdrnetError("mixed-route timeline order changed")
+            rows.append(row)
+    if len(rows) != frame_count:
+        raise MixedRouteDdrnetError("mixed-route timeline is incomplete")
+    for expected, (descriptor_raw, row) in enumerate(zip(frames, rows)):  # noqa: B905
+        descriptor = object_value(descriptor_raw, "mixed-route frame descriptor")
+        relative = descriptor.get("path")
+        if relative != f"frames/frame-{expected + 1:06d}.png":
+            raise MixedRouteDdrnetError("mixed-route frame path changed")
+        pure = PurePosixPath(relative)
+        path = pack.joinpath(*pure.parts)
+        if (
+            path.is_symlink()
+            or not path.is_file()
+            or not path.resolve().is_relative_to(pack)
+            or path.stat().st_size != descriptor.get("byte_length")
+            or sha256(path) != descriptor.get("sha256")
+            or not isinstance(descriptor.get("source_segment_sha256"), str)
+            or row.get("source_sequence")
+            != identity["selected_sequences"][expected]
+        ):
+            raise MixedRouteDdrnetError("mixed-route frame proof changed")
+    return manifest, rows
+
+
+def overlay(source: Image.Image, semantic: np.ndarray, palette: np.ndarray) -> Image.Image:
+    if semantic.shape != (600, 800):
+        raise MixedRouteDdrnetError("expanded semantic mask shape changed")
+    base = source.convert("RGBA")
+    colors = Image.fromarray(palette[semantic], mode="RGBA")
+    return Image.alpha_composite(base, colors)
+
+
+def run() -> int:
+    args = arguments()
+    if not torch.cuda.is_available():
+        raise MixedRouteDdrnetError("CUDA is required for DDRNet islands")
+    if args.output.exists():
+        raise MixedRouteDdrnetError("DDRNet islands output already exists")
+    manifest, timeline = load_pack(args.pack)
+    config = read_json(args.config, "benchmark config")
+    policy = read_json(args.policy, "mission policy")
+    provider_map = read_json(args.provider_map, "provider map")
+    candidate = validate_contracts(config, policy, provider_map, "ddrnet")
+    checkpoint = args.checkpoint.resolve(strict=True)
+    if (
+        checkpoint.is_symlink()
+        or checkpoint.stat().st_size != candidate["checkpoint_size_bytes"]
+        or sha256(checkpoint) != candidate["checkpoint_sha256"]
+    ):
+        raise MixedRouteDdrnetError("DDRNet checkpoint identity changed")
+    dataset_root = args.dataset_root.resolve(strict=True)
+    mapping_path = dataset_root / config["dataset"]["mapping_relative_path"]
+    names, palette = load_mapping(mapping_path, config["dataset"]["mapping_sha256"])
+
+    args.output.mkdir(mode=0o700, parents=True, exist_ok=False)
+    mask_root = args.output / "semantic-masks"
+    overlay_root = args.output / "overlay-frames"
+    mask_root.mkdir(mode=0o700)
+    overlay_root.mkdir(mode=0o700)
+    torch.cuda.empty_cache()
+    model, model_name, architecture_failures = load_model("ddrnet", checkpoint)
+    first_path = args.pack / manifest["frames"][0]["path"]
+    with Image.open(first_path) as opened:
+        warm_source = opened.convert("RGB")
+    warm_tensor, _ = preprocess(warm_source)
+    warmup_ms = [infer(model, warm_tensor)[1] for _ in range(3)]
+    torch.cuda.reset_peak_memory_stats()
+
+    latencies_ms: list[float] = []
+    aggregate = np.zeros(CLASS_COUNT, dtype=np.int64)
+    frame_results: list[dict[str, Any]] = []
+    started = time.perf_counter()
+    for index, (descriptor, timeline_row) in enumerate(
+        zip(manifest["frames"], timeline)  # noqa: B905 - Worker image uses Python 3.9.
+    ):
+        source_path = args.pack / descriptor["path"]
+        with Image.open(source_path) as opened:
+            source = opened.convert("RGB")
+        if source.size != (800, 600):
+            raise MixedRouteDdrnetError("mixed-route source resolution changed")
+        tensor, crop_box = preprocess(source)
+        prediction, latency_ms = infer(model, tensor)
+        expanded = expand_mask(prediction, source.size, crop_box)
+        latencies_ms.append(latency_ms)
+        aggregate += np.bincount(expanded.reshape(-1), minlength=CLASS_COUNT)
+        mask_path = mask_root / f"frame-{index + 1:06d}.png"
+        overlay_path = overlay_root / f"frame-{index + 1:06d}.png"
+        mask_sha256 = save_image(mask_path, expanded, "L")
+        overlay_sha256 = save_image(overlay_path, overlay(source, expanded, palette))
+        present = np.flatnonzero(np.bincount(expanded.reshape(-1), minlength=CLASS_COUNT))
+        frame_results.append(
+            {
+                "frame_index": index,
+                "source_sequence": timeline_row["source_sequence"],
+                "source_frame_index": timeline_row["source_frame_index"],
+                "session_seconds": timeline_row["session_seconds"],
+                "latency_ms": round(latency_ms, 6),
+                "present_classes": [
+                    {"class_id": int(class_id), "label": names[int(class_id)]}
+                    for class_id in present
+                ],
+                "mask": {
+                    "path": mask_path.relative_to(args.output).as_posix(),
+                    "byte_length": mask_path.stat().st_size,
+                    "sha256": mask_sha256,
+                },
+                "overlay": {
+                    "path": overlay_path.relative_to(args.output).as_posix(),
+                    "byte_length": overlay_path.stat().st_size,
+                    "sha256": overlay_sha256,
+                },
+            }
+        )
+    wall_seconds = time.perf_counter() - started
+    if len(frame_results) != manifest["frame_count"]:
+        raise MixedRouteDdrnetError("DDRNet island accounting changed")
+    timing = {
+        "prewarm_inference_count": len(warmup_ms),
+        "prewarm_latency_ms_first": round(warmup_ms[0], 6),
+        "prewarm_latency_ms_last": round(warmup_ms[-1], 6),
+        "inference_wall_seconds": round(wall_seconds, 6),
+        "latency_ms_mean": round(statistics.fmean(latencies_ms), 6),
+        "latency_ms_p50": round(percentile(latencies_ms, 0.5), 6),
+        "latency_ms_p95": round(percentile(latencies_ms, 0.95), 6),
+        "throughput_fps_from_mean_inference": round(
+            1000.0 / statistics.fmean(latencies_ms), 6
+        ),
+    }
+    if any(not math.isfinite(float(value)) for value in timing.values()):
+        raise MixedRouteDdrnetError("DDRNet timing is non-finite")
+    result: dict[str, Any] = {
+        "schema_version": SCHEMA,
+        "status": "review-islands-ready-not-accepted",
+        "worker_id": "worker-006",
+        "source": {
+            "pack_id": manifest["pack_id"],
+            "pack_identity_sha256": manifest["identity_sha256"],
+            "job_id": manifest["identity"]["job_id"],
+            "input_sha256": manifest["identity"]["input_sha256"],
+            "session_id": manifest["identity"]["session_id"],
+            "source_id": manifest["identity"]["source_id"],
+            "frame_count": manifest["frame_count"],
+            "ground_truth_available": False,
+        },
+        "candidate": {
+            "candidate_key": "ddrnet",
+            "candidate_id": candidate["candidate_id"],
+            "loaded_model_name": model_name,
+            "architecture_probe_failures": architecture_failures,
+            "checkpoint_size_bytes": checkpoint.stat().st_size,
+            "checkpoint_sha256": sha256(checkpoint),
+        },
+        "taxonomy": {
+            "schema_version": "missioncore.lab-v1-vegetation-taxonomy/v1",
+            "classes": [
+                {
+                    "class_id": class_id,
+                    "label": names[class_id],
+                    "color_rgb": palette[class_id, :3].astype(int).tolist(),
+                    "disposition": "undefined" if class_id == 0 else "prediction",
+                }
+                for class_id in range(CLASS_COUNT)
+            ],
+        },
+        "aggregate_prediction_pixels": aggregate.tolist(),
+        "frames": frame_results,
+        "timing": timing,
+        "resource": {
+            "hostname": platform.node(),
+            "gpu_name": torch.cuda.get_device_name(0),
+            "peak_allocated_vram_bytes": int(torch.cuda.max_memory_allocated()),
+            "peak_reserved_vram_bytes": int(torch.cuda.max_memory_reserved()),
+            "torch_version": torch.__version__,
+            "cuda_runtime_version": torch.version.cuda,
+            "python_version": platform.python_version(),
+        },
+        "provenance": {
+            "pack_manifest_sha256": sha256(args.pack / "manifest.json"),
+            "config_sha256": sha256(args.config),
+            "policy_sha256": sha256(args.policy),
+            "provider_map_sha256": sha256(args.provider_map),
+            "runner_sha256": sha256(Path(__file__)),
+        },
+        "limitations": [
+            "Selected independently decodable islands are not a complete route timeline.",
+            "RAVNOVES004TREE has no route truth; class colors are model predictions.",
+            "DDRNet evidence cannot clear rigid geometry, person or vehicle vetoes.",
+        ],
+        "authority": AUTHORITY,
+    }
+    result["result_id"] = f"mixed-route-ddrnet-islands-{stable_digest(result)}"
+    (args.output / "result.json").write_text(
+        json.dumps(result, ensure_ascii=False, sort_keys=True, indent=2) + "\n",
+        encoding="utf-8",
+    )
+    print(
+        json.dumps(
+            {
+                "result_id": result["result_id"],
+                "frames": len(frame_results),
+                "latency_p95_ms": timing["latency_ms_p95"],
+            },
+            sort_keys=True,
+        )
+    )
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(run())

experiments/perception/worker/lab_v1_vegetation_goose/run_vegetation_integrated_load.py

@@ -0,0 +1,398 @@
+#!/usr/bin/env python3
+"""Run source-paced DDRNet beside the frozen M4 graph and TGS shadow."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import math
+import platform
+import shutil
+import statistics
+import time
+from pathlib import Path
+from typing import Any
+
+import cv2
+import torch
+from PIL import Image
+from run_goose_vegetation_benchmark import (
+    infer,
+    load_mapping,
+    load_model,
+    percentile,
+    preprocess,
+    read_json,
+    sha256,
+    stable_digest,
+    validate_contracts,
+)
+
+SCHEMA = "missioncore.lab-v1-vegetation-integrated-load/v3"
+FRAME_SCHEMA = "missioncore.lab-v1-vegetation-integrated-frame/v2"
+FRAME_COUNT = 4_489
+AUTHORITY = {
+    "ground_truth": False,
+    "candidate_accepted": False,
+    "camera_semantics_can_clear_rigid_geometry": False,
+    "commands_enabled": False,
+    "actuation_allowed": False,
+    "navigation_or_safety_accepted": False,
+    "production_accepted": False,
+}
+
+
+class IntegratedLoadError(RuntimeError):
+    """The bounded integrated-load contract is incomplete or changed."""
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--config", type=Path, required=True)
+    parser.add_argument("--policy", type=Path, required=True)
+    parser.add_argument("--provider-map", type=Path, required=True)
+    parser.add_argument("--checkpoint", type=Path, required=True)
+    parser.add_argument("--dataset-root", type=Path, required=True)
+    parser.add_argument("--video", type=Path, required=True)
+    parser.add_argument("--video-sha256", required=True)
+    parser.add_argument("--runtime-video-cache", type=Path, required=True)
+    parser.add_argument("--source-rate-hz", type=float, required=True)
+    parser.add_argument("--inference-stride", type=int, required=True)
+    parser.add_argument("--inference-phase-offset-ms", type=float, required=True)
+    parser.add_argument("--minimum-effective-timeline-fps", type=float, required=True)
+    parser.add_argument("--minimum-effective-inference-fps", type=float, required=True)
+    parser.add_argument("--maximum-inference-completion-p95-ms", type=float, required=True)
+    parser.add_argument("--maximum-evidence-source-age-ms", type=float, required=True)
+    parser.add_argument("--shared-start-ready-file", type=Path, required=True)
+    parser.add_argument("--shared-start-file", type=Path, required=True)
+    parser.add_argument("--shared-start-timeout-seconds", type=float, default=600.0)
+    parser.add_argument("--frame-ledger", type=Path, required=True)
+    parser.add_argument("--output", type=Path, required=True)
+    parser.add_argument("--release-sha256", required=True)
+    return parser.parse_args()
+
+
+def wait_for_shared_start(ready_file: Path, start_file: Path, timeout_seconds: float) -> None:
+    if ready_file.exists():
+        raise IntegratedLoadError("shared-start ready file already exists")
+    ready_file.parent.mkdir(mode=0o700, parents=True, exist_ok=True)
+    ready_file.write_text("ready\n", encoding="utf-8")
+    deadline = time.monotonic() + timeout_seconds
+    while not start_file.is_file():
+        if time.monotonic() >= deadline:
+            raise IntegratedLoadError("shared-start barrier timed out")
+        time.sleep(0.01)
+
+
+def distribution(values: list[float]) -> dict[str, float]:
+    return {
+        "mean": round(statistics.fmean(values), 6),
+        "p50": round(percentile(values, 0.50), 6),
+        "p95": round(percentile(values, 0.95), 6),
+        "p99": round(percentile(values, 0.99), 6),
+        "maximum": round(max(values), 6),
+    }
+
+
+def open_video(path: Path) -> cv2.VideoCapture:
+    if path.is_symlink() or not path.is_file():
+        raise IntegratedLoadError("RAVNOVES video is unavailable")
+    capture = cv2.VideoCapture(str(path))
+    if not capture.isOpened():
+        raise IntegratedLoadError("RAVNOVES video decoder did not open")
+    return capture
+
+
+def decode_source(capture: cv2.VideoCapture, expected_size: tuple[int, int]) -> Image.Image:
+    available, bgr = capture.read()
+    if not available or bgr is None:
+        raise IntegratedLoadError("RAVNOVES video ended before the frozen frame count")
+    if (bgr.shape[1], bgr.shape[0]) != expected_size:
+        raise IntegratedLoadError("RAVNOVES decoded frame dimensions changed")
+    return Image.fromarray(cv2.cvtColor(bgr, cv2.COLOR_BGR2RGB), mode="RGB")
+
+
+def validate_sha256(value: str, label: str) -> None:
+    if len(value) != 64 or any(character not in "0123456789abcdef" for character in value):
+        raise IntegratedLoadError(f"{label} SHA-256 is invalid")
+
+
+def buffer_compressed_video(source: Path, target: Path, expected_sha256: str) -> dict[str, Any]:
+    if source.is_symlink() or not source.is_file():
+        raise IntegratedLoadError("RAVNOVES video is unavailable")
+    if target.exists() or target.is_symlink():
+        raise IntegratedLoadError("RAVNOVES runtime video cache already exists")
+    if not target.parent.is_dir():
+        raise IntegratedLoadError("RAVNOVES runtime video cache parent is unavailable")
+    started = time.monotonic_ns()
+    shutil.copyfile(source, target)
+    copied_bytes = target.stat().st_size
+    if copied_bytes != source.stat().st_size:
+        raise IntegratedLoadError("RAVNOVES runtime video cache size changed")
+    copied_sha256 = sha256(target)
+    if copied_sha256 != expected_sha256:
+        raise IntegratedLoadError("RAVNOVES runtime video cache digest changed")
+    return {
+        "bytes": copied_bytes,
+        "sha256": copied_sha256,
+        "seconds": round((time.monotonic_ns() - started) / 1_000_000_000.0, 6),
+    }
+
+
+def run() -> int:
+    args = parse_args()
+    if not torch.cuda.is_available():
+        raise IntegratedLoadError("CUDA is required for Worker 006 qualification")
+    positive_finite_values = (
+        args.source_rate_hz,
+        args.minimum_effective_timeline_fps,
+        args.minimum_effective_inference_fps,
+        args.maximum_inference_completion_p95_ms,
+        args.maximum_evidence_source_age_ms,
+        args.shared_start_timeout_seconds,
+    )
+    if args.inference_stride <= 0 or any(
+        not math.isfinite(value) or value <= 0 for value in positive_finite_values
+    ):
+        raise IntegratedLoadError("integrated-load thresholds must be positive and finite")
+    if (
+        not math.isfinite(args.inference_phase_offset_ms)
+        or args.inference_phase_offset_ms < 0
+        or args.inference_phase_offset_ms >= 1000.0 / args.source_rate_hz
+    ):
+        raise IntegratedLoadError("inference phase offset must fit inside one source interval")
+    validate_sha256(args.release_sha256, "release")
+    validate_sha256(args.video_sha256, "video")
+    if args.output.exists() or args.frame_ledger.exists():
+        raise IntegratedLoadError("integrated-load output already exists")
+
+    config = read_json(args.config, "benchmark config")
+    policy = read_json(args.policy, "mission policy")
+    provider_map = read_json(args.provider_map, "provider map")
+    candidate = validate_contracts(config, policy, provider_map, "ddrnet")
+    if args.checkpoint.is_symlink() or not args.checkpoint.is_file():
+        raise IntegratedLoadError("DDRNet checkpoint is unavailable")
+    if args.checkpoint.stat().st_size != candidate["checkpoint_size_bytes"]:
+        raise IntegratedLoadError("DDRNet checkpoint size changed")
+    checkpoint_sha256 = sha256(args.checkpoint)
+    if checkpoint_sha256 != candidate["checkpoint_sha256"]:
+        raise IntegratedLoadError("DDRNet checkpoint digest changed")
+    mapping_path = args.dataset_root / config["dataset"]["mapping_relative_path"]
+    load_mapping(mapping_path, config["dataset"]["mapping_sha256"])
+    expected_size = (
+        config["ravnoves"]["expected_width"],
+        config["ravnoves"]["expected_height"],
+    )
+    compressed_video_buffer = buffer_compressed_video(
+        args.video, args.runtime_video_cache, args.video_sha256
+    )
+    warmup_capture = open_video(args.runtime_video_cache)
+    warmup_source = decode_source(warmup_capture, expected_size)
+    warmup_capture.release()
+
+    torch.cuda.empty_cache()
+    model, model_name, architecture_failures = load_model("ddrnet", args.checkpoint)
+    warmup_tensor, _ = preprocess(warmup_source)
+    warmup_latencies_ms = [infer(model, warmup_tensor)[1] for _ in range(3)]
+    torch.cuda.reset_peak_memory_stats()
+    source_capture = open_video(args.runtime_video_cache)
+    wait_for_shared_start(
+        args.shared_start_ready_file,
+        args.shared_start_file,
+        args.shared_start_timeout_seconds,
+    )
+
+    interval_ns = 1_000_000_000.0 / args.source_rate_hz
+    start_ns = time.monotonic_ns()
+    started_utc_ns = time.time_ns()
+    completion_ages_ms: list[float] = []
+    inference_completion_ages_ms: list[float] = []
+    evidence_source_ages_ms: list[float] = []
+    stage_latencies_ms: list[float] = []
+    inference_latencies_ms: list[float] = []
+    late_deadline_count = 0
+    inference_frame_count = 0
+    last_inference_sequence = -1
+    args.frame_ledger.parent.mkdir(parents=True, exist_ok=True)
+    with args.frame_ledger.open("x", encoding="utf-8") as ledger:
+        for sequence in range(FRAME_COUNT):
+            scheduled_ns = start_ns + round(sequence * interval_ns)
+            inference_executed = sequence % args.inference_stride == 0
+            execution_target_ns = scheduled_ns
+            if inference_executed:
+                execution_target_ns += round(args.inference_phase_offset_ms * 1_000_000.0)
+            remaining_ns = execution_target_ns - time.monotonic_ns()
+            if remaining_ns > 0:
+                time.sleep(remaining_ns / 1_000_000_000.0)
+            admitted_ns = time.monotonic_ns()
+            source = decode_source(source_capture, expected_size)
+            inference_ms: float | None = None
+            if inference_executed:
+                tensor, _ = preprocess(source)
+                _, inference_ms = infer(model, tensor)
+                last_inference_sequence = sequence
+                inference_frame_count += 1
+            if last_inference_sequence < 0:
+                raise IntegratedLoadError("semantic evidence is unavailable for the timeline")
+            completed_ns = time.monotonic_ns()
+            completion_age_ms = (completed_ns - scheduled_ns) / 1_000_000.0
+            stage_ms = (completed_ns - admitted_ns) / 1_000_000.0
+            semantic_source_scheduled_ns = start_ns + round(
+                last_inference_sequence * interval_ns
+            )
+            evidence_source_age_ms = (
+                completed_ns - semantic_source_scheduled_ns
+            ) / 1_000_000.0
+            completion_ages_ms.append(completion_age_ms)
+            evidence_source_ages_ms.append(evidence_source_age_ms)
+            stage_latencies_ms.append(stage_ms)
+            if inference_ms is not None:
+                inference_latencies_ms.append(inference_ms)
+                inference_completion_ages_ms.append(completion_age_ms)
+            if sequence + 1 < FRAME_COUNT and completed_ns > start_ns + round(
+                (sequence + 1) * interval_ns
+            ):
+                late_deadline_count += 1
+            row = {
+                "schema_version": FRAME_SCHEMA,
+                "sequence": sequence,
+                "frame_name": f"frame-{sequence + 1:06d}",
+                "scheduled_monotonic_ns": scheduled_ns,
+                "admitted_monotonic_ns": admitted_ns,
+                "completed_monotonic_ns": completed_ns,
+                "completion_age_ms": round(completion_age_ms, 6),
+                "stage_ms": round(stage_ms, 6),
+                "inference_executed": inference_executed,
+                "inference_phase_offset_ms": args.inference_phase_offset_ms
+                if inference_executed
+                else 0.0,
+                "inference_ms": round(inference_ms, 6) if inference_ms is not None else None,
+                "semantic_source_sequence": last_inference_sequence,
+                "semantic_evidence_source_age_ms": round(evidence_source_age_ms, 6),
+            }
+            ledger.write(json.dumps(row, sort_keys=True, separators=(",", ":")) + "\n")
+            if sequence % 64 == 0:
+                ledger.flush()
+    extra_available, _ = source_capture.read()
+    source_capture.release()
+    if extra_available:
+        raise IntegratedLoadError("RAVNOVES video contains frames beyond the frozen timeline")
+
+    completed_ns = time.monotonic_ns()
+    wall_seconds = (completed_ns - start_ns) / 1_000_000_000.0
+    effective_timeline_fps = FRAME_COUNT / wall_seconds
+    effective_inference_fps = inference_frame_count / wall_seconds
+    completion = distribution(completion_ages_ms)
+    inference_completion = distribution(inference_completion_ages_ms)
+    evidence_source_age = distribution(evidence_source_ages_ms)
+    expected_inference_frames = (FRAME_COUNT + args.inference_stride - 1) // args.inference_stride
+    checks = {
+        "all_frames_accounted": len(completion_ages_ms) == FRAME_COUNT,
+        "exact_multirate_schedule": inference_frame_count == expected_inference_frames,
+        "inference_phase_offset_preserved": args.inference_phase_offset_ms
+        < 1000.0 / args.source_rate_hz,
+        "minimum_effective_timeline_fps": effective_timeline_fps
+        >= args.minimum_effective_timeline_fps,
+        "minimum_effective_inference_fps": effective_inference_fps
+        >= args.minimum_effective_inference_fps,
+        "maximum_inference_completion_p95_ms": inference_completion["p95"]
+        <= args.maximum_inference_completion_p95_ms,
+        "maximum_evidence_source_age_ms": evidence_source_age["maximum"]
+        <= args.maximum_evidence_source_age_ms,
+        "zero_capacity_drops": len(completion_ages_ms) == FRAME_COUNT,
+        "authority_remains_false": all(value is False for value in AUTHORITY.values()),
+    }
+    result: dict[str, Any] = {
+        "schema_version": SCHEMA,
+        "worker_id": "worker-006",
+        "source": {
+            "source_id": config["ravnoves"]["source_id"],
+            "frame_count": FRAME_COUNT,
+            "requested_source_rate_hz": args.source_rate_hz,
+            "raw_fisheye_immutable": True,
+            "ground_truth_available": False,
+        },
+        "candidate": {
+            "candidate_id": candidate["candidate_id"],
+            "candidate_key": "ddrnet",
+            "loaded_model_name": model_name,
+            "architecture_probe_failures": architecture_failures,
+            "checkpoint_size_bytes": args.checkpoint.stat().st_size,
+            "checkpoint_sha256": checkpoint_sha256,
+        },
+        "execution": {
+            "run_mode": "source-paced-multirate-integrated-shadow/v2",
+            "started_utc_ns": started_utc_ns,
+            "wall_seconds": round(wall_seconds, 6),
+            "effective_fps": round(effective_timeline_fps, 6),
+            "effective_timeline_fps": round(effective_timeline_fps, 6),
+            "effective_inference_fps": round(effective_inference_fps, 6),
+            "inference_stride": args.inference_stride,
+            "inference_phase_offset_ms": args.inference_phase_offset_ms,
+            "inference_frame_count": inference_frame_count,
+            "held_evidence_frame_count": FRAME_COUNT - inference_frame_count,
+            "frame_count": FRAME_COUNT,
+            "capacity_drop_count": 0,
+            "deadline_miss_count": late_deadline_count,
+            "source_decode": {
+                "mode": "bounded-compressed-scene-buffer/v1",
+                "compressed_scene_prefetch": True,
+                "compressed_scene_buffer": compressed_video_buffer,
+                "full_route_rgb_prefetch": False,
+                "candidate_local_decoder": True,
+                "runtime_target": "shared-source-frame",
+            },
+            "frame_ledger": {
+                "path": args.frame_ledger.name,
+                "rows": FRAME_COUNT,
+                "sha256": sha256(args.frame_ledger),
+            },
+        },
+        "timing": {
+            "prewarm_inference_count": len(warmup_latencies_ms),
+            "prewarm_latency_ms_first": round(warmup_latencies_ms[0], 6),
+            "prewarm_latency_ms_last": round(warmup_latencies_ms[-1], 6),
+            "completion_age_ms": completion,
+            "inference_completion_age_ms": inference_completion,
+            "semantic_evidence_source_age_ms": evidence_source_age,
+            "stage_ms": distribution(stage_latencies_ms),
+            "inference_ms": distribution(inference_latencies_ms),
+        },
+        "resource": {
+            "gpu_name": torch.cuda.get_device_name(0),
+            "peak_allocated_vram_bytes": int(torch.cuda.max_memory_allocated()),
+            "peak_reserved_vram_bytes": int(torch.cuda.max_memory_reserved()),
+            "torch_version": torch.__version__,
+            "cuda_runtime_version": torch.version.cuda,
+            "python_version": platform.python_version(),
+        },
+        "identity": {
+            "release_sha256": args.release_sha256,
+            "config_sha256": sha256(args.config),
+            "policy_sha256": sha256(args.policy),
+            "provider_map_sha256": sha256(args.provider_map),
+            "runner_sha256": sha256(Path(__file__)),
+        },
+        "predeclared_thresholds": {
+            "minimum_effective_timeline_fps": args.minimum_effective_timeline_fps,
+            "minimum_effective_inference_fps": args.minimum_effective_inference_fps,
+            "inference_phase_offset_ms": args.inference_phase_offset_ms,
+            "maximum_inference_completion_p95_ms": (
+                args.maximum_inference_completion_p95_ms
+            ),
+            "maximum_evidence_source_age_ms": args.maximum_evidence_source_age_ms,
+            "capacity_drop_count_max": 0,
+        },
+        "checks": checks,
+        "integrated_load_gate_passed": all(checks.values()),
+        "authority": AUTHORITY,
+    }
+    result["result_id"] = f"lab-v1-vegetation-integrated-{stable_digest(result)}"
+    args.output.parent.mkdir(parents=True, exist_ok=True)
+    args.output.write_text(json.dumps(result, indent=2, sort_keys=True) + "\n", encoding="utf-8")
+    print(json.dumps({"result_id": result["result_id"], "passed": all(checks.values())}))
+    return 0 if all(checks.values()) else 2
+
+
+if __name__ == "__main__":
+    raise SystemExit(run())

experiments/perception/worker/m49_t3_travel/build_mixed_route_tgs_evidence.py

@@ -0,0 +1,277 @@
+#!/usr/bin/env python3
+"""Seal fail-closed TRAVEL/TGS evidence for mixed-route review islands."""
+
+from __future__ import annotations
+
+import argparse
+import csv
+import json
+from pathlib import Path
+
+import numpy as np
+from build_tgs_fail_closed_evidence import (
+    TgsEvidenceError,
+    _load_float32,
+    classify_exact_input,
+    costmap_grid,
+    rasterize_costmap,
+    sha256_file,
+    write_deterministic_npz,
+)
+
+CONFIG_SCHEMA = "missioncore.mixed-route-tgs-review-profile/v1"
+INPUT_SCHEMA = "missioncore.mixed-route-tgs-input/v1"
+RESULT_SCHEMA = "missioncore.mixed-route-tgs-result/v1"
+FRAME_COUNT = 10
+
+
+def _timing(path: Path) -> dict[str, object]:
+    rows: list[dict[str, object]] = []
+    with path.open(encoding="utf-8", newline="") as stream:
+        for raw in csv.DictReader(stream, delimiter="\t"):
+            try:
+                row = {
+                    "profile_id": str(raw["profile"]),
+                    "slot": int(raw["slot"]),
+                    "wall_seconds": float(raw["wall_seconds"]),
+                    "max_rss_kib": int(raw["max_rss_kib"]),
+                }
+            except (KeyError, TypeError, ValueError) as exc:
+                raise TgsEvidenceError("TGS timing row is invalid") from exc
+            if (
+                row["profile_id"] not in {"current_increment", "causal_rolling_1s"}
+                or not 0 <= row["slot"] < FRAME_COUNT
+                or not 0 <= row["wall_seconds"] < 60
+                or not 0 < row["max_rss_kib"] < 16 * 1024 * 1024
+            ):
+                raise TgsEvidenceError("TGS timing value is invalid")
+            rows.append(row)
+    if len(rows) != FRAME_COUNT * 2:
+        raise TgsEvidenceError("TGS timing is incomplete")
+    seconds = np.asarray([row["wall_seconds"] for row in rows], dtype=np.float64)
+    return {
+        "runs": rows,
+        "wall_seconds_mean": round(float(seconds.mean()), 6),
+        "wall_seconds_p95": round(float(np.percentile(seconds, 95)), 6),
+        "max_rss_kib": max(int(row["max_rss_kib"]) for row in rows),
+    }
+
+
+def build(run_root: Path, config_path: Path, output_root: Path) -> dict[str, object]:
+    if output_root.exists():
+        raise TgsEvidenceError("mixed-route TGS evidence already exists")
+    config = json.loads(config_path.read_text(encoding="utf-8"))
+    source = config.get("source") if isinstance(config, dict) else None
+    invariants = config.get("invariants") if isinstance(config, dict) else None
+    if (
+        config.get("schema_version") != CONFIG_SCHEMA
+        or not isinstance(source, dict)
+        or not isinstance(invariants, dict)
+        or invariants.get("aos_allowed") is not False
+        or invariants.get("missing_support_means_free") is not False
+        or invariants.get("future_frames_used") is not False
+        or invariants.get("navigation_or_actuation_allowed") is not False
+        or config.get("state_codes")
+        != {
+            "UNOBSERVED": 0,
+            "GROUND_SUPPORT": 1,
+            "NONGROUND_OCCUPIED": 2,
+            "UNKNOWN_REJECTED": 3,
+        }
+    ):
+        raise TgsEvidenceError("mixed-route TGS profile changed")
+    input_manifest_path = run_root / "inputs" / "input-manifest.json"
+    input_manifest = json.loads(input_manifest_path.read_text(encoding="utf-8"))
+    if (
+        input_manifest.get("schema_version") != INPUT_SCHEMA
+        or input_manifest.get("source_pack_id") != source.get("source_pack_id")
+        or input_manifest.get("source_pack_sha256")
+        != source.get("source_pack_sha256")
+        or input_manifest.get("config_sha256") != sha256_file(config_path)
+        or input_manifest.get("coordinate_frame") != "map-gravity-local"
+        or input_manifest.get("future_frames_used") is not False
+        or input_manifest.get("frame_count") != FRAME_COUNT
+        or len(input_manifest.get("records", [])) != FRAME_COUNT * 2
+    ):
+        raise TgsEvidenceError("mixed-route TGS input manifest changed")
+    records = {
+        (str(row["profile_id"]), int(row["slot"])): row
+        for row in input_manifest["records"]
+    }
+    if len(records) != FRAME_COUNT * 2:
+        raise TgsEvidenceError("mixed-route TGS input records are not unique")
+
+    cell_size = float(config["costmap"]["cell_size_m"])
+    radius = float(config["costmap"]["radius_m"])
+    grid = costmap_grid(radius, cell_size)
+    arrays: dict[str, np.ndarray] = {
+        "costmap_cell_indices_xy": grid[:, :2].astype(np.int32),
+        "costmap_cell_centers_xy_m": grid[:, 2:].astype(np.float32),
+        "source_frame_indices": np.asarray(
+            [
+                records[("current_increment", slot)]["source_frame_index"]
+                for slot in range(FRAME_COUNT)
+            ],
+            dtype=np.int64,
+        ),
+        "session_seconds": np.asarray(
+            [
+                records[("current_increment", slot)]["session_seconds"]
+                for slot in range(FRAME_COUNT)
+            ],
+            dtype=np.float64,
+        ),
+    }
+    summaries: list[dict[str, object]] = []
+    for profile_id in ("current_increment", "causal_rolling_1s"):
+        all_points: list[np.ndarray] = []
+        all_states: list[np.ndarray] = []
+        offsets = [0]
+        grid_states: list[np.ndarray] = []
+        ground_counts: list[np.ndarray] = []
+        nonground_counts: list[np.ndarray] = []
+        rejected_counts: list[np.ndarray] = []
+        z_bounds_rows: list[np.ndarray] = []
+        for slot in range(FRAME_COUNT):
+            record = records[(profile_id, slot)]
+            native_path = run_root / "inputs" / str(record["relative_path"])
+            if (
+                not native_path.is_file()
+                or native_path.stat().st_size != record["bytes"]
+                or sha256_file(native_path) != record["sha256"]
+            ):
+                raise TgsEvidenceError("sealed mixed-route TGS input changed")
+            output = run_root / "outputs" / profile_id
+            points, states = classify_exact_input(
+                _load_float32(native_path, 4),
+                _load_float32(output / f"{slot}_ground.bin", 4),
+                _load_float32(output / f"{slot}_nonground.bin", 4),
+                min_range_m=float(config["tgs"]["min_range_m"]),
+                max_range_m=float(config["tgs"]["max_range_m"]),
+            )
+            grid_state, ground, nonground, rejected, z_bounds = rasterize_costmap(
+                points,
+                states,
+                grid,
+                cell_size_m=cell_size,
+            )
+            all_points.append(points.astype(np.float32, copy=False))
+            all_states.append(states)
+            offsets.append(offsets[-1] + points.shape[0])
+            grid_states.append(grid_state)
+            ground_counts.append(ground)
+            nonground_counts.append(nonground)
+            rejected_counts.append(rejected)
+            z_bounds_rows.append(z_bounds)
+            accounted = (
+                np.count_nonzero(states == 1)
+                + np.count_nonzero(states == 2)
+                + np.count_nonzero(states == 3)
+                == points.shape[0]
+            )
+            summaries.append(
+                {
+                    "profile_id": profile_id,
+                    "slot": slot,
+                    "frame_index": int(record["frame_index"]),
+                    "source_frame_index": int(record["source_frame_index"]),
+                    "source_sequence": int(record["source_sequence"]),
+                    "session_seconds": float(record["session_seconds"]),
+                    "point_count": int(points.shape[0]),
+                    "ground_point_count": int(np.count_nonzero(states == 1)),
+                    "nonground_point_count": int(np.count_nonzero(states == 2)),
+                    "rejected_point_count": int(np.count_nonzero(states == 3)),
+                    "ground_cell_count": int(np.count_nonzero(grid_state == 1)),
+                    "nonground_cell_count": int(np.count_nonzero(grid_state == 2)),
+                    "rejected_cell_count": int(np.count_nonzero(grid_state == 3)),
+                    "unobserved_cell_count": int(np.count_nonzero(grid_state == 0)),
+                    "all_points_accounted": bool(accounted),
+                }
+            )
+        arrays[f"{profile_id}_points_xyz_m"] = np.concatenate(all_points)
+        arrays[f"{profile_id}_point_states"] = np.concatenate(all_states)
+        arrays[f"{profile_id}_point_offsets"] = np.asarray(offsets, dtype=np.int64)
+        arrays[f"{profile_id}_costmap_states"] = np.stack(grid_states)
+        arrays[f"{profile_id}_costmap_ground_point_counts"] = np.stack(ground_counts)
+        arrays[f"{profile_id}_costmap_nonground_point_counts"] = np.stack(
+            nonground_counts
+        )
+        arrays[f"{profile_id}_costmap_rejected_point_counts"] = np.stack(
+            rejected_counts
+        )
+        arrays[f"{profile_id}_costmap_z_bounds_m"] = np.stack(z_bounds_rows)
+    if not all(bool(row["all_points_accounted"]) for row in summaries):
+        raise TgsEvidenceError("mixed-route TGS lost an eligible point")
+
+    output_root.mkdir(parents=True)
+    evidence_path = output_root / "evidence.npz"
+    write_deterministic_npz(evidence_path, arrays)
+    timing = _timing(run_root / "tgs-timing.tsv")
+    result = {
+        "schema_version": RESULT_SCHEMA,
+        "status": "passed-review-only",
+        "source": {
+            "source_id": source["source_id"],
+            "session_id": source["session_id"],
+            "review_pack_id": source["review_pack_id"],
+            "source_pack_id": source["source_pack_id"],
+            "source_pack_sha256": source["source_pack_sha256"],
+        },
+        "config_sha256": sha256_file(config_path),
+        "input_manifest_sha256": sha256_file(input_manifest_path),
+        "evidence": {
+            "path": "evidence.npz",
+            "bytes": evidence_path.stat().st_size,
+            "sha256": sha256_file(evidence_path),
+        },
+        "costmap": {
+            "coordinate_frame": "map-gravity-local",
+            "cell_size_m": cell_size,
+            "radius_m": radius,
+            "cell_count": int(grid.shape[0]),
+        },
+        "anchors": summaries,
+        "timing": timing,
+        "summary": {
+            "frame_count": FRAME_COUNT,
+            "anchor_profile_count": len(summaries),
+            "all_eligible_points_accounted": True,
+            "aos_used": False,
+            "primary_profile": "causal_rolling_1s",
+        },
+        "limitations": [
+            "Selected review islands are not a complete route timeline.",
+            (
+                "TGS separates local ground support from non-ground evidence; it does not "
+                "prove ditch or negative-obstacle detection."
+            ),
+            "Camera projection is visual evidence only and cannot clear rigid geometry.",
+        ],
+        "authority": {
+            "visual_quality_accepted": False,
+            "traversability_accepted": False,
+            "realtime_accepted": False,
+            "navigation_or_safety_accepted": False,
+            "actuation_allowed": False,
+        },
+    }
+    (output_root / "result.json").write_text(
+        json.dumps(result, indent=2, sort_keys=True) + "\n",
+        encoding="utf-8",
+    )
+    return result
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--run-root", type=Path, required=True)
+    parser.add_argument("--config", type=Path, required=True)
+    parser.add_argument("--output-root", type=Path, required=True)
+    args = parser.parse_args()
+    result = build(args.run_root, args.config, args.output_root)
+    print(json.dumps(result["summary"], sort_keys=True))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

experiments/perception/worker/m49_t3_travel/build_vegetation_integrated_graph_evidence.py

@@ -0,0 +1,461 @@
+#!/usr/bin/env python3
+"""Seal the synchronized RF-DETR, TGS and DDRNet Worker 006 load gate."""
+
+from __future__ import annotations
+
+import argparse
+import csv
+import hashlib
+import json
+import math
+import re
+from collections import defaultdict
+from pathlib import Path
+from typing import Any
+
+import numpy as np
+
+PROFILE_SCHEMA = "missioncore.lab-v1-vegetation-integrated-shadow-profile/v3"
+M49_SCHEMA = "missioncore.m49-tgs-integrated-graph-shadow-result/v1"
+VEGETATION_SCHEMA = "missioncore.lab-v1-vegetation-integrated-load/v3"
+RESULT_SCHEMA = "missioncore.lab-v1-vegetation-integrated-shadow-result/v3"
+FRAME_COUNT = 4_489
+
+
+class VegetationIntegratedError(RuntimeError):
+    """The synchronized three-layer load evidence is incomplete."""
+
+
+def canonical_json(value: object) -> bytes:
+    return json.dumps(value, sort_keys=True, separators=(",", ":")).encode("utf-8")
+
+
+def sha256_file(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as stream:
+        for chunk in iter(lambda: stream.read(1024 * 1024), b""):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+def load_json(path: Path, label: str) -> dict[str, Any]:
+    try:
+        value = json.loads(path.read_text(encoding="utf-8-sig"))
+    except (OSError, json.JSONDecodeError) as exc:
+        raise VegetationIntegratedError(f"{label} is unreadable") from exc
+    if not isinstance(value, dict):
+        raise VegetationIntegratedError(f"{label} is not an object")
+    return value
+
+
+def distribution(values: list[float]) -> dict[str, float]:
+    if not values:
+        raise VegetationIntegratedError("timing distribution is empty")
+    array = np.asarray(values, dtype=np.float64)
+    return {
+        "mean": round(float(array.mean()), 6),
+        "p50": round(float(np.percentile(array, 50)), 6),
+        "p95": round(float(np.percentile(array, 95)), 6),
+        "p99": round(float(np.percentile(array, 99)), 6),
+        "maximum": round(float(array.max()), 6),
+    }
+
+
+def graph_completion_ages(path: Path) -> list[float]:
+    values: list[float] = []
+    with path.open("r", encoding="utf-8") as stream:
+        for expected, line in enumerate(stream):
+            row = json.loads(line)
+            if row.get("source_envelope", {}).get("sequence") != expected:
+                raise VegetationIntegratedError("graph frame sequence changed")
+            age = row.get("completion_age_ns")
+            if not isinstance(age, int) or age < 0:
+                raise VegetationIntegratedError("graph completion age is invalid")
+            values.append(age / 1_000_000.0)
+    if len(values) != FRAME_COUNT:
+        raise VegetationIntegratedError("graph frame ledger is incomplete")
+    return values
+
+
+def tgs_completion_ages(path: Path) -> list[float]:
+    values: list[float] = []
+    with path.open("r", encoding="utf-8", newline="") as stream:
+        for expected, row in enumerate(csv.DictReader(stream, delimiter="\t")):
+            if int(row["timeline_frame_index"]) != expected:
+                raise VegetationIntegratedError("TGS timing sequence changed")
+            age = float(row["completion_age_ms"])
+            if not math.isfinite(age) or age < 0:
+                raise VegetationIntegratedError("TGS completion age is invalid")
+            values.append(age)
+    if len(values) != FRAME_COUNT:
+        raise VegetationIntegratedError("TGS timing ledger is incomplete")
+    return values
+
+
+def vegetation_frame_metrics(
+    path: Path,
+    *,
+    inference_stride: int,
+    inference_phase_offset_ms: float,
+    source_rate_hz: float,
+) -> dict[str, object]:
+    completion_ages: list[float] = []
+    evidence_source_ages: list[float] = []
+    inference_count = 0
+    with path.open("r", encoding="utf-8") as stream:
+        for expected, line in enumerate(stream):
+            row = json.loads(line)
+            if row.get("schema_version") != "missioncore.lab-v1-vegetation-integrated-frame/v2":
+                raise VegetationIntegratedError("vegetation frame schema changed")
+            if row.get("sequence") != expected:
+                raise VegetationIntegratedError("vegetation frame sequence changed")
+            age = row.get("completion_age_ms")
+            if not isinstance(age, (int, float)) or not math.isfinite(age) or age < 0:
+                raise VegetationIntegratedError("vegetation completion age is invalid")
+            inference_executed = row.get("inference_executed")
+            expected_inference = expected % inference_stride == 0
+            if inference_executed is not expected_inference:
+                raise VegetationIntegratedError("vegetation inference schedule changed")
+            expected_phase = inference_phase_offset_ms if expected_inference else 0.0
+            phase = row.get("inference_phase_offset_ms")
+            if not isinstance(phase, (int, float)) or float(phase) != expected_phase:
+                raise VegetationIntegratedError("vegetation inference phase changed")
+            if expected_inference and float(age) + 0.001 < expected_phase:
+                raise VegetationIntegratedError("vegetation inference phase attribution changed")
+            expected_source = expected - (expected % inference_stride)
+            if row.get("semantic_source_sequence") != expected_source:
+                raise VegetationIntegratedError("vegetation evidence source changed")
+            evidence_age = row.get("semantic_evidence_source_age_ms")
+            expected_evidence_age = float(age) + (
+                (expected - expected_source) * 1000.0 / source_rate_hz
+            )
+            if (
+                not isinstance(evidence_age, (int, float))
+                or not math.isfinite(evidence_age)
+                or evidence_age < 0
+                or abs(float(evidence_age) - expected_evidence_age) > 0.001
+            ):
+                raise VegetationIntegratedError("vegetation evidence source age changed")
+            completion_ages.append(float(age))
+            evidence_source_ages.append(float(evidence_age))
+            inference_count += int(expected_inference)
+    if len(completion_ages) != FRAME_COUNT:
+        raise VegetationIntegratedError("vegetation frame ledger is incomplete")
+    return {
+        "completion_ages": completion_ages,
+        "evidence_source_ages": evidence_source_ages,
+        "inference_count": inference_count,
+        "held_count": FRAME_COUNT - inference_count,
+    }
+
+
+_SIZE = re.compile(r"^\s*([0-9.]+)\s*([kmgt]?i?b)\s*$", re.IGNORECASE)
+
+
+def size_mib(value: str) -> float:
+    match = _SIZE.fullmatch(value)
+    if match is None:
+        raise VegetationIntegratedError("container memory telemetry is invalid")
+    number = float(match.group(1))
+    scale = {
+        "b": 1.0 / (1024.0 * 1024.0),
+        "kb": 1.0 / 1024.0,
+        "kib": 1.0 / 1024.0,
+        "mb": 1.0,
+        "mib": 1.0,
+        "gb": 1024.0,
+        "gib": 1024.0,
+        "tb": 1024.0 * 1024.0,
+        "tib": 1024.0 * 1024.0,
+    }[match.group(2).lower()]
+    return number * scale
+
+
+def host_telemetry(path: Path) -> dict[str, object]:
+    roles = ("graph", "tgs", "triton", "vegetation")
+    samples: dict[str, list[dict[str, float]]] = defaultdict(list)
+    with path.open("r", encoding="utf-8-sig") as stream:
+        for line in stream:
+            row = json.loads(line)
+            role = row.get("role")
+            if role not in roles:
+                raise VegetationIntegratedError("container telemetry role changed")
+            cpu = row.get("cpu_percent")
+            memory = row.get("memory_usage")
+            memory_percent = row.get("memory_percent")
+            if not all(isinstance(value, str) for value in (cpu, memory, memory_percent)):
+                raise VegetationIntegratedError("container telemetry row is incomplete")
+            assert isinstance(cpu, str) and isinstance(memory, str)
+            assert isinstance(memory_percent, str)
+            samples[role].append(
+                {
+                    "cpu_percent": float(cpu.rstrip("%")),
+                    "memory_used_mib": size_mib(memory.split("/", 1)[0].strip()),
+                    "memory_percent": float(memory_percent.rstrip("%")),
+                }
+            )
+    if any(not samples[role] for role in roles):
+        raise VegetationIntegratedError("container telemetry does not cover every runtime role")
+    return {
+        role: {
+            "sample_count": len(samples[role]),
+            "cpu_percent": distribution([row["cpu_percent"] for row in samples[role]]),
+            "memory_used_mib": distribution(
+                [row["memory_used_mib"] for row in samples[role]]
+            ),
+            "memory_percent": distribution(
+                [row["memory_percent"] for row in samples[role]]
+            ),
+        }
+        for role in roles
+    }
+
+
+def build(
+    *,
+    profile_path: Path,
+    m49_result_path: Path,
+    graph_frames_path: Path,
+    tgs_timing_path: Path,
+    vegetation_result_path: Path,
+    vegetation_frames_path: Path,
+    telemetry_path: Path,
+    output_path: Path,
+    release_sha256: str,
+) -> dict[str, object]:
+    if output_path.exists():
+        raise VegetationIntegratedError("integrated vegetation result already exists")
+    if len(release_sha256) != 64 or any(
+        character not in "0123456789abcdef" for character in release_sha256
+    ):
+        raise VegetationIntegratedError("release SHA-256 is invalid")
+    profile = load_json(profile_path, "integrated vegetation profile")
+    m49 = load_json(m49_result_path, "M49 integrated result")
+    vegetation = load_json(vegetation_result_path, "vegetation load result")
+    if profile.get("schema_version") != PROFILE_SCHEMA:
+        raise VegetationIntegratedError("integrated vegetation profile schema changed")
+    if m49.get("schema_version") != M49_SCHEMA:
+        raise VegetationIntegratedError("M49 integrated result schema changed")
+    if vegetation.get("schema_version") != VEGETATION_SCHEMA:
+        raise VegetationIntegratedError("vegetation load result schema changed")
+
+    source_rate_hz = float(profile["source"]["requested_source_rate_hz"])
+    inference_stride = int(profile["stages"]["vegetation"]["inference_stride"])
+    inference_phase_offset_ms = float(
+        profile["stages"]["vegetation"]["inference_phase_offset_ms"]
+    )
+    if (
+        not math.isfinite(source_rate_hz)
+        or source_rate_hz <= 0
+        or inference_stride <= 0
+        or not math.isfinite(inference_phase_offset_ms)
+        or inference_phase_offset_ms < 0
+        or inference_phase_offset_ms >= 1000.0 / source_rate_hz
+    ):
+        raise VegetationIntegratedError("vegetation multirate schedule is invalid")
+    graph_ages = graph_completion_ages(graph_frames_path)
+    tgs_ages = tgs_completion_ages(tgs_timing_path)
+    vegetation_frames = vegetation_frame_metrics(
+        vegetation_frames_path,
+        inference_stride=inference_stride,
+        inference_phase_offset_ms=inference_phase_offset_ms,
+        source_rate_hz=source_rate_hz,
+    )
+    vegetation_ages = vegetation_frames["completion_ages"]
+    assert isinstance(vegetation_ages, list)
+    combined_ages = [
+        max(graph, tgs, semantic)
+        for graph, tgs, semantic in zip(
+            graph_ages, tgs_ages, vegetation_ages, strict=True
+        )
+    ]
+    combined = distribution(combined_ages)
+    telemetry = host_telemetry(telemetry_path)
+    acceptance = profile["acceptance"]
+    vegetation_execution = vegetation.get("execution", {})
+    vegetation_timing = vegetation.get("timing", {})
+    vegetation_identity = vegetation.get("identity", {})
+    vegetation_candidate = vegetation.get("candidate", {})
+    m49_performance = m49.get("performance", {})
+    m49_accounting = m49.get("accounting", {})
+    checks = {
+        "base_m49_runtime_passed": (
+            m49.get("status") == "passed"
+            and m49.get("integrated_runtime_gate_passed") is True
+            and m49.get("identity", {}).get("profile_sha256")
+            == profile["stages"]["m49_graph_tgs"]["profile_sha256"]
+        ),
+        "vegetation_identity_frozen": (
+            vegetation_candidate.get("candidate_key") == "ddrnet"
+            and vegetation_candidate.get("checkpoint_sha256")
+            == profile["stages"]["vegetation"]["checkpoint_sha256"]
+            and vegetation_identity.get("config_sha256")
+            == profile["stages"]["vegetation"]["config_sha256"]
+            and vegetation_identity.get("policy_sha256")
+            == profile["stages"]["vegetation"]["policy_sha256"]
+            and vegetation_identity.get("provider_map_sha256")
+            == profile["stages"]["vegetation"]["provider_map_sha256"]
+        ),
+        "requested_source_rate_preserved": (
+            vegetation.get("source", {}).get("requested_source_rate_hz")
+            == profile["source"]["requested_source_rate_hz"]
+        ),
+        "vegetation_load_gate_passed": vegetation.get("integrated_load_gate_passed") is True,
+        "vegetation_multirate_schedule_frozen": (
+            vegetation_execution.get("inference_stride") == inference_stride
+            and vegetation_execution.get("inference_phase_offset_ms")
+            == inference_phase_offset_ms
+            and vegetation_execution.get("inference_frame_count")
+            == vegetation_frames["inference_count"]
+            and vegetation_execution.get("held_evidence_frame_count")
+            == vegetation_frames["held_count"]
+        ),
+        "exact_three_layer_sequence_join": len(combined_ages) == FRAME_COUNT,
+        "all_graph_frames_delivered": (
+            m49_accounting.get("graph_admitted") == FRAME_COUNT
+            and m49_accounting.get("graph_delivered") == FRAME_COUNT
+        ),
+        "all_tgs_frames_accounted": m49_accounting.get("tgs_timeline_frames")
+        == FRAME_COUNT,
+        "all_vegetation_frames_accounted": vegetation_execution.get("frame_count")
+        == FRAME_COUNT,
+        "minimum_graph_world_state_fps": float(
+            m49_performance.get("effective_world_state_fps", 0.0)
+        )
+        >= float(acceptance["minimum_graph_world_state_fps"]),
+        "minimum_vegetation_timeline_fps": float(
+            vegetation_execution.get("effective_timeline_fps", 0.0)
+        )
+        >= float(acceptance["minimum_vegetation_timeline_fps"]),
+        "minimum_vegetation_inference_fps": float(
+            vegetation_execution.get("effective_inference_fps", 0.0)
+        )
+        >= float(acceptance["minimum_vegetation_inference_fps"]),
+        "maximum_vegetation_inference_completion_p95_ms": float(
+            vegetation_timing.get("inference_completion_age_ms", {}).get(
+                "p95", math.inf
+            )
+        )
+        <= float(acceptance["maximum_vegetation_inference_completion_p95_ms"]),
+        "maximum_semantic_evidence_source_age_ms": max(
+            vegetation_frames["evidence_source_ages"]
+        )
+        <= float(acceptance["maximum_semantic_evidence_source_age_ms"]),
+        "maximum_combined_output_age_p99_ms": combined["p99"]
+        <= float(acceptance["maximum_combined_output_age_p99_ms"]),
+        "zero_capacity_drops": (
+            int(m49_accounting.get("tgs_capacity_drops", -1)) == 0
+            and int(vegetation_execution.get("capacity_drop_count", -1)) == 0
+        ),
+        "host_resource_telemetry_complete": all(
+            telemetry[role]["sample_count"] > 0
+            for role in ("graph", "tgs", "triton", "vegetation")
+        ),
+        "authority_remains_false": (
+            all(value is False for value in profile["authority"].values())
+            and all(value is False for value in vegetation.get("authority", {}).values())
+        ),
+    }
+    files = {
+        label: {"bytes": path.stat().st_size, "sha256": sha256_file(path)}
+        for label, path in (
+            ("m49-result.json", m49_result_path),
+            ("graph-frames.jsonl", graph_frames_path),
+            ("tgs-timing.tsv", tgs_timing_path),
+            ("vegetation-result.json", vegetation_result_path),
+            ("vegetation-frames.jsonl", vegetation_frames_path),
+            ("container-telemetry.jsonl", telemetry_path),
+        )
+    }
+    document: dict[str, object] = {
+        "schema_version": RESULT_SCHEMA,
+        "profile_id": profile["profile_id"],
+        "status": "passed" if all(checks.values()) else "failed",
+        "source": {
+            "source_id": profile["source"]["source_id"],
+            "requested_source_rate_hz": profile["source"]["requested_source_rate_hz"],
+            "joined_frame_count": len(combined_ages),
+            "ground_truth_available": False,
+        },
+        "identity": {
+            "release_sha256": release_sha256,
+            "profile_sha256": sha256_file(profile_path),
+            "m49_result_id": m49.get("result_id"),
+            "vegetation_result_id": vegetation.get("result_id"),
+        },
+        "performance": {
+            "graph_tgs": m49_performance,
+            "vegetation": {
+                "effective_timeline_fps": vegetation_execution.get(
+                    "effective_timeline_fps"
+                ),
+                "effective_inference_fps": vegetation_execution.get(
+                    "effective_inference_fps"
+                ),
+                "completion_age_ms": vegetation_timing.get("completion_age_ms"),
+                "inference_completion_age_ms": vegetation_timing.get(
+                    "inference_completion_age_ms"
+                ),
+                "semantic_evidence_source_age_ms": distribution(
+                    vegetation_frames["evidence_source_ages"]
+                ),
+                "stage_ms": vegetation_timing.get("stage_ms"),
+                "inference_ms": vegetation_timing.get("inference_ms"),
+                "resource": vegetation.get("resource"),
+            },
+            "three_layer_output_age_ms": combined,
+            "host_containers": telemetry,
+        },
+        "accounting": {
+            "graph_frames": m49_accounting.get("graph_delivered"),
+            "tgs_frames": m49_accounting.get("tgs_timeline_frames"),
+            "vegetation_frames": vegetation_execution.get("frame_count"),
+            "vegetation_inference_frames": vegetation_frames["inference_count"],
+            "vegetation_held_evidence_frames": vegetation_frames["held_count"],
+            "capacity_drop_count": int(m49_accounting.get("tgs_capacity_drops", 0))
+            + int(vegetation_execution.get("capacity_drop_count", 0)),
+        },
+        "checks": checks,
+        "integrated_runtime_gate_passed": all(checks.values()),
+        "visual_quality_accepted": False,
+        "route_truth_available": False,
+        "production_accepted": False,
+        "authority": profile["authority"],
+        "files": files,
+    }
+    identity = hashlib.sha256(canonical_json(document)).hexdigest()
+    document["result_id"] = f"lab-v1-vegetation-integrated-shadow-{identity}"
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    output_path.write_text(json.dumps(document, indent=2, sort_keys=True) + "\n", encoding="utf-8")
+    return document
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--profile", type=Path, required=True)
+    parser.add_argument("--m49-result", type=Path, required=True)
+    parser.add_argument("--graph-frames", type=Path, required=True)
+    parser.add_argument("--tgs-timing", type=Path, required=True)
+    parser.add_argument("--vegetation-result", type=Path, required=True)
+    parser.add_argument("--vegetation-frames", type=Path, required=True)
+    parser.add_argument("--telemetry", type=Path, required=True)
+    parser.add_argument("--output", type=Path, required=True)
+    parser.add_argument("--release-sha256", required=True)
+    arguments = parser.parse_args()
+    result = build(
+        profile_path=arguments.profile,
+        m49_result_path=arguments.m49_result,
+        graph_frames_path=arguments.graph_frames,
+        tgs_timing_path=arguments.tgs_timing,
+        vegetation_result_path=arguments.vegetation_result,
+        vegetation_frames_path=arguments.vegetation_frames,
+        telemetry_path=arguments.telemetry,
+        output_path=arguments.output,
+        release_sha256=arguments.release_sha256,
+    )
+    print(json.dumps({"result_id": result["result_id"], "status": result["status"]}))
+    return 0 if result["status"] == "passed" else 2
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

experiments/perception/worker/m49_t3_travel/prepare_mixed_route_tgs_inputs.py

@@ -0,0 +1,243 @@
+#!/usr/bin/env python3
+"""Prepare exact mixed-route LiDAR islands for isolated TRAVEL/TGS review."""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+from pathlib import Path
+
+import numpy as np
+from prepare_tgs_fail_closed_inputs import TgsInputError, gravity_local_xyzi
+
+CONFIG_SCHEMA = "missioncore.mixed-route-tgs-review-profile/v1"
+PACK_SCHEMA = "missioncore.mixed-route-lidar-pack/v1"
+INPUT_SCHEMA = "missioncore.mixed-route-tgs-input/v1"
+FRAME_COUNT = 10
+
+
+def sha256_file(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as stream:
+        for chunk in iter(lambda: stream.read(1024 * 1024), b""):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+def _slice(points: np.ndarray, offsets: np.ndarray, index: int) -> np.ndarray:
+    return points[int(offsets[index]) : int(offsets[index + 1])]
+
+
+def _validate_offsets(offsets: np.ndarray, point_count: int) -> bool:
+    return bool(
+        offsets.shape == (FRAME_COUNT + 1,)
+        and offsets.dtype == np.int64
+        and int(offsets[0]) == 0
+        and int(offsets[-1]) == point_count
+        and np.all(np.diff(offsets) > 0)
+    )
+
+
+def prepare(source_root: Path, config_path: Path, output_root: Path) -> dict[str, object]:
+    if output_root.exists():
+        raise TgsInputError("mixed-route TGS output already exists")
+    source = source_root.resolve(strict=True)
+    config = json.loads(config_path.read_text(encoding="utf-8"))
+    manifest = json.loads((source / "manifest.json").read_text(encoding="utf-8"))
+    identity = manifest.get("identity") if isinstance(manifest, dict) else None
+    artifact = manifest.get("artifact") if isinstance(manifest, dict) else None
+    source_config = config.get("source") if isinstance(config, dict) else None
+    invariants = config.get("invariants") if isinstance(config, dict) else None
+    profiles = config.get("profiles") if isinstance(config, dict) else None
+    if (
+        config.get("schema_version") != CONFIG_SCHEMA
+        or not isinstance(source_config, dict)
+        or not isinstance(invariants, dict)
+        or not isinstance(profiles, dict)
+        or set(profiles) != {"current_increment", "causal_rolling_1s"}
+        or source_config.get("input_coordinate_frame")
+        != "map-gravity-local-translation-only"
+        or invariants.get("lidar_orientation_applied_to_tgs_input") is not False
+        or invariants.get("future_frames_used") is not False
+        or invariants.get("navigation_or_actuation_allowed") is not False
+        or manifest.get("schema_version") != PACK_SCHEMA
+        or not isinstance(identity, dict)
+        or identity.get("schema_version") != PACK_SCHEMA
+        or identity.get("session_id") != source_config.get("session_id")
+        or identity.get("review_pack_id") != source_config.get("review_pack_id")
+        or manifest.get("pack_id") != source_config.get("source_pack_id")
+        or not isinstance(artifact, dict)
+        or artifact.get("path") != "lidar-pack.npz"
+        or artifact.get("sha256") != source_config.get("source_pack_sha256")
+        or identity.get("frame_count") != FRAME_COUNT
+        or identity.get("available_lidar_frames") != FRAME_COUNT
+        or identity.get("causal_history_seconds")
+        != float(profiles["causal_rolling_1s"]["history_seconds"])
+        or identity.get("ground_truth") is not False
+    ):
+        raise TgsInputError("mixed-route TGS source contract changed")
+    pack_path = source / "lidar-pack.npz"
+    if (
+        not pack_path.is_file()
+        or pack_path.stat().st_size != artifact.get("byte_length")
+        or sha256_file(pack_path) != artifact.get("sha256")
+    ):
+        raise TgsInputError("mixed-route LiDAR pack changed")
+
+    required = {
+        "frame_indices",
+        "source_frame_indices",
+        "session_seconds",
+        "lidar_session_seconds",
+        "sample_available",
+        "cloud_offsets",
+        "cloud_points_map",
+        "pose_positions_map",
+        "lidar_camera_delta_ms",
+        "pose_point_delta_ms",
+        "causal_history_seconds",
+        "causal_history_offsets",
+        "causal_history_points_map",
+    }
+    with np.load(pack_path, allow_pickle=False) as archive:
+        if not required.issubset(archive.files):
+            raise TgsInputError("mixed-route LiDAR pack members changed")
+        arrays = {name: archive[name] for name in required}
+    current_points = arrays["cloud_points_map"]
+    history_points = arrays["causal_history_points_map"]
+    if (
+        arrays["frame_indices"].shape != (FRAME_COUNT,)
+        or arrays["frame_indices"].dtype != np.int64
+        or not np.array_equal(arrays["frame_indices"], np.arange(FRAME_COUNT))
+        or arrays["source_frame_indices"].shape != (FRAME_COUNT,)
+        or arrays["source_frame_indices"].dtype != np.int64
+        or np.any(np.diff(arrays["source_frame_indices"]) <= 0)
+        or arrays["session_seconds"].shape != (FRAME_COUNT,)
+        or arrays["session_seconds"].dtype != np.float64
+        or np.any(np.diff(arrays["session_seconds"]) <= 0)
+        or arrays["lidar_session_seconds"].shape != (FRAME_COUNT,)
+        or arrays["lidar_session_seconds"].dtype != np.float64
+        or arrays["sample_available"].shape != (FRAME_COUNT,)
+        or arrays["sample_available"].dtype != np.bool_
+        or not arrays["sample_available"].all()
+        or current_points.ndim != 2
+        or current_points.shape[1:] != (3,)
+        or current_points.dtype != np.float32
+        or history_points.ndim != 2
+        or history_points.shape[1:] != (3,)
+        or history_points.dtype != np.float32
+        or not np.isfinite(current_points).all()
+        or not np.isfinite(history_points).all()
+        or not _validate_offsets(arrays["cloud_offsets"], current_points.shape[0])
+        or not _validate_offsets(
+            arrays["causal_history_offsets"], history_points.shape[0]
+        )
+        or arrays["pose_positions_map"].shape != (FRAME_COUNT, 3)
+        or arrays["pose_positions_map"].dtype != np.float64
+        or not np.isfinite(arrays["pose_positions_map"]).all()
+        or arrays["causal_history_seconds"].shape != (1,)
+        or float(arrays["causal_history_seconds"][0])
+        != float(profiles["causal_rolling_1s"]["history_seconds"])
+        or np.any(np.abs(arrays["lidar_camera_delta_ms"]) > 100.0)
+        or np.any(np.abs(arrays["pose_point_delta_ms"]) > 100.0)
+    ):
+        raise TgsInputError("mixed-route LiDAR arrays changed")
+
+    records: list[dict[str, object]] = []
+    for profile_id in ("current_increment", "causal_rolling_1s"):
+        for slot in range(FRAME_COUNT):
+            if profile_id == "current_increment":
+                points_map = _slice(
+                    current_points, arrays["cloud_offsets"], slot
+                )
+            else:
+                points_map = _slice(
+                    history_points, arrays["causal_history_offsets"], slot
+                )
+                radius = float(profiles[profile_id]["local_radius_m"])
+                relative_xy = (
+                    points_map[:, :2].astype(np.float64)
+                    - arrays["pose_positions_map"][slot, :2]
+                )
+                points_map = points_map[np.linalg.norm(relative_xy, axis=1) <= radius]
+            native = gravity_local_xyzi(
+                points_map, arrays["pose_positions_map"][slot]
+            )
+            if native.shape[0] == 0:
+                raise TgsInputError("mixed-route TGS profile produced an empty cloud")
+            target = (
+                output_root
+                / "profiles"
+                / profile_id
+                / "velodyne"
+                / f"{slot:06d}.bin"
+            )
+            target.parent.mkdir(parents=True, exist_ok=True)
+            target.write_bytes(np.ascontiguousarray(native).tobytes())
+            records.append(
+                {
+                    "profile_id": profile_id,
+                    "slot": slot,
+                    "frame_index": slot,
+                    "source_frame_index": int(
+                        arrays["source_frame_indices"][slot]
+                    ),
+                    "source_sequence": int(
+                        arrays["source_frame_indices"][slot]
+                    )
+                    + 1,
+                    "session_seconds": float(arrays["session_seconds"][slot]),
+                    "lidar_session_seconds": float(
+                        arrays["lidar_session_seconds"][slot]
+                    ),
+                    "lidar_camera_delta_ms": float(
+                        arrays["lidar_camera_delta_ms"][slot]
+                    ),
+                    "pose_point_delta_ms": float(
+                        arrays["pose_point_delta_ms"][slot]
+                    ),
+                    "point_count": int(native.shape[0]),
+                    "relative_path": target.relative_to(output_root).as_posix(),
+                    "bytes": target.stat().st_size,
+                    "sha256": sha256_file(target),
+                }
+            )
+    manifest_out = {
+        "schema_version": INPUT_SCHEMA,
+        "source_pack_id": manifest["pack_id"],
+        "source_pack_sha256": artifact["sha256"],
+        "config_sha256": sha256_file(config_path),
+        "coordinate_frame": "map-gravity-local",
+        "transform": "translation-only-preserve-map-gravity-axis",
+        "intensity_policy": "zero-filled-algorithm-compatibility-only",
+        "future_frames_used": False,
+        "frame_count": FRAME_COUNT,
+        "profile_count": 2,
+        "records": records,
+        "authority": {
+            "navigation_or_safety_accepted": False,
+            "actuation_allowed": False,
+        },
+    }
+    manifest_path = output_root / "input-manifest.json"
+    manifest_path.write_text(
+        json.dumps(manifest_out, indent=2, sort_keys=True) + "\n",
+        encoding="utf-8",
+    )
+    return manifest_out
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--source-root", type=Path, required=True)
+    parser.add_argument("--config", type=Path, required=True)
+    parser.add_argument("--output-root", type=Path, required=True)
+    args = parser.parse_args()
+    manifest = prepare(args.source_root, args.config, args.output_root)
+    print(json.dumps({"ok": True, "records": len(manifest["records"])}, sort_keys=True))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

experiments/perception/worker/m49_t3_travel/run_tgs_integrated_shadow.sh

@@ -5,6 +5,9 @@ readonly BINARY=/shared/bin/run_tgs_full_shadow
 readonly INPUT_ROOT=/shared/tgs/inputs
 readonly OUTPUT_ROOT=/shared/tgs/outputs/causal_rolling_1s
 readonly TIMING_PATH=/shared/tgs/tgs-full-timing.tsv
+readonly RUNTIME_ROOT=/tmp/m49-tgs-runtime
+readonly RUNTIME_OUTPUT_ROOT=${RUNTIME_ROOT}/outputs
+readonly RUNTIME_TIMING_PATH=${RUNTIME_ROOT}/tgs-full-timing.tsv
 readonly READY_FILE=/shared/control/tgs.ready
 readonly START_FILE=/shared/control/start.signal
 readonly SOURCE_RATE_HZ=${M49_SOURCE_RATE_HZ:-12.0}
@@ -15,12 +18,20 @@ test -f "${INPUT_ROOT}/schedule.tsv"
 test ! -e /shared/tgs/outputs
 test ! -e "${TIMING_PATH}"
 test ! -e "${READY_FILE}"
-mkdir -p "${OUTPUT_ROOT}"
-exec /usr/bin/time -v "${BINARY}" \
+test ! -e "${RUNTIME_ROOT}"
+mkdir -p "${RUNTIME_OUTPUT_ROOT}"
+/usr/bin/time -v "${BINARY}" \
   "${INPUT_ROOT}/profiles/causal_rolling_1s" \
   "${INPUT_ROOT}/schedule.tsv" \
-  "${OUTPUT_ROOT}" \
-  "${TIMING_PATH}" \
+  "${RUNTIME_OUTPUT_ROOT}" \
+  "${RUNTIME_TIMING_PATH}" \
   "${SOURCE_RATE_HZ}" \
   "${READY_FILE}" \
   "${START_FILE}"
+test -f "${RUNTIME_TIMING_PATH}"
+mkdir -p "${OUTPUT_ROOT}"
+copy_started=$(date +%s%N)
+cp -R "${RUNTIME_OUTPUT_ROOT}/." "${OUTPUT_ROOT}/"
+cp "${RUNTIME_TIMING_PATH}" "${TIMING_PATH}"
+copy_completed=$(date +%s%N)
+echo "[TGS-FULL] evidence_copy_ms=$(((copy_completed - copy_started) / 1000000))"

scripts/build_lab_v1_vegetation_integrated_worker_artifact.py

@@ -0,0 +1,189 @@
+#!/usr/bin/env python3
+"""Build a clean-revision Worker 006 release for the DDRNet + M49 load gate."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import re
+import subprocess
+import sys
+import tempfile
+from pathlib import Path
+
+SCRIPT_ROOT = Path(__file__).resolve().parent
+if str(SCRIPT_ROOT) not in sys.path:
+    sys.path.insert(0, str(SCRIPT_ROOT))
+
+from build_m49_tgs_integrated_graph_worker_artifact import (  # noqa: E402
+    PATCH_ID,
+    REPOSITORY_ROOT,
+    WHEEL_NAME,
+    ArtifactBuildError,
+    build_wheel,
+    git_revision,
+    materialize_revision,
+    sha256_file,
+    write_archive,
+)
+from build_m49_tgs_integrated_graph_worker_artifact import (  # noqa: E402
+    SOURCES as M49_SOURCES,
+)
+
+SOURCES = M49_SOURCES + (
+    Path(
+        "experiments/perception/worker/lab_v1_vegetation_goose/"
+        "run_goose_vegetation_benchmark.py"
+    ),
+    Path(
+        "experiments/perception/worker/lab_v1_vegetation_goose/"
+        "run_vegetation_integrated_load.py"
+    ),
+    Path(
+        "experiments/perception/worker/m49_t3_travel/"
+        "build_vegetation_integrated_graph_evidence.py"
+    ),
+    Path("config/perception/lab-v1-goose-vegetation-benchmark-v1.json"),
+    Path("config/perception/lab-v1-vegetation-mission-policy-v1.json"),
+    Path("config/perception/lab-v1-vegetation-provider-label-map-v1.json"),
+    Path("config/perception/lab-v1-vegetation-integrated-multirate-phased-shadow-v3.json"),
+)
+
+
+def build_artifact(
+    patch_id: str,
+    output_directory: Path,
+    *,
+    revision: str | None = None,
+    source_root: Path | None = None,
+) -> dict[str, object]:
+    if PATCH_ID.fullmatch(patch_id) is None:
+        raise ArtifactBuildError("patch id is invalid")
+    selected_revision = revision or git_revision()
+    if re.fullmatch(r"[a-f0-9]{40}", selected_revision) is None:
+        raise ArtifactBuildError("artifact revision is invalid")
+    with tempfile.TemporaryDirectory(prefix="mission-core-vegetation-integrated-") as directory:
+        stage = Path(directory)
+        snapshot = source_root
+        if snapshot is None:
+            snapshot = stage / "source"
+            materialize_revision(selected_revision, snapshot)
+        sources = tuple(snapshot / relative for relative in SOURCES)
+        if any(path.is_symlink() or not path.is_file() for path in sources):
+            raise ArtifactBuildError("release input is not a regular file")
+        payload = stage / "payload"
+        payload.mkdir()
+        wheel = build_wheel(snapshot, stage / "wheel")
+        copied: list[Path] = []
+        for source in sources:
+            destination = payload / source.name
+            if destination.exists():
+                raise ArtifactBuildError("release payload file names are not unique")
+            destination.write_bytes(source.read_bytes())
+            copied.append(destination)
+        wheel_destination = payload / WHEEL_NAME
+        wheel_destination.write_bytes(wheel.read_bytes())
+        copied.append(wheel_destination)
+        release = {
+            "schema_version": "missioncore.lab-v1-vegetation-integrated-worker-release/v3",
+            "patch_id": patch_id,
+            "transition": "lab-v1-vegetation-m49-integrated-multirate-phased-shadow/v3",
+            "code_revision": selected_revision,
+            "worker_id": "worker-006",
+            "source_pack_sha256": (
+                "0685d24219d8236caf8b7f1685e93f6d6b59e7fd015a768d88a92bbe8b154944"
+            ),
+            "video_sha256": (
+                "cadd1696ff000904eb78633a0a8418104b8024f178b91f3421789021ccb160e8"
+            ),
+            "expected_frames": 4489,
+            "requested_source_rate_hz": 12.0,
+            "semantic_inference_rate_hz": 6.0,
+            "semantic_inference_stride": 2,
+            "semantic_inference_phase_offset_ms": 40.0,
+            "native_engine_sha256": (
+                "b8a40b3580edff001ec9680de68707242294ff590ab296000fae371f1083f695"
+            ),
+            "ddrnet_checkpoint_sha256": (
+                "b99c2838051bcd7b092fd3970aa62a77d5c0bbb809c9b9afb2ff4b0ebdaa4ee6"
+            ),
+            "images": {
+                "travel": (
+                    "sha256:7b412020f4d8392d1d1ed1b33beadc44140f0ea8f781e62dd69796042334300f"
+                ),
+                "parity": (
+                    "sha256:ceb13548617e4bd3f619766bfdff00af3fa5160946b367828da6d2233dcdcba0"
+                ),
+                "runtime": (
+                    "sha256:58df7489c3f2276f9591d500a012dee03e23d35543ce3c390b4c001e6bf90794"
+                ),
+                "vegetation": (
+                    "sha256:591cb382c099eeb05e7ec16e2371e0b2da54d2bb5c49ec0f4ac88dbf72b0f0cd"
+                ),
+            },
+            "authority": {
+                "visual_quality_accepted": False,
+                "route_truth_available": False,
+                "traversability_accepted": False,
+                "physical_free_space_accepted": False,
+                "commands_enabled": False,
+                "actuation_allowed": False,
+                "navigation_or_safety_accepted": False,
+                "production_accepted": False,
+            },
+            "scope": {
+                "gauss_or_playcanvas_action": "none",
+                "durable_worker_action": "none",
+                "canonical_triton_action": "none",
+                "heavy_vegetation_candidates": ["ddrnet"],
+            },
+            "files": {
+                path.name: {"sha256": sha256_file(path), "bytes": path.stat().st_size}
+                for path in sorted(copied)
+            },
+        }
+        release_path = payload / "release.json"
+        release_path.write_text(
+            json.dumps(release, indent=2, sort_keys=True) + "\n", encoding="utf-8"
+        )
+        payload_files = sorted((*release["files"], release_path.name))
+        (stage / "manifest.env").write_text(
+            f"id={patch_id}\ncomponent=mission-core-worker\ntype=shadow-release\n",
+            encoding="utf-8",
+        )
+        (stage / "files.txt").write_text(
+            "\n".join(payload_files) + "\n", encoding="utf-8"
+        )
+        target = output_directory.resolve() / f"nodedc-{patch_id}.tgz"
+        write_archive(stage, target)
+    return {
+        "ok": True,
+        "patch_id": patch_id,
+        "artifact": str(target),
+        "sha256": sha256_file(target),
+        "code_revision": selected_revision,
+        "wheel_sha256": release["files"][WHEEL_NAME]["sha256"],
+        "payload_files": payload_files,
+        "transition": release["transition"],
+    }
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("patch_id")
+    parser.add_argument(
+        "--output-directory",
+        type=Path,
+        default=REPOSITORY_ROOT / ".runtime/worker-artifacts",
+    )
+    arguments = parser.parse_args()
+    try:
+        result = build_artifact(arguments.patch_id, arguments.output_directory)
+    except (ArtifactBuildError, OSError, subprocess.SubprocessError) as exc:
+        parser.error(str(exc))
+    print(json.dumps(result, indent=2, sort_keys=True))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

scripts/prepare_mixed_route_review_pack.py

@@ -0,0 +1,296 @@
+#!/usr/bin/env python3
+"""Publish exact, independently decodable camera islands for mixed-route review."""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import os
+import shutil
+import subprocess
+import tempfile
+from datetime import UTC, datetime
+from pathlib import Path
+from typing import Any
+
+from PIL import Image
+
+from k1link.compute.jobs import validate_camera_compute_job
+from k1link.device_plugins.xgrids_k1.mqtt.capture import read_capture_clock_origin
+
+SCHEMA = "missioncore.mixed-route-review-pack/v1"
+MAX_INDEX_LINE_BYTES = 64 * 1024
+
+
+class MixedRouteReviewPackError(RuntimeError):
+    """The selected camera evidence cannot be published without ambiguity."""
+
+
+def _canonical_json(value: object) -> bytes:
+    return json.dumps(
+        value,
+        ensure_ascii=False,
+        sort_keys=True,
+        separators=(",", ":"),
+        allow_nan=False,
+    ).encode("utf-8")
+
+
+def _sha256(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as stream:
+        for chunk in iter(lambda: stream.read(1024 * 1024), b""):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+def _sequences(value: str) -> tuple[int, ...]:
+    try:
+        sequences = tuple(int(item) for item in value.split(","))
+    except ValueError as exc:
+        raise argparse.ArgumentTypeError("sequences must be comma-separated integers") from exc
+    if not sequences or any(item < 1 for item in sequences):
+        raise argparse.ArgumentTypeError("sequences must be positive")
+    if len(set(sequences)) != len(sequences) or tuple(sorted(sequences)) != sequences:
+        raise argparse.ArgumentTypeError("sequences must be unique and increasing")
+    return sequences
+
+
+def _arguments() -> argparse.Namespace:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--job", type=Path, required=True)
+    parser.add_argument("--session", type=Path, required=True)
+    parser.add_argument("--sequences", type=_sequences, required=True)
+    parser.add_argument("--output-root", type=Path, required=True)
+    parser.add_argument("--ffmpeg", type=Path, required=True)
+    return parser.parse_args()
+
+
+def _read_selected_index(
+    path: Path,
+    sequences: tuple[int, ...],
+) -> list[dict[str, Any]]:
+    wanted = set(sequences)
+    selected: dict[int, dict[str, Any]] = {}
+    with path.open("rb") as stream:
+        for expected_sequence, line in enumerate(stream, start=1):
+            if len(line) > MAX_INDEX_LINE_BYTES or not line.endswith(b"\n"):
+                raise MixedRouteReviewPackError("camera index line is invalid")
+            if expected_sequence not in wanted:
+                continue
+            try:
+                value = json.loads(line)
+            except json.JSONDecodeError as exc:
+                raise MixedRouteReviewPackError("camera index JSON is invalid") from exc
+            if (
+                not isinstance(value, dict)
+                or value.get("schema_version")
+                != "missioncore.camera-recording-index/v1"
+                or value.get("kind") != "media"
+                or value.get("sequence") != expected_sequence
+                or value.get("path") != f"segments/{expected_sequence}.m4s"
+                or not isinstance(value.get("session_monotonic_ns"), int)
+                or not isinstance(value.get("host_monotonic_ns"), int)
+                or not isinstance(value.get("host_epoch_ns"), int)
+            ):
+                raise MixedRouteReviewPackError("selected camera index row changed")
+            selected[expected_sequence] = value
+    if tuple(sorted(selected)) != sequences:
+        raise MixedRouteReviewPackError("selected camera sequence is incomplete")
+    return [selected[sequence] for sequence in sequences]
+
+
+def _decode_exact_fragment(
+    *,
+    ffmpeg: Path,
+    init_path: Path,
+    segment_path: Path,
+    output_path: Path,
+) -> None:
+    input_value = f"concat:{init_path}|{segment_path}"
+    completed = subprocess.run(
+        [
+            os.fspath(ffmpeg),
+            "-hide_banner",
+            "-loglevel",
+            "error",
+            "-nostdin",
+            "-y",
+            "-i",
+            input_value,
+            "-frames:v",
+            "1",
+            os.fspath(output_path),
+        ],
+        capture_output=True,
+        text=True,
+        timeout=30,
+        check=False,
+    )
+    if completed.returncode != 0 or not output_path.is_file():
+        detail = completed.stderr.strip().splitlines()[-1:] or ["no decoded frame"]
+        raise MixedRouteReviewPackError(
+            f"selected fragment is not independently decodable: {segment_path.name}: {detail[0]}"
+        )
+    with Image.open(output_path) as image:
+        if image.mode != "RGB" or image.size != (800, 600):
+            raise MixedRouteReviewPackError("selected camera frame shape changed")
+
+
+def prepare(
+    *,
+    job_root: Path,
+    session_root: Path,
+    sequences: tuple[int, ...],
+    output_root: Path,
+    ffmpeg_path: Path,
+) -> Path:
+    job = validate_camera_compute_job(job_root)
+    session = session_root.resolve(strict=True)
+    if not session.is_dir() or session.name != job.session_id:
+        raise MixedRouteReviewPackError("camera job and observation session differ")
+    capture_root = session / "captures" / "mqtt_live"
+    origin_path = capture_root / "mqtt.timeline.origin.json"
+    origin = read_capture_clock_origin(origin_path)
+    if sequences[-1] > job.segment_count:
+        raise MixedRouteReviewPackError("selected sequence escapes the camera epoch")
+    ffmpeg = ffmpeg_path.resolve(strict=True)
+    if not ffmpeg.is_file():
+        raise MixedRouteReviewPackError("ffmpeg is unavailable")
+    epoch_root = (
+        job.job_root
+        / "input"
+        / "camera"
+        / job.source_id
+        / f"epoch-{job.codec_epoch}"
+    )
+    selected = _read_selected_index(epoch_root / "index.jsonl", sequences)
+    identity = {
+        "schema_version": SCHEMA,
+        "job_id": job.job_id,
+        "input_sha256": job.input_sha256,
+        "session_id": job.session_id,
+        "source_id": job.source_id,
+        "codec_epoch": job.codec_epoch,
+        "clock_origin": {
+            "artifact_sha256": _sha256(origin_path),
+            "started_epoch_ns": origin.started_at_epoch_ns,
+            "started_monotonic_ns": origin.started_monotonic_ns,
+        },
+        "selected_sequences": list(sequences),
+        "selection_policy": "exact-independently-decodable-fragments/v1",
+        "ground_truth": False,
+        "authority": {
+            "navigation_or_safety_accepted": False,
+            "actuation_allowed": False,
+        },
+        "producer_sha256": _sha256(Path(__file__).resolve(strict=True)),
+    }
+    identity_sha256 = hashlib.sha256(_canonical_json(identity)).hexdigest()
+    pack_id = f"mixed-route-review-pack-{identity_sha256}"
+    parent = output_root.resolve()
+    parent.mkdir(mode=0o700, parents=True, exist_ok=True)
+    final = parent / pack_id
+    if final.exists():
+        return final
+    staging = Path(tempfile.mkdtemp(prefix=f".{pack_id}.", dir=parent))
+    published = False
+    try:
+        frames_root = staging / "frames"
+        frames_root.mkdir(mode=0o700)
+        timeline_rows: list[dict[str, Any]] = []
+        artifacts: list[dict[str, Any]] = []
+        for frame_index, (sequence, row) in enumerate(
+            zip(sequences, selected, strict=True)
+        ):
+            output_path = frames_root / f"frame-{frame_index + 1:06d}.png"
+            segment_path = epoch_root / "segments" / f"{sequence}.m4s"
+            _decode_exact_fragment(
+                ffmpeg=ffmpeg,
+                init_path=epoch_root / "init.mp4",
+                segment_path=segment_path,
+                output_path=output_path,
+            )
+            host_monotonic_ns = int(row["host_monotonic_ns"])
+            if host_monotonic_ns < origin.started_monotonic_ns:
+                raise MixedRouteReviewPackError("selected frame predates the session clock origin")
+            session_seconds = (
+                host_monotonic_ns - origin.started_monotonic_ns
+            ) / 1e9
+            timeline_rows.append(
+                {
+                    "frame_index": frame_index,
+                    "sequence": frame_index + 1,
+                    "source_frame_index": sequence - 1,
+                    "source_sequence": sequence,
+                    "session_seconds": session_seconds,
+                    "host_monotonic_ns": row["host_monotonic_ns"],
+                    "host_epoch_ns": row["host_epoch_ns"],
+                }
+            )
+            artifacts.append(
+                {
+                    "path": output_path.relative_to(staging).as_posix(),
+                    "byte_length": output_path.stat().st_size,
+                    "sha256": _sha256(output_path),
+                    "source_segment_sha256": row["sha256"],
+                }
+            )
+        timeline_path = staging / "timeline.jsonl"
+        timeline_path.write_text(
+            "".join(
+                json.dumps(
+                    row,
+                    ensure_ascii=False,
+                    sort_keys=True,
+                    separators=(",", ":"),
+                )
+                + "\n"
+                for row in timeline_rows
+            ),
+            encoding="utf-8",
+        )
+        manifest = {
+            "schema_version": SCHEMA,
+            "pack_id": pack_id,
+            "identity_sha256": identity_sha256,
+            "identity": identity,
+            "created_at_utc": datetime.now(UTC)
+            .isoformat(timespec="milliseconds")
+            .replace("+00:00", "Z"),
+            "frame_count": len(sequences),
+            "timeline": {
+                "path": timeline_path.name,
+                "byte_length": timeline_path.stat().st_size,
+                "sha256": _sha256(timeline_path),
+            },
+            "frames": artifacts,
+        }
+        (staging / "manifest.json").write_text(
+            json.dumps(manifest, ensure_ascii=False, sort_keys=True, indent=2) + "\n",
+            encoding="utf-8",
+        )
+        os.replace(staging, final)
+        published = True
+    finally:
+        if not published:
+            shutil.rmtree(staging, ignore_errors=True)
+    return final
+
+
+def main() -> int:
+    args = _arguments()
+    result = prepare(
+        job_root=args.job,
+        session_root=args.session,
+        sequences=args.sequences,
+        output_root=args.output_root,
+        ffmpeg_path=args.ffmpeg,
+    )
+    print(json.dumps({"pack_id": result.name, "output": os.fspath(result)}, sort_keys=True))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

scripts/seal_mixed_route_full_video_review.py

@@ -0,0 +1,38 @@
+#!/usr/bin/env python3
+"""Seal the complete RAVNOVES004TREE semantic pass into existing LAB V1."""
+
+from __future__ import annotations
+
+import argparse
+from pathlib import Path
+
+from k1link.laboratory.mixed_route_vegetation_review import (
+    seal_mixed_route_full_video_review,
+)
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--base-lab-root", type=Path, required=True)
+    parser.add_argument("--job-root", type=Path, required=True)
+    parser.add_argument("--recorded-media-preparation", type=Path, required=True)
+    parser.add_argument("--eomt-root", type=Path, required=True)
+    parser.add_argument("--eomt-profile", type=Path, required=True)
+    parser.add_argument("--ddrnet-root", type=Path, required=True)
+    parser.add_argument("--output-root", type=Path, required=True)
+    args = parser.parse_args()
+    print(
+        seal_mixed_route_full_video_review(
+            base_lab_root=args.base_lab_root,
+            job_root=args.job_root,
+            recorded_media_preparation_path=args.recorded_media_preparation,
+            eomt_root=args.eomt_root,
+            eomt_profile_path=args.eomt_profile,
+            ddrnet_root=args.ddrnet_root,
+            output_root=args.output_root,
+        )
+    )
+
+
+if __name__ == "__main__":
+    main()

src/k1link/laboratory/mixed_route_vegetation_review.py

@@ -0,0 +1,901 @@
+"""Seal RAVNOVES004TREE mixed-route review into the existing vegetation LAB."""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import os
+import shutil
+import struct
+import tarfile
+import tempfile
+import zipfile
+from datetime import UTC, datetime
+from pathlib import Path
+from typing import Any
+
+import numpy as np
+from PIL import Image, ImageDraw
+
+from k1link.compute.jobs import validate_camera_compute_job
+
+from k1link.laboratory.vegetation_shadow_lab import (
+    LAB_SCHEMA,
+    RESULT_PREFIX,
+    VegetationShadowLabError,
+    canonical_json,
+    sha256_path,
+)
+
+REVIEW_SCHEMA = "missioncore.mixed-route-review-pack/v1"
+DDRNET_SCHEMA = "missioncore.mixed-route-ddrnet-islands/v1"
+TGS_SCHEMA = "missioncore.mixed-route-tgs-result/v1"
+FRAME_COUNT = 10
+PHASES = (
+    "rural",
+    "rural",
+    "rural",
+    "rural",
+    "rural",
+    "transition",
+    "urban",
+    "urban",
+    "urban",
+    "urban",
+)
+TGS_COLORS = {
+    0: (5, 7, 9),
+    1: (132, 188, 86),
+    2: (235, 112, 122),
+    3: (150, 154, 163),
+}
+FULL_ROUTE_SOURCE_ID = "RAVNOVES004TREE"
+FULL_ROUTE_FRAME_COUNT = 6830
+FULL_ROUTE_JOB_ID = "recorded-camera-eb2783c5480d56bda07c8af0"
+FULL_ROUTE_INPUT_SHA256 = (
+    "eb2783c5480d56bda07c8af008dff5344d19dc550ef70fe2075d6f098f7cc715"
+)
+FULL_ROUTE_STREAM_SHA256 = (
+    "e5eb017e2cc0f546736eda5235ca157b501913093cb64af5e548e335417e1bac"
+)
+
+
+def _read_json(path: Path, label: str) -> dict[str, Any]:
+    try:
+        value = json.loads(path.read_text(encoding="utf-8-sig"))
+    except (OSError, json.JSONDecodeError) as exc:
+        raise VegetationShadowLabError(f"{label} is invalid") from exc
+    if not isinstance(value, dict):
+        raise VegetationShadowLabError(f"{label} must be an object")
+    return value
+
+
+def _artifact(
+    source: Path,
+    staging: Path,
+    relative: str,
+    artifacts: list[dict[str, object]],
+    *,
+    role: str,
+    media_type: str,
+) -> dict[str, object]:
+    if source.is_symlink() or not source.is_file():
+        raise VegetationShadowLabError(f"mixed-route artifact is unavailable: {relative}")
+    target = staging / relative
+    target.parent.mkdir(mode=0o700, parents=True, exist_ok=True)
+    shutil.copyfile(source, target)
+    descriptor = {
+        "role": role,
+        "path": relative,
+        "byte_length": target.stat().st_size,
+        "sha256": sha256_path(target),
+        "media_type": media_type,
+    }
+    artifacts.append(descriptor)
+    return descriptor
+
+
+def _image_proof(descriptor: dict[str, object]) -> dict[str, object]:
+    return {"path": descriptor["path"], "sha256": descriptor["sha256"]}
+
+
+def _mask_archive_descriptor(
+    path: Path,
+    relative: str,
+    artifacts: list[dict[str, object]],
+    *,
+    role: str,
+) -> dict[str, object]:
+    descriptor = {
+        "role": role,
+        "path": relative,
+        "byte_length": path.stat().st_size,
+        "sha256": sha256_path(path),
+        "media_type": "application/zip",
+    }
+    artifacts.append(descriptor)
+    return descriptor
+
+
+def _repack_eomt_masks(source: Path, destination: Path, frame_count: int) -> None:
+    destination.parent.mkdir(mode=0o700, parents=True, exist_ok=True)
+    expected = [f"semantic-masks/frame-{sequence + 1:06d}.png" for sequence in range(frame_count)]
+    try:
+        with (
+            tarfile.open(source, mode="r:gz") as archive,
+            zipfile.ZipFile(
+                destination,
+                mode="x",
+                compression=zipfile.ZIP_STORED,
+                allowZip64=True,
+            ) as output,
+        ):
+            members = [member for member in archive.getmembers() if member.isfile()]
+            if [member.name.removeprefix("./") for member in members] != expected:
+                raise VegetationShadowLabError("full-route EoMT mask sequence changed")
+            for member, expected_name in zip(members, expected, strict=True):
+                if member.size < 8 or member.size > 1024 * 1024:
+                    raise VegetationShadowLabError("full-route EoMT mask size changed")
+                stream = archive.extractfile(member)
+                if stream is None:
+                    raise VegetationShadowLabError("full-route EoMT mask is unavailable")
+                output.writestr(
+                    f"masks/{Path(expected_name).name}",
+                    stream.read(),
+                )
+    except (OSError, tarfile.TarError, zipfile.BadZipFile) as exc:
+        destination.unlink(missing_ok=True)
+        raise VegetationShadowLabError("full-route EoMT archive is invalid") from exc
+
+
+def _validate_zip_masks(path: Path, frame_count: int) -> None:
+    expected = [f"masks/frame-{sequence + 1:06d}.png" for sequence in range(frame_count)]
+    try:
+        with zipfile.ZipFile(path) as archive:
+            members = archive.infolist()
+            if (
+                [member.filename for member in members] != expected
+                or any(
+                    member.is_dir() or member.file_size < 8 or member.file_size > 1024 * 1024
+                    for member in members
+                )
+            ):
+                raise VegetationShadowLabError("full-route semantic mask sequence changed")
+    except (OSError, zipfile.BadZipFile) as exc:
+        raise VegetationShadowLabError("full-route semantic archive is invalid") from exc
+
+
+def _full_route_frame_times(media: dict[str, Any], frame_count: int) -> list[int]:
+    epochs = media.get("epochs")
+    start = media.get("timeline_start_seconds")
+    end = media.get("timeline_end_seconds")
+    if (
+        not isinstance(epochs, list)
+        or len(epochs) != 1
+        or not isinstance(start, (int, float))
+        or not isinstance(end, (int, float))
+    ):
+        raise VegetationShadowLabError("recorded media timeline changed")
+    epoch = epochs[0]
+    segments = epoch.get("segments") if isinstance(epoch, dict) else None
+    if not isinstance(segments, list) or len(segments) != frame_count:
+        raise VegetationShadowLabError("recorded media segment count changed")
+    starts = [float(start)]
+    previous_end = 0.0
+    for sequence, raw in enumerate(segments, start=1):
+        if (
+            not isinstance(raw, dict)
+            or raw.get("sequence") != sequence
+            or not isinstance(raw.get("end_time_seconds"), (int, float))
+            or float(raw["end_time_seconds"]) <= previous_end
+        ):
+            raise VegetationShadowLabError("recorded media segment timeline changed")
+        if sequence < frame_count:
+            starts.append(float(start) + float(raw["end_time_seconds"]))
+        previous_end = float(raw["end_time_seconds"])
+    if abs((float(start) + previous_end) - float(end)) > 0.001:
+        raise VegetationShadowLabError("recorded media duration changed")
+    return [round(value * 1_000_000_000) for value in starts]
+
+
+def _eomt_taxonomy(profile: dict[str, Any]) -> dict[str, object]:
+    taxonomy = profile.get("target_taxonomy")
+    if not isinstance(taxonomy, dict) or set(taxonomy) != {str(index) for index in range(16)}:
+        raise VegetationShadowLabError("EoMT target taxonomy changed")
+    classes = []
+    for class_id in range(16):
+        digest = hashlib.sha256(f"mission-core-segment-{class_id}".encode()).digest()
+        classes.append(
+            {
+                "class_id": class_id,
+                "label": taxonomy[str(class_id)],
+                "color_rgb": [64 + digest[index] % 176 for index in range(3)],
+                "disposition": "undefined" if class_id == 0 else "prediction",
+            }
+        )
+    return {
+        "schema_version": "missioncore.recorded-eomt-taxonomy/v1",
+        "classes": classes,
+    }
+
+
+def _render_tgs_costmaps(tgs_root: Path, destination: Path) -> list[Path]:
+    result = _read_json(tgs_root / "result.json", "mixed-route TGS result")
+    evidence = result.get("evidence")
+    costmap = result.get("costmap")
+    if (
+        result.get("schema_version") != TGS_SCHEMA
+        or result.get("status") != "passed-review-only"
+        or not isinstance(evidence, dict)
+        or not isinstance(costmap, dict)
+        or result.get("summary", {}).get("frame_count") != FRAME_COUNT
+        or result.get("authority", {}).get("actuation_allowed") is not False
+    ):
+        raise VegetationShadowLabError("mixed-route TGS contract changed")
+    evidence_path = tgs_root / str(evidence.get("path"))
+    if (
+        not evidence_path.is_file()
+        or evidence.get("bytes") != evidence_path.stat().st_size
+        or evidence.get("sha256") != sha256_path(evidence_path)
+    ):
+        raise VegetationShadowLabError("mixed-route TGS evidence changed")
+    with np.load(evidence_path, allow_pickle=False) as archive:
+        centers = archive["costmap_cell_centers_xy_m"]
+        states = archive["causal_rolling_1s_costmap_states"]
+    if centers.shape != (2244, 2) or states.shape != (FRAME_COUNT, 2244):
+        raise VegetationShadowLabError("mixed-route TGS costmap shape changed")
+    radius = float(costmap["radius_m"])
+    cell_size = float(costmap["cell_size_m"])
+    size = 600
+    scale = size / (radius * 2.0)
+    outputs: list[Path] = []
+    destination.mkdir(mode=0o700, parents=True, exist_ok=True)
+    for slot in range(FRAME_COUNT):
+        image = Image.new("RGB", (size, size), TGS_COLORS[0])
+        draw = ImageDraw.Draw(image)
+        half = cell_size * scale / 2.0
+        for center, state in zip(centers, states[slot], strict=True):
+            x = (float(center[0]) + radius) * scale
+            y = (radius - float(center[1])) * scale
+            draw.rectangle((x - half, y - half, x + half, y + half), fill=TGS_COLORS[int(state)])
+        rover_w = 0.8 * scale
+        rover_l = 1.0 * scale
+        cx = size / 2.0
+        cy = size / 2.0
+        draw.rectangle(
+            (cx - rover_w / 2, cy - rover_l / 2, cx + rover_w / 2, cy + rover_l / 2),
+            outline=(255, 255, 255),
+            width=3,
+        )
+        path = destination / f"frame-{slot + 1:06d}.png"
+        image.save(path, format="PNG", optimize=True)
+        outputs.append(path)
+    return outputs
+
+
+def seal_mixed_route_vegetation_review(
+    *,
+    base_lab_root: Path,
+    review_pack_root: Path,
+    eomt_root: Path,
+    ddrnet_root: Path,
+    tgs_root: Path,
+    output_root: Path,
+) -> Path:
+    base_root = base_lab_root.resolve(strict=True)
+    base = _read_json(base_root / "result.json", "base vegetation LAB")
+    base_identity = base.get("identity")
+    if (
+        base.get("schema_version") != LAB_SCHEMA
+        or not isinstance(base_identity, dict)
+        or hashlib.sha256(canonical_json(base_identity)).hexdigest()
+        != base.get("identity_sha256")
+        or base.get("result_id") != base_root.name
+        or not base_root.name.startswith(RESULT_PREFIX)
+        or base.get("authority", {}).get("commands_enabled") is not False
+    ):
+        raise VegetationShadowLabError("base vegetation LAB proof changed")
+
+    pack_root = review_pack_root.resolve(strict=True)
+    pack = _read_json(pack_root / "manifest.json", "mixed-route review pack")
+    timeline_path = pack_root / str(pack.get("timeline", {}).get("path"))
+    if (
+        pack.get("schema_version") != REVIEW_SCHEMA
+        or pack.get("frame_count") != FRAME_COUNT
+        or pack.get("identity", {}).get("session_id") != "20260828T130511Z_viewer_live"
+        or pack.get("identity", {}).get("ground_truth") is not False
+        or not timeline_path.is_file()
+        or pack.get("timeline", {}).get("sha256") != sha256_path(timeline_path)
+    ):
+        raise VegetationShadowLabError("mixed-route review pack changed")
+    timeline = [json.loads(line) for line in timeline_path.read_text(encoding="utf-8").splitlines()]
+    if len(timeline) != FRAME_COUNT:
+        raise VegetationShadowLabError("mixed-route timeline is incomplete")
+
+    eomt = _read_json(eomt_root / "run-report.partial.json", "mixed-route EoMT result")
+    ddrnet = _read_json(ddrnet_root / "result.json", "mixed-route DDRNet result")
+    tgs = _read_json(tgs_root / "result.json", "mixed-route TGS result")
+    if (
+        eomt.get("input", {}).get("frames_admitted") != FRAME_COUNT
+        or eomt.get("metrics", {}).get("frames_processed") != FRAME_COUNT
+        or eomt.get("ground_truth") is not False
+        or ddrnet.get("schema_version") != DDRNET_SCHEMA
+        or ddrnet.get("source", {}).get("pack_id") != pack["pack_id"]
+        or len(ddrnet.get("frames", [])) != FRAME_COUNT
+        or ddrnet.get("authority", {}).get("candidate_accepted") is not False
+        or tgs.get("schema_version") != TGS_SCHEMA
+        or tgs.get("source", {}).get("review_pack_id") != pack["pack_id"]
+        or tgs.get("summary", {}).get("frame_count") != FRAME_COUNT
+    ):
+        raise VegetationShadowLabError("mixed-route model identities differ")
+
+    output_root.mkdir(mode=0o700, parents=True, exist_ok=True)
+    temporary = Path(tempfile.mkdtemp(prefix=".mixed-route-vegetation-", dir=output_root))
+    artifacts: list[dict[str, object]] = []
+    try:
+        tgs_images = _render_tgs_costmaps(tgs_root, temporary / ".tgs-render")
+        cases: list[dict[str, object]] = []
+        tgs_anchors = {
+            int(row["slot"]): row
+            for row in tgs["anchors"]
+            if row.get("profile_id") == "causal_rolling_1s"
+        }
+        for slot, row in enumerate(timeline):
+            case_id = f"route-{slot + 1:02d}"
+            relative_root = f"route-review/{case_id}"
+            source_descriptor = _artifact(
+                pack_root / "frames" / f"frame-{slot + 1:06d}.png",
+                temporary,
+                f"{relative_root}/source.png",
+                artifacts,
+                role="mixed-route-source-frame",
+                media_type="image/png",
+            )
+            city_descriptor = _artifact(
+                eomt_root / "overlay-frames" / f"frame-{slot + 1:06d}.png",
+                temporary,
+                f"{relative_root}/city.png",
+                artifacts,
+                role="mixed-route-eomt-overlay",
+                media_type="image/png",
+            )
+            vegetation_descriptor = _artifact(
+                ddrnet_root / "overlay-frames" / f"frame-{slot + 1:06d}.png",
+                temporary,
+                f"{relative_root}/vegetation.png",
+                artifacts,
+                role="mixed-route-ddrnet-overlay",
+                media_type="image/png",
+            )
+            tgs_descriptor = _artifact(
+                tgs_images[slot],
+                temporary,
+                f"{relative_root}/tgs.png",
+                artifacts,
+                role="mixed-route-tgs-costmap",
+                media_type="image/png",
+            )
+            anchor = tgs_anchors[slot]
+            cases.append(
+                {
+                    "case_id": case_id,
+                    "phase": PHASES[slot],
+                    "source_sequence": int(row["source_sequence"]),
+                    "session_seconds": float(row["session_seconds"]),
+                    "assets": {
+                        "source": _image_proof(source_descriptor),
+                        "city": _image_proof(city_descriptor),
+                        "vegetation": _image_proof(vegetation_descriptor),
+                        "tgs": _image_proof(tgs_descriptor),
+                    },
+                    "tgs": {
+                        "ground_cells": int(anchor["ground_cell_count"]),
+                        "occupied_cells": int(anchor["nonground_cell_count"]),
+                        "rejected_cells": int(anchor["rejected_cell_count"]),
+                        "unobserved_cells": int(anchor["unobserved_cell_count"]),
+                    },
+                }
+            )
+        shutil.rmtree(temporary / ".tgs-render")
+
+        proofs = {}
+        for key, path in (
+            ("base", base_root / "result.json"),
+            ("eomt", eomt_root / "run-report.partial.json"),
+            ("ddrnet", ddrnet_root / "result.json"),
+            ("tgs", tgs_root / "result.json"),
+        ):
+            descriptor = _artifact(
+                path,
+                temporary,
+                f"proofs/{key}.json",
+                artifacts,
+                role="mixed-route-proof",
+                media_type="application/json",
+            )
+            proofs[key] = _image_proof(descriptor)
+        _artifact(
+            tgs_root / str(tgs["evidence"]["path"]),
+            temporary,
+            "proofs/tgs-evidence.npz",
+            artifacts,
+            role="mixed-route-tgs-evidence",
+            media_type="application/x-npz",
+        )
+
+        route_review = {
+            "source_id": "RAVNOVES004TREE",
+            "session_id": "20260828T130511Z_viewer_live",
+            "pack_id": pack["pack_id"],
+            "frame_count": FRAME_COUNT,
+            "ground_truth": False,
+            "selection_policy": "same-scene-camera-lidar-aligned-review-islands/v1",
+            "models": {
+                "city": {
+                    "name": "EoMT Cityscapes",
+                    "frames": FRAME_COUNT,
+                    "inference_fps": eomt["metrics"]["inference_frames_per_second"],
+                    "end_to_end_p95_ms": eomt["metrics"]["latency_ms"]["end_to_end_ms"]["p95"],
+                },
+                "vegetation": {
+                    "name": ddrnet["candidate"]["loaded_model_name"],
+                    "result_id": ddrnet["result_id"],
+                    "frames": FRAME_COUNT,
+                    "latency_p95_ms": ddrnet["timing"]["latency_ms_p95"],
+                },
+                "tgs": {
+                    "name": "TRAVEL/TGS causal rolling 1 s",
+                    "frames": FRAME_COUNT,
+                    "latency_p95_ms": tgs["timing"]["wall_seconds_p95"] * 1000.0,
+                    "cell_size_m": tgs["costmap"]["cell_size_m"],
+                    "radius_m": tgs["costmap"]["radius_m"],
+                },
+            },
+            "cases": cases,
+            "proofs": proofs,
+            "limitations": [
+                "Ten aligned review islands are not a complete route timeline.",
+                "RAVNOVES004TREE has no manual truth.",
+                "DDRNet vegetation subtypes remain visually noisy and are not planner authority.",
+                "TGS does not prove ditch or negative-obstacle detection.",
+                "People and vehicles require an independent fail-safe detector and STOP path.",
+            ],
+        }
+        authority = {
+            "commands_enabled": False,
+            "navigation_or_safety_accepted": False,
+            "actuation_accepted": False,
+            "camera_semantics_can_clear_rigid_geometry": False,
+        }
+        identity = {
+            "lab_id": "lab-v1-vegetation-mission-policy",
+            "base_result_id": base["result_id"],
+            "selected_candidate": base_identity["selected_candidate"],
+            "candidate_metrics": base_identity["candidate_metrics"],
+            "source": {
+                "shadow_session": "RAVNOVES004TREE",
+                "shadow_camera": "sensor.camera.right",
+                "shadow_frame_count": FRAME_COUNT,
+                "video_shadow_frame_count": 0,
+            },
+            "route_review": route_review,
+            "authority": authority,
+        }
+        identity_sha256 = hashlib.sha256(canonical_json(identity)).hexdigest()
+        result_id = f"{RESULT_PREFIX}{identity_sha256}"
+        manifest = {
+            "schema_version": LAB_SCHEMA,
+            "result_id": result_id,
+            "identity_sha256": identity_sha256,
+            "created_at_utc": datetime.now(UTC).isoformat(),
+            "ground_truth": False,
+            "status": "visual-shadow-ready-policy-not-authorized",
+            "identity": identity,
+            "source": identity["source"],
+            "route_video": None,
+            "route_review": route_review,
+            "method": {
+                "completeness": "bounded-review-islands",
+                "execution_class": "ai-inference",
+                "pipeline_id": "ravnoves004tree-eomt-ddrnet-causal-tgs-review/v1",
+            },
+            "metrics": {"candidates": base["metrics"]["candidates"]},
+            "decision": {
+                "selected_candidate": base_identity["selected_candidate"],
+                "visual_shadow_ready": True,
+                "full_video_shadow_ready": False,
+                "mission_policy_ready_for_configuration": True,
+                "multilayer_policy_review_ready": True,
+                "navigation_accepted": False,
+                "production_accepted": False,
+            },
+            "limitations": route_review["limitations"],
+            "authority": authority,
+            "catalogs": {"goose": [], "ravnoves": []},
+            "artifacts": artifacts,
+        }
+        (temporary / "result.json").write_bytes(canonical_json(manifest) + b"\n")
+        destination = output_root / result_id
+        if destination.exists():
+            raise VegetationShadowLabError("immutable mixed-route LAB result already exists")
+        os.replace(temporary, destination)
+        return destination
+    except Exception:
+        shutil.rmtree(temporary, ignore_errors=True)
+        raise
+
+
+def seal_mixed_route_full_video_review(
+    *,
+    base_lab_root: Path,
+    job_root: Path,
+    recorded_media_preparation_path: Path,
+    eomt_root: Path,
+    eomt_profile_path: Path,
+    ddrnet_root: Path,
+    output_root: Path,
+) -> Path:
+    """Publish the complete 004 city/nature pass in the existing M4.7 LAB."""
+
+    base_root = base_lab_root.resolve(strict=True)
+    base = _read_json(base_root / "result.json", "base vegetation LAB")
+    base_identity = base.get("identity")
+    if (
+        base.get("schema_version") != LAB_SCHEMA
+        or not isinstance(base_identity, dict)
+        or hashlib.sha256(canonical_json(base_identity)).hexdigest()
+        != base.get("identity_sha256")
+        or base.get("result_id") != base_root.name
+        or not base_root.name.startswith(RESULT_PREFIX)
+        or base.get("authority", {}).get("commands_enabled") is not False
+    ):
+        raise VegetationShadowLabError("base vegetation LAB proof changed")
+
+    job = validate_camera_compute_job(job_root)
+    if (
+        job.job_id != FULL_ROUTE_JOB_ID
+        or job.input_sha256 != FULL_ROUTE_INPUT_SHA256
+        or job.session_id != "20260828T130511Z_viewer_live"
+        or job.source_id != "sensor.camera.right"
+        or job.segment_count != FULL_ROUTE_FRAME_COUNT
+    ):
+        raise VegetationShadowLabError("full-route camera job changed")
+
+    eomt = _read_json(eomt_root / "result.json", "full-route EoMT result")
+    eomt_report = _read_json(eomt_root / "run-report.json", "full-route EoMT report")
+    decode_repair = _read_json(
+        eomt_root / "decode-repair.json",
+        "full-route video decode repair",
+    )
+    eomt_input = eomt_report.get("input")
+    eomt_metrics = eomt_report.get("metrics")
+    if (
+        eomt.get("schema_version") != "missioncore.recorded-perception-result/v2"
+        or eomt.get("ground_truth") is not False
+        or eomt.get("frames_processed") != FULL_ROUTE_FRAME_COUNT
+        or not isinstance(eomt_input, dict)
+        or eomt_input.get("job_id") != job.job_id
+        or eomt_input.get("input_sha256") != job.input_sha256
+        or eomt_input.get("frames_admitted") != FULL_ROUTE_FRAME_COUNT
+        or not isinstance(eomt_metrics, dict)
+        or eomt_metrics.get("frames_processed") != FULL_ROUTE_FRAME_COUNT
+    ):
+        raise VegetationShadowLabError("full-route EoMT contract changed")
+    if (
+        decode_repair.get("schema_version")
+        != "missioncore.recorded-video-decode-repair/v1"
+        or decode_repair.get("decoder") != "ffmpeg-h264_cuvid-output-corrupt"
+        or decode_repair.get("packets_requested") != FULL_ROUTE_FRAME_COUNT
+        or decode_repair.get("frames_decoded") != FULL_ROUTE_FRAME_COUNT - 1
+        or decode_repair.get("repaired_frame_count") != 1
+        or decode_repair.get("repairs")
+        != [
+            {
+                "sequence": 6092,
+                "packet_pts": 55656450,
+                "method": "duplicate-previous-decoded-frame",
+            }
+        ]
+    ):
+        raise VegetationShadowLabError("full-route video decode repair changed")
+    eomt_artifacts = {
+        item.get("kind"): item
+        for item in eomt.get("artifacts", [])
+        if isinstance(item, dict)
+    }
+    eomt_archive_proof = eomt_artifacts.get("panoptic-mask-archive")
+    if not isinstance(eomt_archive_proof, dict):
+        raise VegetationShadowLabError("full-route EoMT mask proof is missing")
+    eomt_archive = eomt_root / str(eomt_archive_proof.get("path"))
+    if (
+        not eomt_archive.is_file()
+        or eomt_archive.stat().st_size != eomt_archive_proof.get("byte_length")
+        or sha256_path(eomt_archive) != eomt_archive_proof.get("sha256")
+    ):
+        raise VegetationShadowLabError("full-route EoMT mask proof changed")
+
+    ddrnet = _read_json(ddrnet_root / "result.json", "full-route DDRNet result")
+    ddrnet_decode_repair = _read_json(
+        ddrnet_root / "decode-repair.json",
+        "full-route DDRNet video decode repair",
+    )
+    ddrnet_source = ddrnet.get("source")
+    ddrnet_video = ddrnet.get("video_semantics")
+    if (
+        ddrnet.get("schema_version") != "missioncore.lab-v1-goose-vegetation-run/v1"
+        or ddrnet.get("mode") != "ravnoves-video"
+        or ddrnet.get("candidate", {}).get("candidate_key") != "ddrnet"
+        or not isinstance(ddrnet_source, dict)
+        or ddrnet_source.get("source_id")
+        != f"{FULL_ROUTE_SOURCE_ID}/right-{FULL_ROUTE_STREAM_SHA256}"
+        or ddrnet_source.get("input_count") != FULL_ROUTE_FRAME_COUNT
+        or ddrnet_source.get("ground_truth_available") is not False
+        or not isinstance(ddrnet_video, dict)
+        or ddrnet_video.get("base_m4_result_id") is not None
+        or ddrnet.get("authority", {}).get("navigation_accepted") is not False
+        or ddrnet.get("authority", {}).get("actuation_accepted") is not False
+    ):
+        raise VegetationShadowLabError("full-route DDRNet contract changed")
+    if ddrnet_decode_repair != decode_repair:
+        raise VegetationShadowLabError("full-route model decoders disagree")
+    ddrnet_archive_proof = ddrnet_video.get("mask_archive")
+    ddrnet_taxonomy = ddrnet_video.get("taxonomy")
+    if (
+        not isinstance(ddrnet_archive_proof, dict)
+        or ddrnet_archive_proof.get("frame_count") != FULL_ROUTE_FRAME_COUNT
+        or not isinstance(ddrnet_taxonomy, dict)
+    ):
+        raise VegetationShadowLabError("full-route DDRNet mask proof changed")
+    ddrnet_archive = ddrnet_root / str(ddrnet_archive_proof.get("path"))
+    if (
+        not ddrnet_archive.is_file()
+        or ddrnet_archive.stat().st_size != ddrnet_archive_proof.get("byte_length")
+        or sha256_path(ddrnet_archive) != ddrnet_archive_proof.get("sha256")
+    ):
+        raise VegetationShadowLabError("full-route DDRNet archive changed")
+    _validate_zip_masks(ddrnet_archive, FULL_ROUTE_FRAME_COUNT)
+
+    media_document = _read_json(
+        recorded_media_preparation_path.resolve(strict=True),
+        "recorded media preparation",
+    )
+    media = media_document.get("manifest")
+    if (
+        media_document.get("schema_version") != "missioncore.recorded-media-preparation/v3"
+        or media_document.get("session_id") != job.session_id
+        or media_document.get("artifact_id") != "recorded-video-6a3945242828a038"
+        or media_document.get("checksum_sha256")
+        != "557e61f2839140dc9f97b5aea855c576b0616573080dff5d2852ab1df0558665"
+        or not isinstance(media, dict)
+        or media.get("source_id") != "recorded.camera.6a3945242828a038"
+        or media.get("generation_sha256")
+        != "b073ea1e7babf1c77a664e1a5b95e3702d0e05b0e34c1e85a7c67a6f8b392ded"
+        or media.get("byte_length") != 551674491
+        or media.get("timeline_start_seconds") != job.timeline_start_seconds
+        or media.get("timeline_end_seconds") != job.timeline_end_seconds
+        or media.get("synchronization") != "host-arrival-best-effort"
+    ):
+        raise VegetationShadowLabError("recorded media preparation changed")
+    frame_times_ns = _full_route_frame_times(media, FULL_ROUTE_FRAME_COUNT)
+    eomt_profile = _read_json(eomt_profile_path.resolve(strict=True), "EoMT profile")
+    eomt_taxonomy = _eomt_taxonomy(eomt_profile)
+
+    output_root.mkdir(mode=0o700, parents=True, exist_ok=True)
+    temporary = Path(tempfile.mkdtemp(prefix=".mixed-route-full-video-", dir=output_root))
+    artifacts: list[dict[str, object]] = []
+    try:
+        eomt_destination = temporary / "video" / "eomt-semantic-masks.zip"
+        _repack_eomt_masks(eomt_archive, eomt_destination, FULL_ROUTE_FRAME_COUNT)
+        _validate_zip_masks(eomt_destination, FULL_ROUTE_FRAME_COUNT)
+        eomt_descriptor = _mask_archive_descriptor(
+            eomt_destination,
+            "video/eomt-semantic-masks.zip",
+            artifacts,
+            role="full-route-eomt-semantic-mask-archive",
+        )
+        ddrnet_descriptor = _artifact(
+            ddrnet_archive,
+            temporary,
+            "video/ddrnet-semantic-masks.zip",
+            artifacts,
+            role="full-route-ddrnet-semantic-mask-archive",
+            media_type="application/zip",
+        )
+        _validate_zip_masks(
+            temporary / "video" / "ddrnet-semantic-masks.zip",
+            FULL_ROUTE_FRAME_COUNT,
+        )
+        timeline_destination = temporary / "video" / "frame-source-times-ns.bin"
+        timeline_destination.write_bytes(
+            struct.pack(f"<{FULL_ROUTE_FRAME_COUNT}Q", *frame_times_ns)
+        )
+        timeline_descriptor = {
+            "role": "full-route-frame-timeline",
+            "path": "video/frame-source-times-ns.bin",
+            "byte_length": timeline_destination.stat().st_size,
+            "sha256": sha256_path(timeline_destination),
+            "media_type": "application/octet-stream",
+        }
+        artifacts.append(timeline_descriptor)
+        proof_descriptors: dict[str, dict[str, object]] = {}
+        for key, path in (
+            ("base", base_root / "result.json"),
+            ("job", job.manifest_path),
+            ("media", recorded_media_preparation_path.resolve(strict=True)),
+            ("eomt", eomt_root / "result.json"),
+            ("eomt_report", eomt_root / "run-report.json"),
+            ("decode_repair", eomt_root / "decode-repair.json"),
+            ("ddrnet", ddrnet_root / "result.json"),
+            ("ddrnet_decode_repair", ddrnet_root / "decode-repair.json"),
+        ):
+            descriptor = _artifact(
+                path,
+                temporary,
+                f"proofs/{key}.json",
+                artifacts,
+                role="full-route-proof",
+                media_type="application/json",
+            )
+            proof_descriptors[key] = _image_proof(descriptor)
+
+        full_route = {
+            "source_id": FULL_ROUTE_SOURCE_ID,
+            "session_id": job.session_id,
+            "source_job_id": job.job_id,
+            "source_job_input_sha256": job.input_sha256,
+            "source_stream_sha256": FULL_ROUTE_STREAM_SHA256,
+            "recorded_media_source_id": media["source_id"],
+            "recorded_media_generation_sha256": media["generation_sha256"],
+            "frame_count": FULL_ROUTE_FRAME_COUNT,
+            "width": 800,
+            "height": 600,
+            "timeline_start_seconds": job.timeline_start_seconds,
+            "timeline_end_seconds": job.timeline_end_seconds,
+            "timeline": {
+                "path": timeline_descriptor["path"],
+                "sha256": timeline_descriptor["sha256"],
+                "byte_length": timeline_descriptor["byte_length"],
+                "encoding": "uint64-le-nanoseconds",
+                "frame_count": FULL_ROUTE_FRAME_COUNT,
+            },
+            "ground_truth": False,
+            "decode_repair": {
+                "repaired_frame_count": 1,
+                "sequence": 6092,
+                "method": "duplicate-previous-decoded-frame",
+                "proofs": {
+                    "eomt": proof_descriptors["decode_repair"],
+                    "ddrnet": proof_descriptors["ddrnet_decode_repair"],
+                },
+            },
+            "layers": {
+                "city": {
+                    "name": "EoMT Cityscapes",
+                    "result_id": eomt["result_id"],
+                    "frame_count": FULL_ROUTE_FRAME_COUNT,
+                    "taxonomy": eomt_taxonomy,
+                    "mask_archive": {
+                        "path": eomt_descriptor["path"],
+                        "sha256": eomt_descriptor["sha256"],
+                        "byte_length": eomt_descriptor["byte_length"],
+                    },
+                    "inference_fps": eomt_metrics["inference_frames_per_second"],
+                    "latency_p95_ms": eomt_metrics["latency_ms"]["end_to_end_ms"]["p95"],
+                    "peak_reserved_vram_bytes": int(
+                        float(eomt_metrics["cuda_peak_memory_reserved_mib"]) * 1024 * 1024
+                    ),
+                },
+                "vegetation": {
+                    "name": ddrnet["candidate"]["loaded_model_name"],
+                    "result_id": ddrnet["result_id"],
+                    "frame_count": FULL_ROUTE_FRAME_COUNT,
+                    "taxonomy": ddrnet_taxonomy,
+                    "mask_archive": {
+                        "path": ddrnet_descriptor["path"],
+                        "sha256": ddrnet_descriptor["sha256"],
+                        "byte_length": ddrnet_descriptor["byte_length"],
+                    },
+                    "inference_fps": ddrnet["timing"]["throughput_fps_from_mean_inference"],
+                    "latency_p95_ms": ddrnet["timing"]["latency_ms_p95"],
+                    "peak_reserved_vram_bytes": ddrnet["resource"]["peak_reserved_vram_bytes"],
+                },
+            },
+            "proofs": proof_descriptors,
+            "limitations": [
+                "RAVNOVES004TREE has no manual route truth.",
+                "One corrupt H.264 packet at sequence 6092 was represented by the previous decoded frame; the repair is sealed as evidence.",
+                "EoMT and DDRNet were executed sequentially, not as a concurrent realtime stack.",
+                "DDRNet vegetation subtypes remain prediction-only and are not planner authority.",
+                "This full-video pass does not add full-route TGS, ditch or negative-obstacle proof.",
+                "People and vehicles still require an independent fail-safe detector and STOP path.",
+            ],
+        }
+        authority = {
+            "commands_enabled": False,
+            "navigation_or_safety_accepted": False,
+            "actuation_accepted": False,
+            "camera_semantics_can_clear_rigid_geometry": False,
+        }
+        identity = {
+            "lab_id": "lab-v1-vegetation-mission-policy",
+            "base_result_id": base["result_id"],
+            "selected_candidate": base_identity["selected_candidate"],
+            "candidate_metrics": base_identity["candidate_metrics"],
+            "source": {
+                "shadow_session": FULL_ROUTE_SOURCE_ID,
+                "shadow_camera": job.source_id,
+                "shadow_frame_count": FULL_ROUTE_FRAME_COUNT,
+                "video_shadow_frame_count": FULL_ROUTE_FRAME_COUNT,
+            },
+            "route_full_review": full_route,
+            "authority": authority,
+        }
+        identity_sha256 = hashlib.sha256(canonical_json(identity)).hexdigest()
+        result_id = f"{RESULT_PREFIX}{identity_sha256}"
+        manifest = {
+            "schema_version": LAB_SCHEMA,
+            "result_id": result_id,
+            "identity_sha256": identity_sha256,
+            "created_at_utc": datetime.now(UTC).isoformat(),
+            "ground_truth": False,
+            "status": "visual-shadow-ready-policy-not-authorized",
+            "identity": identity,
+            "source": identity["source"],
+            "route_video": None,
+            "route_review": None,
+            "route_full_review": full_route,
+            "method": {
+                "completeness": "complete",
+                "execution_class": "ai-inference",
+                "pipeline_id": "ravnoves004tree-full-eomt-ddrnet-recorded-review/v1",
+            },
+            "metrics": {"candidates": base["metrics"]["candidates"]},
+            "decision": {
+                "selected_candidate": base_identity["selected_candidate"],
+                "visual_shadow_ready": True,
+                "full_video_shadow_ready": True,
+                "mission_policy_ready_for_configuration": True,
+                "multilayer_policy_review_ready": True,
+                "navigation_accepted": False,
+                "production_accepted": False,
+            },
+            "limitations": full_route["limitations"],
+            "authority": authority,
+            "catalogs": {"goose": [], "ravnoves": []},
+            "artifacts": artifacts,
+        }
+        (temporary / "result.json").write_bytes(canonical_json(manifest) + b"\n")
+        destination = output_root / result_id
+        if destination.exists():
+            raise VegetationShadowLabError("immutable full-route LAB result already exists")
+        os.replace(temporary, destination)
+        return destination
+    except Exception:
+        shutil.rmtree(temporary, ignore_errors=True)
+        raise
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--base-lab-root", type=Path, required=True)
+    parser.add_argument("--review-pack-root", type=Path, required=True)
+    parser.add_argument("--eomt-root", type=Path, required=True)
+    parser.add_argument("--ddrnet-root", type=Path, required=True)
+    parser.add_argument("--tgs-root", type=Path, required=True)
+    parser.add_argument("--output-root", type=Path, required=True)
+    args = parser.parse_args()
+    print(
+        seal_mixed_route_vegetation_review(
+            base_lab_root=args.base_lab_root,
+            review_pack_root=args.review_pack_root,
+            eomt_root=args.eomt_root,
+            ddrnet_root=args.ddrnet_root,
+            tgs_root=args.tgs_root,
+            output_root=args.output_root,
+        )
+    )
+
+
+if __name__ == "__main__":
+    main()

src/k1link/laboratory/vegetation_benchmark_archive.py

@@ -0,0 +1,139 @@
+"""Seal a benchmark-only vegetation result into its archival LAB namespace."""
+
+from __future__ import annotations
+
+import argparse
+import copy
+import hashlib
+import json
+import shutil
+import tempfile
+from pathlib import Path, PurePosixPath
+from typing import Any, Final
+
+from k1link.laboratory.evidence_registry import LaboratoryEvidenceDefinition
+from k1link.laboratory.evidence_report import verify_laboratory_evidence_result
+from k1link.laboratory.vegetation_shadow_lab import LAB_SCHEMA
+
+_SOURCE_DEFINITION: Final = LaboratoryEvidenceDefinition(
+    work_id="lab-v1-vegetation-shadow",
+    runtime_relative_root=PurePosixPath("lab-v1-vegetation/results"),
+    result_id_prefix="lab-v1-vegetation-shadow",
+    document_name="result.json",
+    result_schema_version=LAB_SCHEMA,
+)
+_ARCHIVE_DEFINITION: Final = LaboratoryEvidenceDefinition(
+    work_id="lab-v1-vegetation-benchmark",
+    runtime_relative_root=PurePosixPath("lab-v1-vegetation-benchmark/results"),
+    result_id_prefix="lab-v1-vegetation-benchmark",
+    document_name="result.json",
+    result_schema_version=LAB_SCHEMA,
+)
+
+
+class VegetationBenchmarkArchiveError(ValueError):
+    """The source result is not a valid benchmark-only immutable result."""
+
+
+def _canonical_json(value: object) -> bytes:
+    return json.dumps(
+        value,
+        ensure_ascii=False,
+        separators=(",", ":"),
+        sort_keys=True,
+    ).encode("utf-8")
+
+
+def _object(value: object, label: str) -> dict[str, Any]:
+    if not isinstance(value, dict):
+        raise VegetationBenchmarkArchiveError(f"{label} is invalid")
+    return value
+
+
+def seal_vegetation_benchmark_archive(
+    *,
+    source_result_root: Path,
+    output_root: Path,
+) -> Path:
+    source = source_result_root.resolve(strict=True)
+    verify_laboratory_evidence_result(_SOURCE_DEFINITION, source)
+    manifest = _object(
+        json.loads((source / "result.json").read_text("utf-8")),
+        "source result",
+    )
+    if manifest.get("route_video") is not None:
+        raise VegetationBenchmarkArchiveError("benchmark archive source contains route video")
+    artifacts = manifest.get("artifacts")
+    if not isinstance(artifacts, list):
+        raise VegetationBenchmarkArchiveError("source artifacts are invalid")
+
+    identity = copy.deepcopy(_object(manifest.get("identity"), "source identity"))
+    identity.update(
+        {
+            "lab_id": "lab-v1-vegetation-benchmark-archive",
+            "archived_from_result_id": source.name,
+        }
+    )
+    identity_sha256 = hashlib.sha256(_canonical_json(identity)).hexdigest()
+    result_id = f"lab-v1-vegetation-benchmark-{identity_sha256}"
+
+    output_root.mkdir(mode=0o700, parents=True, exist_ok=True)
+    destination = output_root / result_id
+    if destination.exists():
+        verify_laboratory_evidence_result(_ARCHIVE_DEFINITION, destination)
+        return destination
+
+    temporary = Path(tempfile.mkdtemp(prefix=".vegetation-benchmark-", dir=output_root))
+    try:
+        for raw in artifacts:
+            descriptor = _object(raw, "artifact descriptor")
+            relative_text = descriptor.get("path")
+            if not isinstance(relative_text, str):
+                raise VegetationBenchmarkArchiveError("artifact path is invalid")
+            relative = PurePosixPath(relative_text)
+            if relative.is_absolute() or any(part in {"", ".", ".."} for part in relative.parts):
+                raise VegetationBenchmarkArchiveError("artifact path is unsafe")
+            source_path = source.joinpath(*relative.parts)
+            destination_path = temporary.joinpath(*relative.parts)
+            destination_path.parent.mkdir(mode=0o700, parents=True, exist_ok=True)
+            shutil.copyfile(source_path, destination_path)
+
+        archived = copy.deepcopy(manifest)
+        archived.update(
+            {
+                "result_id": result_id,
+                "identity": identity,
+                "identity_sha256": identity_sha256,
+                "archived_from_result_id": source.name,
+            }
+        )
+        (temporary / "result.json").write_bytes(_canonical_json(archived) + b"\n")
+        temporary.rename(destination)
+        verify_laboratory_evidence_result(_ARCHIVE_DEFINITION, destination)
+        return destination
+    except Exception:
+        shutil.rmtree(temporary, ignore_errors=True)
+        raise
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--source-result-root", type=Path, required=True)
+    parser.add_argument("--output-root", type=Path, required=True)
+    args = parser.parse_args()
+    print(
+        seal_vegetation_benchmark_archive(
+            source_result_root=args.source_result_root,
+            output_root=args.output_root,
+        )
+    )
+
+
+if __name__ == "__main__":
+    main()
+
+
+__all__ = [
+    "VegetationBenchmarkArchiveError",
+    "seal_vegetation_benchmark_archive",
+]

src/k1link/laboratory/vegetation_policy_review.py

@@ -0,0 +1,302 @@
+"""Seal a coarse material + YOLOX + TGS review from an immutable vegetation LAB."""
+
+from __future__ import annotations
+
+import argparse
+import copy
+import hashlib
+import json
+import shutil
+import tempfile
+from datetime import UTC, datetime
+from pathlib import Path, PurePosixPath
+from typing import Any, Final
+
+from k1link.laboratory.evidence_registry import LaboratoryEvidenceDefinition
+from k1link.laboratory.evidence_report import verify_laboratory_evidence_result
+from k1link.laboratory.m49_tgs_full_shadow import read_m49_tgs_full_shadow
+from k1link.laboratory.vegetation_mission_policy import (
+    load_vegetation_mission_policy,
+    load_vegetation_provider_label_map,
+)
+from k1link.laboratory.vegetation_policy_video import build_policy_mask_archive, policy_taxonomy
+from k1link.laboratory.vegetation_shadow_lab import (
+    LAB_SCHEMA,
+    RESULT_PREFIX,
+    canonical_json,
+    sha256_path,
+)
+
+_DEFINITION: Final = LaboratoryEvidenceDefinition(
+    work_id="lab-v1-vegetation-shadow",
+    runtime_relative_root=PurePosixPath("lab-v1-vegetation/results"),
+    result_id_prefix="lab-v1-vegetation-shadow",
+    document_name="result.json",
+    result_schema_version=LAB_SCHEMA,
+)
+_FRAME_COUNT: Final = 4489
+_MAX_RESULT_BYTES: Final = 1024 * 1024
+
+
+class VegetationPolicyReviewError(ValueError):
+    """The sealed inputs cannot form an honest synchronized policy review."""
+
+
+def _object(value: object, label: str) -> dict[str, Any]:
+    if not isinstance(value, dict) or not all(isinstance(key, str) for key in value):
+        raise VegetationPolicyReviewError(f"{label} must be an object")
+    return value
+
+
+def _read_base(root: Path) -> dict[str, Any]:
+    candidate = root.resolve(strict=True)
+    verify_laboratory_evidence_result(_DEFINITION, candidate)
+    path = candidate / "result.json"
+    if path.stat().st_size > _MAX_RESULT_BYTES:
+        raise VegetationPolicyReviewError("base vegetation LAB document is too large")
+    payload = _object(json.loads(path.read_text("utf-8")), "base vegetation LAB")
+    route = _object(payload.get("route_video"), "base route video")
+    authority = _object(payload.get("authority"), "base authority")
+    if (
+        payload.get("schema_version") != LAB_SCHEMA
+        or payload.get("result_id") != candidate.name
+        or route.get("frame_count") != _FRAME_COUNT
+        or route.get("view_kind", "fine-semantic-prediction")
+        != "fine-semantic-prediction"
+        or route.get("base_m4_result_id") is None
+        or authority.get("commands_enabled") is not False
+        or authority.get("navigation_or_safety_accepted") is not False
+        or authority.get("actuation_accepted") is not False
+        or authority.get("camera_semantics_can_clear_rigid_geometry") is not False
+    ):
+        raise VegetationPolicyReviewError("base vegetation LAB contract changed")
+    return payload
+
+
+def _copy_verified_artifacts(
+    *,
+    source_root: Path,
+    destination_root: Path,
+    artifacts: object,
+) -> list[dict[str, object]]:
+    if not isinstance(artifacts, list):
+        raise VegetationPolicyReviewError("base artifact catalog changed")
+    copied: list[dict[str, object]] = []
+    for raw in artifacts:
+        descriptor = _object(raw, "base artifact")
+        relative_text = descriptor.get("path")
+        expected_sha256 = descriptor.get("sha256")
+        if not isinstance(relative_text, str) or not isinstance(expected_sha256, str):
+            raise VegetationPolicyReviewError("base artifact proof changed")
+        relative = PurePosixPath(relative_text)
+        source = source_root.joinpath(*relative.parts)
+        destination = destination_root.joinpath(*relative.parts)
+        if (
+            relative.is_absolute()
+            or str(relative) != relative_text
+            or any(part in {"", ".", ".."} for part in relative.parts)
+            or source.is_symlink()
+            or not source.is_file()
+            or sha256_path(source) != expected_sha256
+        ):
+            raise VegetationPolicyReviewError("base artifact changed")
+        destination.parent.mkdir(mode=0o700, parents=True, exist_ok=True)
+        shutil.copyfile(source, destination)
+        copied.append(copy.deepcopy(descriptor))
+    return copied
+
+
+def seal_vegetation_policy_review(
+    *,
+    base_lab_root: Path,
+    mission_policy_path: Path,
+    provider_label_map_path: Path,
+    m49_tgs_full_shadow_root: Path,
+    valid_fov_mask_path: Path,
+    output_root: Path,
+    created_at_utc: str | None = None,
+) -> Path:
+    base_root = base_lab_root.resolve(strict=True)
+    base = _read_base(base_root)
+    base_route = _object(base["route_video"], "base route video")
+    repository_root = mission_policy_path.resolve().parents[2]
+    mission_policy = load_vegetation_mission_policy(
+        mission_policy_path.resolve(strict=True),
+        repository_root=repository_root,
+    )
+    provider_map = load_vegetation_provider_label_map(
+        provider_label_map_path.resolve(strict=True),
+        policy=mission_policy,
+    )
+    tgs = read_m49_tgs_full_shadow(m49_tgs_full_shadow_root)
+    tgs_source = _object(tgs.report.get("source"), "full TGS source")
+    tgs_timeline = _object(tgs.report.get("timeline"), "full TGS timeline")
+    if (
+        tgs_source.get("source_id") != "RAVNOVES00"
+        or tgs_source.get("linked_visual_result_id") != base_route.get("base_m4_result_id")
+        or tgs_timeline.get("frame_count") != _FRAME_COUNT
+    ):
+        raise VegetationPolicyReviewError("TGS and vegetation timelines differ")
+
+    raw_archive = _object(base_route.get("mask_archive"), "fine mask archive")
+    if raw_archive.get("path") != "video/ddrnet-semantic-masks.zip":
+        raise VegetationPolicyReviewError("fine mask archive identity changed")
+    raw_archive_path = base_root / "video" / "ddrnet-semantic-masks.zip"
+    fine_taxonomy = _object(base_route.get("taxonomy"), "fine taxonomy")
+    valid_fov_source = valid_fov_mask_path.resolve(strict=True)
+
+    output_root.mkdir(mode=0o700, parents=True, exist_ok=True)
+    temporary = Path(tempfile.mkdtemp(prefix=".lab-v1-policy-", dir=output_root))
+    try:
+        artifacts = _copy_verified_artifacts(
+            source_root=base_root,
+            destination_root=temporary,
+            artifacts=base.get("artifacts"),
+        )
+        policy_archive = temporary / "video" / "coarse-material-policy-masks.zip"
+        valid_fov_destination = temporary / "video" / "valid-fov-mask.png"
+        valid_fov_destination.parent.mkdir(mode=0o700, parents=True, exist_ok=True)
+        shutil.copyfile(valid_fov_source, valid_fov_destination)
+        valid_fov_proof = {
+            "role": "route-camera-valid-fov-mask",
+            "path": "video/valid-fov-mask.png",
+            "byte_length": valid_fov_destination.stat().st_size,
+            "sha256": sha256_path(valid_fov_destination),
+            "media_type": "image/png",
+        }
+        artifacts.append(valid_fov_proof)
+        policy_counts = build_policy_mask_archive(
+            source_archive=raw_archive_path,
+            destination_archive=policy_archive,
+            fine_taxonomy=fine_taxonomy,
+            provider_label_map=provider_map,
+            valid_fov_mask=valid_fov_destination,
+        )
+        policy_archive_proof = {
+            "role": "route-coarse-material-mask-archive",
+            "path": "video/coarse-material-policy-masks.zip",
+            "byte_length": policy_archive.stat().st_size,
+            "sha256": sha256_path(policy_archive),
+            "media_type": "application/zip",
+        }
+        artifacts.append(policy_archive_proof)
+
+        route = copy.deepcopy(base_route)
+        route.update(
+            {
+                "view_kind": "coarse-material-policy-review",
+                "source_mask_archive": copy.deepcopy(raw_archive),
+                "mask_archive": {
+                    "path": policy_archive_proof["path"],
+                    "sha256": policy_archive_proof["sha256"],
+                    "byte_length": policy_archive_proof["byte_length"],
+                },
+                "taxonomy": policy_taxonomy(),
+                "aggregate_prediction_pixels": policy_counts,
+                "linked_tgs_result_id": tgs.result_id,
+                "valid_fov": {
+                    "mask_path": valid_fov_proof["path"],
+                    "mask_sha256": valid_fov_proof["sha256"],
+                    "outside_valid_fov_class_id": 9,
+                },
+                "policy": {
+                    "profile_id": mission_policy["profile_id"],
+                    "profile_sha256": sha256_path(mission_policy_path),
+                    "provider_label_map_id": provider_map["profile_id"],
+                    "provider_label_map_sha256": sha256_path(provider_label_map_path),
+                    "presets": mission_policy["presets"],
+                    "precedence": mission_policy["precedence"],
+                },
+                "fusion": {
+                    "mode": "synchronised-multilayer-review",
+                    "pixel_raster_fusion": False,
+                    "camera_material_layer": "DDRNet fine-64 to coarse material evidence",
+                    "camera_safety_veto_layer": "frozen M4 YOLOX camera proposals",
+                    "spatial_safety_veto_layer": "M4.9 full TGS gravity-local costmap",
+                    "temporal_consensus_owner": "TGS causal rolling 1 s and metric obstacle tracks",
+                    "camera_semantic_temporal_filter": "none",
+                    "camera_valid_fov_filter": "sealed exact KB4 valid-FOV mask",
+                    "reason": "No admitted TGS-to-camera pixel projection exists.",
+                },
+            }
+        )
+        identity = copy.deepcopy(_object(base.get("identity"), "base identity"))
+        identity.update(
+            {
+                "base_result_id": base_root.name,
+                "route_video": route,
+            }
+        )
+        identity_sha256 = hashlib.sha256(canonical_json(identity)).hexdigest()
+        result_id = f"{RESULT_PREFIX}{identity_sha256}"
+        manifest = copy.deepcopy(base)
+        manifest.update(
+            {
+                "result_id": result_id,
+                "identity_sha256": identity_sha256,
+                "created_at_utc": created_at_utc or datetime.now(UTC).isoformat(),
+                "identity": identity,
+                "route_video": route,
+                "method": {
+                    "completeness": "complete",
+                    "execution_class": "ai-inference-plus-deterministic-adapter",
+                    "pipeline_id": "goose-fine64-to-coarse-material-plus-yolox-tgs-review/v1",
+                },
+                "decision": {
+                    **_object(base.get("decision"), "base decision"),
+                    "multilayer_policy_review_ready": True,
+                    "navigation_accepted": False,
+                    "production_accepted": False,
+                },
+                "limitations": [
+                    "GOOSE validation is external-domain qualification, not RAVNOVES ground truth.",
+                    (
+                        "The coarse material playback is derived from per-frame DDRNet "
+                        "predictions and has no RAVNOVES truth."
+                    ),
+                    (
+                        "Vegetation semantics never clears YOLOX, LiDAR, metric obstacle "
+                        "or TGS vetoes."
+                    ),
+                    "Pixels outside the exact KB4 valid FOV are transparent UNOBSERVED evidence.",
+                    (
+                        "TGS remains in gravity-local space; no uncalibrated pixel "
+                        "projection is fabricated."
+                    ),
+                    (
+                        "Temporal consensus comes from causal TGS and metric tracks; "
+                        "the camera material mask is not temporally filtered."
+                    ),
+                ],
+                "artifacts": artifacts,
+            }
+        )
+        (temporary / "result.json").write_bytes(canonical_json(manifest) + b"\n")
+        destination = output_root / result_id
+        if destination.exists():
+            raise VegetationPolicyReviewError("immutable vegetation policy result already exists")
+        temporary.replace(destination)
+        verify_laboratory_evidence_result(_DEFINITION, destination)
+        return destination
+    except Exception:
+        shutil.rmtree(temporary, ignore_errors=True)
+        raise
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--base-lab-root", type=Path, required=True)
+    parser.add_argument("--mission-policy-path", type=Path, required=True)
+    parser.add_argument("--provider-label-map-path", type=Path, required=True)
+    parser.add_argument("--m49-tgs-full-shadow-root", type=Path, required=True)
+    parser.add_argument("--valid-fov-mask-path", type=Path, required=True)
+    parser.add_argument("--output-root", type=Path, required=True)
+    args = parser.parse_args()
+    print(seal_vegetation_policy_review(**vars(args)))
+
+
+if __name__ == "__main__":
+    main()
+
+
+__all__ = ["VegetationPolicyReviewError", "seal_vegetation_policy_review"]

src/k1link/laboratory/vegetation_policy_video.py

@@ -0,0 +1,223 @@
+"""Build a deterministic coarse material-evidence video from fine GOOSE masks."""
+
+from __future__ import annotations
+
+import io
+import zipfile
+from pathlib import Path
+from typing import Any, Final
+
+import numpy as np
+from PIL import Image
+
+from k1link.laboratory.vegetation_mission_policy import map_provider_material
+
+TAXONOMY_SCHEMA: Final = "missioncore.lab-v1-terrain-policy-taxonomy/v1"
+FRAME_COUNT: Final = 4489
+WIDTH: Final = 800
+HEIGHT: Final = 600
+
+POLICY_CLASSES: Final = (
+    {
+        "class_id": 0,
+        "label": "UNOBSERVED / NO MATERIAL CLAIM · NO_GO",
+        "color_rgb": [147, 151, 159],
+        "disposition": "ambiguous",
+        "material_class": None,
+        "evidence_state": "UNOBSERVED",
+    },
+    {
+        "class_id": 1,
+        "label": "SAFETY DETECTOR VETO · NO_GO",
+        "color_rgb": [255, 104, 112],
+        "disposition": "labeled",
+        "material_class": None,
+        "evidence_state": "RIGID_OR_UNKNOWN_OBSTACLE",
+    },
+    {
+        "class_id": 2,
+        "label": "WOODY SHRUB / TREE · NO_GO",
+        "color_rgb": [232, 56, 126],
+        "disposition": "labeled",
+        "material_class": "woody_or_tree",
+        "evidence_state": "VEGETATION_WITH_RIGID_GEOMETRY",
+    },
+    {
+        "class_id": 3,
+        "label": "CULTIVATED VEGETATION · POLICY NO_GO",
+        "color_rgb": [183, 112, 255],
+        "disposition": "labeled",
+        "material_class": "cultivated_vegetation",
+        "evidence_state": "VEGETATION_POTENTIALLY_TRAVERSABLE",
+    },
+    {
+        "class_id": 4,
+        "label": "LOW GRASS · MISSION CANDIDATE",
+        "color_rgb": [181, 255, 90],
+        "disposition": "prediction",
+        "material_class": "grass",
+        "evidence_state": "VEGETATION_POTENTIALLY_TRAVERSABLE",
+    },
+    {
+        "class_id": 5,
+        "label": "HIGH / HERBACEOUS · MISSION CANDIDATE",
+        "color_rgb": [113, 211, 111],
+        "disposition": "prediction",
+        "material_class": "herbaceous_vegetation",
+        "evidence_state": "VEGETATION_POTENTIALLY_TRAVERSABLE",
+    },
+    {
+        "class_id": 6,
+        "label": "BARE SOIL · MISSION CANDIDATE",
+        "color_rgb": [255, 197, 92],
+        "disposition": "prediction",
+        "material_class": "bare_soil",
+        "evidence_state": "SUPPORTED_GROUND",
+    },
+    {
+        "class_id": 7,
+        "label": "HARD SURFACE · MISSION CANDIDATE",
+        "color_rgb": [84, 169, 255],
+        "disposition": "prediction",
+        "material_class": "hard_surface",
+        "evidence_state": "SUPPORTED_GROUND",
+    },
+    {
+        "class_id": 8,
+        "label": "VEGETATION UNKNOWN · NO_GO",
+        "color_rgb": [207, 124, 255],
+        "disposition": "labeled",
+        "material_class": "vegetation_unknown",
+        "evidence_state": "VEGETATION_UNKNOWN",
+    },
+    {
+        "class_id": 9,
+        "label": "OUTSIDE VALID FOV · NO SENSOR EVIDENCE",
+        "color_rgb": [0, 0, 0],
+        "disposition": "undefined",
+        "material_class": None,
+        "evidence_state": "UNOBSERVED",
+    },
+)
+
+_MATERIAL_TO_CLASS: Final = {
+    "hard_surface": 7,
+    "bare_soil": 6,
+    "grass": 4,
+    "fern": 5,
+    "herbaceous_vegetation": 5,
+    "cultivated_vegetation": 3,
+    "woody_shrub": 2,
+    "tree_or_trunk": 2,
+    "vegetation_unknown": 8,
+}
+
+
+class VegetationPolicyVideoError(ValueError):
+    """The fine-mask input cannot be transformed without inventing evidence."""
+
+
+def policy_taxonomy() -> dict[str, object]:
+    return {
+        "schema_version": TAXONOMY_SCHEMA,
+        "classes": [dict(row) for row in POLICY_CLASSES],
+    }
+
+
+def fine_to_policy_lut(
+    fine_taxonomy: dict[str, object],
+    provider_label_map: dict[str, Any],
+) -> np.ndarray:
+    classes = fine_taxonomy.get("classes")
+    if not isinstance(classes, list) or len(classes) != 64:
+        raise VegetationPolicyVideoError("fine taxonomy must contain 64 classes")
+    lut = np.zeros(256, dtype=np.uint8)
+    for expected_id, raw in enumerate(classes):
+        if not isinstance(raw, dict) or raw.get("class_id") != expected_id:
+            raise VegetationPolicyVideoError("fine taxonomy ordering changed")
+        label = raw.get("label")
+        if not isinstance(label, str) or not label:
+            raise VegetationPolicyVideoError("fine taxonomy label is invalid")
+        if expected_id == 0:
+            continue
+        material = map_provider_material(
+            provider_label_map,
+            provider_id="goose-fine-64",
+            provider_label=label,
+        )
+        lut[expected_id] = _MATERIAL_TO_CLASS.get(material, 0)
+    return lut
+
+
+def _zip_info(name: str) -> zipfile.ZipInfo:
+    info = zipfile.ZipInfo(name, date_time=(1980, 1, 1, 0, 0, 0))
+    info.compress_type = zipfile.ZIP_STORED
+    info.create_system = 3
+    info.external_attr = 0o600 << 16
+    return info
+
+
+def build_policy_mask_archive(
+    *,
+    source_archive: Path,
+    destination_archive: Path,
+    fine_taxonomy: dict[str, object],
+    provider_label_map: dict[str, Any],
+    valid_fov_mask: Path,
+) -> list[int]:
+    """Map every fine mask to coarse evidence; safety vetoes remain separate layers."""
+
+    lut = fine_to_policy_lut(fine_taxonomy, provider_label_map)
+    try:
+        with Image.open(valid_fov_mask) as image:
+            valid_fov = np.asarray(image.convert("L"), dtype=np.uint8) > 0
+    except OSError as exc:
+        raise VegetationPolicyVideoError("valid-FOV mask is unreadable") from exc
+    if valid_fov.shape != (HEIGHT, WIDTH) or not np.any(valid_fov) or np.all(valid_fov):
+        raise VegetationPolicyVideoError("valid-FOV mask geometry is invalid")
+    counts = np.zeros(len(POLICY_CLASSES), dtype=np.int64)
+    destination_archive.parent.mkdir(mode=0o700, parents=True, exist_ok=True)
+    try:
+        with zipfile.ZipFile(source_archive) as source, zipfile.ZipFile(
+            destination_archive,
+            "x",
+        ) as destination:
+            for sequence in range(FRAME_COUNT):
+                member = f"masks/frame-{sequence + 1:06d}.png"
+                with source.open(member) as stream, Image.open(stream) as image:
+                    fine = np.asarray(image.convert("L"), dtype=np.uint8)
+                if fine.shape != (HEIGHT, WIDTH):
+                    raise VegetationPolicyVideoError(
+                        f"fine mask {member} has shape {fine.shape}, expected {(HEIGHT, WIDTH)}"
+                    )
+                coarse = lut[fine]
+                coarse[~valid_fov] = 9
+                counts += np.bincount(
+                    coarse.reshape(-1),
+                    minlength=len(POLICY_CLASSES),
+                )
+                buffer = io.BytesIO()
+                Image.fromarray(coarse, mode="L").save(
+                    buffer,
+                    format="PNG",
+                    compress_level=1,
+                    optimize=False,
+                )
+                destination.writestr(_zip_info(member), buffer.getvalue())
+    except (KeyError, OSError, ValueError, zipfile.BadZipFile) as exc:
+        destination_archive.unlink(missing_ok=True)
+        raise VegetationPolicyVideoError("fine mask archive is invalid") from exc
+    return [int(value) for value in counts]
+
+
+__all__ = [
+    "FRAME_COUNT",
+    "HEIGHT",
+    "POLICY_CLASSES",
+    "TAXONOMY_SCHEMA",
+    "VegetationPolicyVideoError",
+    "WIDTH",
+    "build_policy_mask_archive",
+    "fine_to_policy_lut",
+    "policy_taxonomy",
+]

src/k1link/laboratory/vegetation_shadow_lab.py

@@ -14,6 +14,15 @@ from pathlib import Path, PurePosixPath
 from typing import Any, Final
 
 from k1link.laboratory.m47_reference_graph import read_m47_reference_graph_lab
+from k1link.laboratory.m49_tgs_full_shadow import read_m49_tgs_full_shadow
+from k1link.laboratory.vegetation_mission_policy import (
+    load_vegetation_mission_policy,
+    load_vegetation_provider_label_map,
+)
+from k1link.laboratory.vegetation_policy_video import (
+    build_policy_mask_archive,
+    policy_taxonomy,
+)
 
 LAB_SCHEMA: Final = "missioncore.lab-v1-vegetation-shadow/v1"
 WORKER_SCHEMA: Final = "missioncore.lab-v1-goose-vegetation-run/v1"
@@ -315,6 +324,10 @@ def seal_vegetation_shadow_lab(
     output_root: Path,
     ddrnet_ravnoves_video_root: Path | None = None,
     m47_reference_graph_lab_root: Path | None = None,
+    mission_policy_path: Path | None = None,
+    provider_label_map_path: Path | None = None,
+    m49_tgs_full_shadow_root: Path | None = None,
+    valid_fov_mask_path: Path | None = None,
 ) -> Path:
     roots = {
         ("ddrnet", "goose"): ddrnet_goose_root.resolve(),
@@ -333,6 +346,18 @@ def seal_vegetation_shadow_lab(
     selected = _selected_candidate(results)
     if (ddrnet_ravnoves_video_root is None) != (m47_reference_graph_lab_root is None):
         raise VegetationShadowLabError("full-video Worker and M4.7 roots must be paired")
+    policy_inputs = (
+        mission_policy_path,
+        provider_label_map_path,
+        m49_tgs_full_shadow_root,
+        valid_fov_mask_path,
+    )
+    if any(value is not None for value in policy_inputs) and not all(
+        value is not None for value in policy_inputs
+    ):
+        raise VegetationShadowLabError("policy, provider map and full TGS roots must be paired")
+    if all(value is not None for value in policy_inputs) and ddrnet_ravnoves_video_root is None:
+        raise VegetationShadowLabError("policy review requires the full-video DDRNet result")
     route_video: dict[str, object] | None = None
     route_video_archive: Path | None = None
     video_result: dict[str, Any] | None = None
@@ -355,6 +380,36 @@ def seal_vegetation_shadow_lab(
             raise VegetationShadowLabError("M4.7 video binding differs from DDRNet source")
         route_video["m47_reference_graph_result_id"] = m47.result_id
 
+    mission_policy: dict[str, Any] | None = None
+    provider_label_map: dict[str, Any] | None = None
+    linked_tgs_result_id: str | None = None
+    if (
+        mission_policy_path is not None
+        and provider_label_map_path is not None
+        and m49_tgs_full_shadow_root is not None
+        and valid_fov_mask_path is not None
+        and route_video is not None
+    ):
+        repository_root = mission_policy_path.resolve().parents[2]
+        mission_policy = load_vegetation_mission_policy(
+            mission_policy_path.resolve(),
+            repository_root=repository_root,
+        )
+        provider_label_map = load_vegetation_provider_label_map(
+            provider_label_map_path.resolve(),
+            policy=mission_policy,
+        )
+        tgs = read_m49_tgs_full_shadow(m49_tgs_full_shadow_root)
+        tgs_source = _object(tgs.report.get("source"), "M4.9 full TGS source")
+        tgs_timeline = _object(tgs.report.get("timeline"), "M4.9 full TGS timeline")
+        if (
+            tgs_source.get("source_id") != "RAVNOVES00"
+            or tgs_source.get("linked_visual_result_id") != route_video["base_m4_result_id"]
+            or tgs_timeline.get("frame_count") != _VIDEO_FRAME_COUNT
+        ):
+            raise VegetationShadowLabError("full TGS timeline differs from vegetation video")
+        linked_tgs_result_id = tgs.result_id
+
     output_root.mkdir(mode=0o700, parents=True, exist_ok=True)
     temporary = Path(tempfile.mkdtemp(prefix=".lab-v1-vegetation-", dir=output_root))
     artifacts: list[dict[str, object]] = []
@@ -471,14 +526,96 @@ def seal_vegetation_shadow_lab(
                 temporary,
                 "video/ddrnet-semantic-masks.zip",
                 artifacts,
-                role="route-semantic-mask-archive",
+                role=(
+                    "route-fine-semantic-source-archive"
+                    if mission_policy is not None
+                    else "route-semantic-mask-archive"
+                ),
                 media_type="application/zip",
             )
-            route_video["mask_archive"] = {
+            raw_archive_proof = {
                 "path": archive_descriptor["path"],
                 "sha256": archive_descriptor["sha256"],
                 "byte_length": archive_descriptor["byte_length"],
             }
+            route_video["mask_archive"] = raw_archive_proof
+            route_video["view_kind"] = "fine-semantic-prediction"
+            if (
+                mission_policy is not None
+                and provider_label_map is not None
+                and linked_tgs_result_id is not None
+                and mission_policy_path is not None
+                and provider_label_map_path is not None
+                and valid_fov_mask_path is not None
+            ):
+                policy_archive = temporary / "video" / "coarse-material-policy-masks.zip"
+                valid_fov_destination = temporary / "video" / "valid-fov-mask.png"
+                shutil.copyfile(valid_fov_mask_path.resolve(strict=True), valid_fov_destination)
+                valid_fov_descriptor = {
+                    "role": "route-camera-valid-fov-mask",
+                    "path": "video/valid-fov-mask.png",
+                    "byte_length": valid_fov_destination.stat().st_size,
+                    "sha256": sha256_path(valid_fov_destination),
+                    "media_type": "image/png",
+                }
+                artifacts.append(valid_fov_descriptor)
+                policy_counts = build_policy_mask_archive(
+                    source_archive=route_video_archive,
+                    destination_archive=policy_archive,
+                    fine_taxonomy=_object(route_video["taxonomy"], "fine video taxonomy"),
+                    provider_label_map=provider_label_map,
+                    valid_fov_mask=valid_fov_destination,
+                )
+                policy_descriptor = {
+                    "role": "route-coarse-material-mask-archive",
+                    "path": "video/coarse-material-policy-masks.zip",
+                    "byte_length": policy_archive.stat().st_size,
+                    "sha256": sha256_path(policy_archive),
+                    "media_type": "application/zip",
+                }
+                artifacts.append(policy_descriptor)
+                route_video.update(
+                    {
+                        "view_kind": "coarse-material-policy-review",
+                        "source_mask_archive": raw_archive_proof,
+                        "mask_archive": {
+                            "path": policy_descriptor["path"],
+                            "sha256": policy_descriptor["sha256"],
+                            "byte_length": policy_descriptor["byte_length"],
+                        },
+                        "taxonomy": policy_taxonomy(),
+                        "aggregate_prediction_pixels": policy_counts,
+                        "linked_tgs_result_id": linked_tgs_result_id,
+                        "valid_fov": {
+                            "mask_path": valid_fov_descriptor["path"],
+                            "mask_sha256": valid_fov_descriptor["sha256"],
+                            "outside_valid_fov_class_id": 9,
+                        },
+                        "policy": {
+                            "profile_id": mission_policy["profile_id"],
+                            "profile_sha256": sha256_path(mission_policy_path),
+                            "provider_label_map_id": provider_label_map["profile_id"],
+                            "provider_label_map_sha256": sha256_path(
+                                provider_label_map_path
+                            ),
+                            "presets": mission_policy["presets"],
+                            "precedence": mission_policy["precedence"],
+                        },
+                        "fusion": {
+                            "mode": "synchronised-multilayer-review",
+                            "pixel_raster_fusion": False,
+                            "camera_material_layer": "DDRNet fine-64 to coarse material evidence",
+                            "camera_safety_veto_layer": "frozen M4 YOLOX camera proposals",
+                            "spatial_safety_veto_layer": "M4.9 full TGS gravity-local costmap",
+                            "temporal_consensus_owner": (
+                                "TGS causal rolling 1 s and metric obstacle tracks"
+                            ),
+                            "camera_semantic_temporal_filter": "none",
+                            "camera_valid_fov_filter": "sealed exact KB4 valid-FOV mask",
+                            "reason": "No admitted TGS-to-camera pixel projection exists.",
+                        },
+                    }
+                )
 
         candidate_metrics: dict[str, object] = {}
         for candidate in _CANDIDATES:
@@ -536,7 +673,11 @@ def seal_vegetation_shadow_lab(
             "method": {
                 "completeness": "complete",
                 "execution_class": "ai-inference",
-                "pipeline_id": "goose-fine64-ready-weights-to-ravnoves-policy-shadow/v1",
+                "pipeline_id": (
+                    "goose-fine64-to-coarse-material-plus-yolox-tgs-review/v1"
+                    if mission_policy is not None
+                    else "goose-fine64-ready-weights-to-ravnoves-policy-shadow/v1"
+                ),
             },
             "metrics": {"candidates": candidate_metrics},
             "decision": {
@@ -544,14 +685,41 @@ def seal_vegetation_shadow_lab(
                 "visual_shadow_ready": True,
                 "full_video_shadow_ready": route_video is not None,
                 "mission_policy_ready_for_configuration": True,
+                "multilayer_policy_review_ready": mission_policy is not None,
                 "navigation_accepted": False,
                 "production_accepted": False,
             },
             "limitations": [
                 "GOOSE validation is external-domain qualification, not RAVNOVES ground truth.",
-                "The full RAVNOVES DDRNet playback is prediction-only and has no independent labels.",
+                (
+                    "The coarse material playback is derived from per-frame DDRNet predictions "
+                    "and has no RAVNOVES truth."
+                    if mission_policy is not None
+                    else (
+                        "The full RAVNOVES DDRNet playback is prediction-only and has "
+                        "no independent labels."
+                    )
+                ),
                 "Vegetation semantics never clears rigid LiDAR/TGS occupancy.",
-                "Undefined pixels outside the 600x600 center crop remain fail-closed.",
+                (
+                    "Pixels outside the exact KB4 valid FOV are transparent UNOBSERVED evidence."
+                    if mission_policy is not None
+                    else "Undefined pixels outside the 600x600 center crop remain fail-closed."
+                ),
+                *(
+                    [
+                        (
+                            "TGS remains in gravity-local space; no uncalibrated pixel "
+                            "projection is fabricated."
+                        ),
+                        (
+                            "Temporal consensus comes from causal TGS and metric tracks; "
+                            "the camera material mask is not temporally filtered."
+                        ),
+                    ]
+                    if mission_policy is not None
+                    else []
+                ),
             ],
             "authority": authority,
             "catalogs": catalogs,
@@ -577,6 +745,10 @@ def _parse_args() -> argparse.Namespace:
     parser.add_argument("--output-root", type=Path, required=True)
     parser.add_argument("--ddrnet-ravnoves-video-root", type=Path)
     parser.add_argument("--m47-reference-graph-lab-root", type=Path)
+    parser.add_argument("--mission-policy-path", type=Path)
+    parser.add_argument("--provider-label-map-path", type=Path)
+    parser.add_argument("--m49-tgs-full-shadow-root", type=Path)
+    parser.add_argument("--valid-fov-mask-path", type=Path)
     return parser.parse_args()
 
 
@@ -590,6 +762,10 @@ def main() -> None:
         output_root=args.output_root,
         ddrnet_ravnoves_video_root=args.ddrnet_ravnoves_video_root,
         m47_reference_graph_lab_root=args.m47_reference_graph_lab_root,
+        mission_policy_path=args.mission_policy_path,
+        provider_label_map_path=args.provider_label_map_path,
+        m49_tgs_full_shadow_root=args.m49_tgs_full_shadow_root,
+        valid_fov_mask_path=args.valid_fov_mask_path,
     )
     print(destination)
 

src/k1link/web/app.py

@@ -138,7 +138,6 @@ from k1link.web.m49_physical_safety_playback_api import (
 )
 from k1link.web.m49_tgs_fail_closed_api import build_m49_tgs_fail_closed_router
 from k1link.web.m49_tgs_full_shadow_api import build_m49_tgs_full_shadow_router
-from k1link.web.vegetation_shadow_lab_api import build_vegetation_shadow_lab_router
 from k1link.web.map_api import (
     MapGatewayConfiguration,
     MapGatewayProxy,
@@ -165,6 +164,10 @@ from k1link.web.session_api import build_session_router
 from k1link.web.simulation_projects_api import build_simulation_projects_router
 from k1link.web.simulation_world_provider_api import build_simulation_world_provider_router
 from k1link.web.system_telemetry_api import build_system_telemetry_router
+from k1link.web.vegetation_shadow_lab_api import (
+    build_vegetation_benchmark_lab_router,
+    build_vegetation_shadow_lab_router,
+)
 from k1link.web.viewer_diagnostics_api import build_viewer_diagnostics_router
 
 REPOSITORY_ROOT = Path(__file__).resolve().parents[3]
@@ -1031,6 +1034,17 @@ app.include_router(
         ),
     )
 )
+app.include_router(
+    build_vegetation_benchmark_lab_router(
+        root_provider=lambda: (
+            REPOSITORY_ROOT
+            / ".runtime"
+            / "compute-experiments"
+            / "lab-v1-vegetation-benchmark"
+            / "results"
+        ),
+    )
+)
 app.include_router(
     build_m49_physical_safety_playback_router(
         root_provider=lambda: (

src/k1link/web/vegetation_shadow_lab_api.py

@@ -5,7 +5,6 @@ from __future__ import annotations
 import copy
 import hashlib
 import json
-import re
 import zipfile
 from collections.abc import Callable
 from functools import lru_cache
@@ -20,10 +19,9 @@ from k1link.laboratory.evidence_report import (
     LaboratoryEvidenceReportError,
     verify_laboratory_evidence_result,
 )
-from k1link.laboratory.vegetation_shadow_lab import LAB_SCHEMA, RESULT_PREFIX
+from k1link.laboratory.vegetation_shadow_lab import LAB_SCHEMA
 
 RootProvider = Callable[[], Path | None]
-RESULT_ID: Final = re.compile(rf"^{re.escape(RESULT_PREFIX)}[a-f0-9]{{64}}$")
 _MAX_DOCUMENT_BYTES: Final = 1024 * 1024
 _DEFINITION: Final = LaboratoryEvidenceDefinition(
     work_id="lab-v1-vegetation-shadow",
@@ -32,25 +30,55 @@ _DEFINITION: Final = LaboratoryEvidenceDefinition(
     document_name="result.json",
     result_schema_version=LAB_SCHEMA,
 )
+_BENCHMARK_DEFINITION: Final = LaboratoryEvidenceDefinition(
+    work_id="lab-v1-vegetation-benchmark",
+    runtime_relative_root=PurePosixPath("lab-v1-vegetation-benchmark/results"),
+    result_id_prefix="lab-v1-vegetation-benchmark",
+    document_name="result.json",
+    result_schema_version=LAB_SCHEMA,
+)
 
 
 def build_vegetation_shadow_lab_router(
     *, root_provider: RootProvider = lambda: None,
 ) -> APIRouter:
-    router = APIRouter(
+    return _build_vegetation_lab_router(
         prefix="/api/v1/laboratory/vegetation-shadow",
+        definition=_DEFINITION,
+        root_provider=root_provider,
+    )
+
+
+def build_vegetation_benchmark_lab_router(
+    *, root_provider: RootProvider = lambda: None,
+) -> APIRouter:
+    return _build_vegetation_lab_router(
+        prefix="/api/v1/laboratory/vegetation-benchmark",
+        definition=_BENCHMARK_DEFINITION,
+        root_provider=root_provider,
+    )
+
+
+def _build_vegetation_lab_router(
+    *,
+    prefix: str,
+    definition: LaboratoryEvidenceDefinition,
+    root_provider: RootProvider,
+) -> APIRouter:
+    router = APIRouter(
+        prefix=prefix,
         tags=["laboratory"],
     )
 
     @router.get("/{result_id}")
     def get_result(result_id: str) -> dict[str, object]:
-        candidate = _resolve_candidate(root_provider, result_id)
-        return {**copy.deepcopy(_read_verified(candidate)), "access": "read-only"}
+        candidate = _resolve_candidate(root_provider, definition, result_id)
+        return {**copy.deepcopy(_read_verified(candidate, definition)), "access": "read-only"}
 
     @router.get("/{result_id}/assets/{asset_path:path}")
     def get_asset(result_id: str, asset_path: str) -> FileResponse:
-        candidate = _resolve_candidate(root_provider, result_id)
-        manifest = _read_verified(candidate)
+        candidate = _resolve_candidate(root_provider, definition, result_id)
+        manifest = _read_verified(candidate, definition)
         artifacts = manifest.get("artifacts")
         if not isinstance(artifacts, list):
             raise HTTPException(status_code=404, detail="Vegetation LAB asset not found")
@@ -90,15 +118,36 @@ def build_vegetation_shadow_lab_router(
 
     @router.get("/{result_id}/masks/{sequence}")
     def get_video_mask(result_id: str, sequence: int) -> Response:
-        candidate = _resolve_candidate(root_provider, result_id)
-        manifest = _read_verified(candidate)
+        candidate = _resolve_candidate(root_provider, definition, result_id)
+        manifest = _read_verified(candidate, definition)
         route_video = manifest.get("route_video")
-        if not isinstance(route_video, dict) or not 0 <= sequence < 4489:
+        if (
+            not isinstance(route_video, dict)
+            or route_video.get("frame_count") != 4489
+            or not 0 <= sequence < 4489
+        ):
             raise HTTPException(status_code=404, detail="Vegetation video mask not found")
         archive = route_video.get("mask_archive")
-        if not isinstance(archive, dict) or archive.get("path") != "video/ddrnet-semantic-masks.zip":
+        archive_relative = archive.get("path") if isinstance(archive, dict) else None
+        if not isinstance(archive_relative, str):
             raise HTTPException(status_code=404, detail="Vegetation video mask not found")
-        archive_path = candidate / "video" / "ddrnet-semantic-masks.zip"
+        relative = PurePosixPath(archive_relative)
+        if (
+            relative.is_absolute()
+            or str(relative) != archive_relative
+            or any(part in {"", ".", ".."} for part in relative.parts)
+            or relative.suffix != ".zip"
+        ):
+            raise HTTPException(status_code=404, detail="Vegetation video mask not found")
+        artifacts = manifest.get("artifacts")
+        if not isinstance(artifacts, list) or not any(
+            isinstance(item, dict)
+            and item.get("path") == archive_relative
+            and item.get("media_type") == "application/zip"
+            for item in artifacts
+        ):
+            raise HTTPException(status_code=404, detail="Vegetation video mask not found")
+        archive_path = candidate.joinpath(*relative.parts)
         member = f"masks/frame-{sequence + 1:06d}.png"
         try:
             before = archive_path.stat()
@@ -130,9 +179,125 @@ def build_vegetation_shadow_lab_router(
             },
         )
 
+    @router.get("/{result_id}/route-masks/{layer}/{sequence}")
+    def get_full_route_mask(result_id: str, layer: str, sequence: int) -> Response:
+        candidate = _resolve_candidate(root_provider, definition, result_id)
+        manifest = _read_verified(candidate, definition)
+        route = manifest.get("route_full_review")
+        layers = route.get("layers") if isinstance(route, dict) else None
+        frame_count = route.get("frame_count") if isinstance(route, dict) else None
+        selected = layers.get(layer) if isinstance(layers, dict) else None
+        archive = selected.get("mask_archive") if isinstance(selected, dict) else None
+        archive_relative = archive.get("path") if isinstance(archive, dict) else None
+        if (
+            layer not in {"city", "vegetation"}
+            or not isinstance(frame_count, int)
+            or not 0 <= sequence < frame_count
+            or not isinstance(archive_relative, str)
+        ):
+            raise HTTPException(status_code=404, detail="Full-route semantic mask not found")
+        relative = PurePosixPath(archive_relative)
+        artifacts = manifest.get("artifacts")
+        if (
+            relative.is_absolute()
+            or str(relative) != archive_relative
+            or any(part in {"", ".", ".."} for part in relative.parts)
+            or relative.suffix != ".zip"
+            or not isinstance(artifacts, list)
+            or not any(
+                isinstance(item, dict)
+                and item.get("path") == archive_relative
+                and item.get("media_type") == "application/zip"
+                for item in artifacts
+            )
+        ):
+            raise HTTPException(status_code=404, detail="Full-route semantic mask not found")
+        return _zip_mask_response(candidate.joinpath(*relative.parts), sequence)
+
+    @router.get("/{result_id}/route-timeline")
+    def get_full_route_timeline(result_id: str) -> FileResponse:
+        candidate = _resolve_candidate(root_provider, definition, result_id)
+        manifest = _read_verified(candidate, definition)
+        route = manifest.get("route_full_review")
+        timeline = route.get("timeline") if isinstance(route, dict) else None
+        relative_text = timeline.get("path") if isinstance(timeline, dict) else None
+        frame_count = timeline.get("frame_count") if isinstance(timeline, dict) else None
+        byte_length = timeline.get("byte_length") if isinstance(timeline, dict) else None
+        sha256 = timeline.get("sha256") if isinstance(timeline, dict) else None
+        if (
+            not isinstance(relative_text, str)
+            or frame_count != route.get("frame_count")
+            or byte_length != frame_count * 8
+            or not isinstance(sha256, str)
+            or len(sha256) != 64
+        ):
+            raise HTTPException(status_code=404, detail="Full-route timeline not found")
+        relative = PurePosixPath(relative_text)
+        artifacts = manifest.get("artifacts")
+        if (
+            relative.is_absolute()
+            or str(relative) != relative_text
+            or any(part in {"", ".", ".."} for part in relative.parts)
+            or not isinstance(artifacts, list)
+            or not any(
+                isinstance(item, dict)
+                and item.get("path") == relative_text
+                and item.get("byte_length") == byte_length
+                and item.get("sha256") == sha256
+                and item.get("media_type") == "application/octet-stream"
+                for item in artifacts
+            )
+        ):
+            raise HTTPException(status_code=404, detail="Full-route timeline not found")
+        path = candidate.joinpath(*relative.parts)
+        if not path.is_file() or path.is_symlink() or path.stat().st_size != byte_length:
+            raise HTTPException(status_code=404, detail="Full-route timeline not found")
+        return FileResponse(
+            path,
+            media_type="application/octet-stream",
+            headers={
+                "Cache-Control": "private, max-age=31536000, immutable",
+                "ETag": f'"{sha256}"',
+                "X-Content-Type-Options": "nosniff",
+            },
+        )
+
     return router
 
 
+def _zip_mask_response(archive_path: Path, sequence: int) -> Response:
+    member = f"masks/frame-{sequence + 1:06d}.png"
+    try:
+        before = archive_path.stat()
+        with zipfile.ZipFile(archive_path) as frozen:
+            info = frozen.getinfo(member)
+            if info.is_dir() or info.file_size < 8 or info.file_size > 1024 * 1024:
+                raise ValueError("Semantic mask member is invalid")
+            payload = frozen.read(info)
+        after = archive_path.stat()
+        if (
+            before.st_size != after.st_size
+            or before.st_mtime_ns != after.st_mtime_ns
+            or len(payload) != info.file_size
+        ):
+            raise ValueError("Semantic mask archive changed during read")
+    except (KeyError, OSError, ValueError, zipfile.BadZipFile):
+        raise HTTPException(
+            status_code=503,
+            detail="Semantic mask failed verification",
+        ) from None
+    digest = hashlib.sha256(payload).hexdigest()
+    return Response(
+        content=payload,
+        media_type="image/png",
+        headers={
+            "Cache-Control": "private, max-age=31536000, immutable",
+            "ETag": f'"{digest}"',
+            "X-Content-Type-Options": "nosniff",
+        },
+    )
+
+
 def _configured_root(provider: RootProvider) -> Path | None:
     candidate = provider()
     if candidate is None:
@@ -147,9 +312,13 @@ def _configured_root(provider: RootProvider) -> Path | None:
     return root if root.is_dir() else None
 
 
-def _resolve_candidate(provider: RootProvider, result_id: str) -> Path:
+def _resolve_candidate(
+    provider: RootProvider,
+    definition: LaboratoryEvidenceDefinition,
+    result_id: str,
+) -> Path:
     root = _configured_root(provider)
-    if root is None or RESULT_ID.fullmatch(result_id) is None:
+    if root is None or definition.result_id_pattern.fullmatch(result_id) is None:
         raise HTTPException(status_code=404, detail="Vegetation LAB result not found")
     candidate = root / result_id
     if candidate.is_symlink():
@@ -163,7 +332,10 @@ def _resolve_candidate(provider: RootProvider, result_id: str) -> Path:
     return resolved
 
 
-def _read_verified(candidate: Path) -> dict[str, Any]:
+def _read_verified(
+    candidate: Path,
+    definition: LaboratoryEvidenceDefinition,
+) -> dict[str, Any]:
     try:
         rows: list[tuple[str, int, int, int, int]] = []
         for path in sorted(candidate.rglob("*"), key=lambda item: item.as_posix()):
@@ -181,19 +353,39 @@ def _read_verified(candidate: Path) -> dict[str, Any]:
             status_code=503,
             detail="Vegetation LAB evidence failed verification",
         ) from None
-    return _read_verified_cached(str(candidate), signature)
+    return _read_verified_cached(
+        str(candidate),
+        signature,
+        definition.work_id,
+        str(definition.runtime_relative_root),
+        definition.result_id_prefix,
+        definition.document_name,
+        definition.result_schema_version,
+    )
 
 
 @lru_cache(maxsize=16)
 def _read_verified_cached(
     candidate_text: str,
     signature: tuple[tuple[str, int, int, int, int], ...],
+    work_id: str,
+    runtime_relative_root: str,
+    result_id_prefix: str,
+    document_name: str,
+    result_schema_version: str,
 ) -> dict[str, Any]:
     del signature
     candidate = Path(candidate_text)
+    definition = LaboratoryEvidenceDefinition(
+        work_id=work_id,
+        runtime_relative_root=PurePosixPath(runtime_relative_root),
+        result_id_prefix=result_id_prefix,
+        document_name=document_name,
+        result_schema_version=result_schema_version,
+    )
     try:
-        verify_laboratory_evidence_result(_DEFINITION, candidate)
-        path = candidate / "result.json"
+        verify_laboratory_evidence_result(definition, candidate)
+        path = candidate / definition.document_name
         if path.stat().st_size > _MAX_DOCUMENT_BYTES:
             raise LaboratoryEvidenceReportError("Vegetation LAB document is too large")
         payload = json.loads(path.read_text("utf-8"))
@@ -207,4 +399,7 @@ def _read_verified_cached(
     return payload
 
 
-__all__ = ["build_vegetation_shadow_lab_router"]
+__all__ = [
+    "build_vegetation_benchmark_lab_router",
+    "build_vegetation_shadow_lab_router",
+]

tests/test_e4_full_session_segmentation.py

@@ -104,3 +104,20 @@ def test_e4_class_fractions_use_only_valid_fov_pixels() -> None:
 
     assert {item["id"]: item["pixels"] for item in classes} == {1: 1, 4: 2, 7: 1}
     assert sum(float(item["fraction_of_valid_fov"]) for item in classes) == 1.0
+
+
+def test_e4_orchestrator_seals_a_single_decoder_gap_without_frame_shift() -> None:
+    path = (
+        Path(__file__).parents[1]
+        / "experiments"
+        / "perception"
+        / "worker"
+        / "Invoke-E4FullSessionSegmentation.ps1"
+    )
+    source = path.read_text(encoding="utf-8")
+    assert "-c:v h264_cuvid" in source
+    assert "-frame_pts 1" in source
+    assert '$decodedPath = Join-Path $decodedFramesRoot ("frame-{0}.png" -f $pts)' in source
+    assert "$repairs.Count -ge 1" in source
+    assert 'method = "duplicate-previous-decoded-frame"' in source
+    assert 'schema_version = "missioncore.recorded-video-decode-repair/v1"' in source

tests/test_lab_v1_goose_vegetation_benchmark.py

@@ -25,6 +25,12 @@ POWERSHELL_PATH = (
     / "worker"
     / "Invoke-LabV1VegetationGooseBenchmark.ps1"
 )
+RAV004_SOURCE_PATH = (
+    REPOSITORY_ROOT
+    / "config"
+    / "perception"
+    / "lab-v1-ravnoves004tree-full-video-source-v1.json"
+)
 
 
 def test_benchmark_contract_is_bounded_and_fail_closed() -> None:
@@ -93,3 +99,21 @@ def test_worker_wrapper_is_isolated_from_canonical_triton() -> None:
     assert '"--cap-drop", "ALL"' in source
     assert '"--security-opt", "no-new-privileges"' in source
     assert "if ($canonicalAfter -ne $canonicalBefore)" in source
+
+
+def test_rav004_full_video_profile_and_decoder_gap_are_explicit() -> None:
+    profile = json.loads(RAV004_SOURCE_PATH.read_text(encoding="utf-8"))
+    source_profile = profile["source"]
+    assert profile["schema_version"] == "missioncore.lab-v1-ravnoves-source/v1"
+    assert source_profile["source_job_id"] == (
+        "recorded-camera-eb2783c5480d56bda07c8af0"
+    )
+    assert source_profile["expected_frame_count"] == 6830
+    assert source_profile["base_m4_result_id"] is None
+    source = POWERSHELL_PATH.read_text(encoding="utf-8")
+    assert "-c:v h264_cuvid" in source
+    assert 'schema_version = "missioncore.recorded-video-decode-repair/v1"' in source
+    assert 'method = "duplicate-previous-decoded-frame"' in source
+    assert "$repairs.Count -ge 1" in source
+    assert '& docker @arguments 2>&1 | ForEach-Object { Write-Output $_ }' in source
+    assert 'if ($dockerExitCode -ne 0)' in source

tests/test_lab_v1_vegetation_integrated_shadow.py

@@ -0,0 +1,276 @@
+from __future__ import annotations
+
+import importlib.util
+import json
+import tarfile
+from pathlib import Path
+
+REPOSITORY_ROOT = Path(__file__).resolve().parents[1]
+EVIDENCE_PATH = (
+    REPOSITORY_ROOT
+    / "experiments/perception/worker/m49_t3_travel/"
+    "build_vegetation_integrated_graph_evidence.py"
+)
+ARTIFACT_PATH = (
+    REPOSITORY_ROOT / "scripts/build_lab_v1_vegetation_integrated_worker_artifact.py"
+)
+RUNNER_PATH = (
+    REPOSITORY_ROOT
+    / "experiments/perception/worker/lab_v1_vegetation_goose/"
+    "run_vegetation_integrated_load.py"
+)
+POWERSHELL_PATH = (
+    REPOSITORY_ROOT
+    / "experiments/perception/worker/Invoke-M49TgsIntegratedGraphShadow.ps1"
+)
+
+
+def load_module(name: str, path: Path):
+    spec = importlib.util.spec_from_file_location(name, path)
+    assert spec is not None and spec.loader is not None
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    return module
+
+
+EVIDENCE = load_module("vegetation_integrated_evidence", EVIDENCE_PATH)
+ARTIFACT = load_module("vegetation_integrated_artifact", ARTIFACT_PATH)
+
+
+def test_three_layer_gate_joins_exact_frames_and_preserves_false_authority(
+    tmp_path: Path,
+) -> None:
+    profile = tmp_path / "profile.json"
+    profile.write_text(
+        json.dumps(
+            {
+                "schema_version": EVIDENCE.PROFILE_SCHEMA,
+                "profile_id": "test",
+                "source": {"source_id": "RAVNOVES00", "requested_source_rate_hz": 12.0},
+                "stages": {
+                    "m49_graph_tgs": {"profile_sha256": "a" * 64},
+                    "vegetation": {
+                        "checkpoint_sha256": "b" * 64,
+                        "config_sha256": "c" * 64,
+                        "policy_sha256": "d" * 64,
+                        "provider_map_sha256": "e" * 64,
+                        "inference_stride": 2,
+                        "inference_phase_offset_ms": 40.0,
+                    },
+                },
+                "acceptance": {
+                    "minimum_graph_world_state_fps": 11.2,
+                    "minimum_vegetation_timeline_fps": 11.2,
+                    "minimum_vegetation_inference_fps": 5.6,
+                    "maximum_vegetation_inference_completion_p95_ms": 125.0,
+                    "maximum_semantic_evidence_source_age_ms": 125.0,
+                    "maximum_combined_output_age_p99_ms": 125.0,
+                },
+                "authority": {
+                    "commands_enabled": False,
+                    "actuation_allowed": False,
+                    "navigation_or_safety_accepted": False,
+                    "production_accepted": False,
+                },
+            }
+        ),
+        encoding="utf-8",
+    )
+    m49 = tmp_path / "m49.json"
+    m49.write_text(
+        json.dumps(
+            {
+                "schema_version": EVIDENCE.M49_SCHEMA,
+                "status": "passed",
+                "integrated_runtime_gate_passed": True,
+                "result_id": "m49-test",
+                "identity": {"profile_sha256": "a" * 64},
+                "performance": {"effective_world_state_fps": 11.8},
+                "accounting": {
+                    "graph_admitted": EVIDENCE.FRAME_COUNT,
+                    "graph_delivered": EVIDENCE.FRAME_COUNT,
+                    "tgs_timeline_frames": EVIDENCE.FRAME_COUNT,
+                    "tgs_capacity_drops": 0,
+                },
+            }
+        ),
+        encoding="utf-8",
+    )
+    vegetation = tmp_path / "vegetation.json"
+    vegetation.write_text(
+        json.dumps(
+            {
+                "schema_version": EVIDENCE.VEGETATION_SCHEMA,
+                "result_id": "vegetation-test",
+                "integrated_load_gate_passed": True,
+                "source": {"requested_source_rate_hz": 12.0},
+                "candidate": {"candidate_key": "ddrnet", "checkpoint_sha256": "b" * 64},
+                "identity": {
+                    "config_sha256": "c" * 64,
+                    "policy_sha256": "d" * 64,
+                    "provider_map_sha256": "e" * 64,
+                },
+                "execution": {
+                    "frame_count": EVIDENCE.FRAME_COUNT,
+                    "effective_fps": 11.75,
+                    "effective_timeline_fps": 11.75,
+                    "effective_inference_fps": 5.875,
+                    "inference_stride": 2,
+                    "inference_phase_offset_ms": 40.0,
+                    "inference_frame_count": 2245,
+                    "held_evidence_frame_count": 2244,
+                    "capacity_drop_count": 0,
+                },
+                "timing": {
+                    "completion_age_ms": {"p95": 25.0},
+                    "inference_completion_age_ms": {"p95": 25.0},
+                    "stage_ms": {"p95": 20.0},
+                    "inference_ms": {"p95": 18.0},
+                },
+                "resource": {"gpu_name": "test"},
+                "authority": {
+                    "commands_enabled": False,
+                    "actuation_allowed": False,
+                    "navigation_or_safety_accepted": False,
+                    "production_accepted": False,
+                },
+            }
+        ),
+        encoding="utf-8",
+    )
+    graph_frames = tmp_path / "graph.jsonl"
+    graph_frames.write_text(
+        "".join(
+            json.dumps(
+                {"source_envelope": {"sequence": index}, "completion_age_ns": 40_000_000}
+            )
+            + "\n"
+            for index in range(EVIDENCE.FRAME_COUNT)
+        ),
+        encoding="utf-8",
+    )
+    tgs_frames = tmp_path / "tgs.tsv"
+    tgs_frames.write_text(
+        "timeline_frame_index\tcompletion_age_ms\n"
+        + "".join(f"{index}\t5.0\n" for index in range(EVIDENCE.FRAME_COUNT)),
+        encoding="utf-8",
+    )
+    vegetation_frames = tmp_path / "vegetation.jsonl"
+    vegetation_frames.write_text(
+        "".join(
+            json.dumps(
+                {
+                    "schema_version": "missioncore.lab-v1-vegetation-integrated-frame/v2",
+                    "sequence": index,
+                    "completion_age_ms": 60.0 if index % 2 == 0 else 20.0,
+                    "inference_executed": index % 2 == 0,
+                    "inference_phase_offset_ms": 40.0 if index % 2 == 0 else 0.0,
+                    "semantic_source_sequence": index - (index % 2),
+                    "semantic_evidence_source_age_ms": 60.0
+                    if index % 2 == 0
+                    else 103.333333,
+                }
+            )
+            + "\n"
+            for index in range(EVIDENCE.FRAME_COUNT)
+        ),
+        encoding="utf-8",
+    )
+    telemetry = tmp_path / "telemetry.jsonl"
+    telemetry.write_text(
+        "".join(
+            json.dumps(
+                {
+                    "role": role,
+                    "cpu_percent": "10.0%",
+                    "memory_usage": "1GiB / 64GiB",
+                    "memory_percent": "1.56%",
+                }
+            )
+            + "\n"
+            for role in ("graph", "tgs", "triton", "vegetation")
+        ),
+        encoding="utf-8",
+    )
+    output = tmp_path / "result.json"
+
+    result = EVIDENCE.build(
+        profile_path=profile,
+        m49_result_path=m49,
+        graph_frames_path=graph_frames,
+        tgs_timing_path=tgs_frames,
+        vegetation_result_path=vegetation,
+        vegetation_frames_path=vegetation_frames,
+        telemetry_path=telemetry,
+        output_path=output,
+        release_sha256="f" * 64,
+    )
+
+    assert result["status"] == "passed"
+    assert result["source"]["joined_frame_count"] == EVIDENCE.FRAME_COUNT
+    assert result["performance"]["three_layer_output_age_ms"]["p99"] == 60.0
+    assert result["checks"]["authority_remains_false"] is True
+    assert result["production_accepted"] is False
+
+
+def test_integrated_release_is_deterministic_and_contains_one_vegetation_candidate(
+    monkeypatch, tmp_path: Path
+) -> None:
+    def fake_wheel(_source_root: Path, output: Path) -> Path:
+        output.mkdir(parents=True, exist_ok=True)
+        wheel = output / ARTIFACT.WHEEL_NAME
+        wheel.write_bytes(b"clean committed wheel\n")
+        return wheel
+
+    monkeypatch.setattr(ARTIFACT, "build_wheel", fake_wheel)
+    revision = "f" * 40
+    first = ARTIFACT.build_artifact(
+        "mission-core-vegetation-integrated-unit-001",
+        tmp_path / "first",
+        revision=revision,
+        source_root=REPOSITORY_ROOT,
+    )
+    second = ARTIFACT.build_artifact(
+        "mission-core-vegetation-integrated-unit-001",
+        tmp_path / "second",
+        revision=revision,
+        source_root=REPOSITORY_ROOT,
+    )
+
+    assert Path(first["artifact"]).read_bytes() == Path(second["artifact"]).read_bytes()
+    with tarfile.open(first["artifact"], "r:gz") as archive:
+        names = set(archive.getnames())
+        release_stream = archive.extractfile("payload/release.json")
+        assert release_stream is not None
+        release = json.loads(release_stream.read())
+    assert "payload/run_vegetation_integrated_load.py" in names
+    assert "payload/build_vegetation_integrated_graph_evidence.py" in names
+    assert (
+        "payload/lab-v1-vegetation-integrated-multirate-phased-shadow-v3.json"
+        in names
+    )
+    assert release["semantic_inference_rate_hz"] == 6.0
+    assert release["semantic_inference_phase_offset_ms"] == 40.0
+    assert release["scope"]["heavy_vegetation_candidates"] == ["ddrnet"]
+    assert all(value is False for value in release["authority"].values())
+
+
+def test_worker_gate_reuses_shared_barrier_and_keeps_canonical_triton_unchanged() -> None:
+    runner = RUNNER_PATH.read_text(encoding="utf-8")
+    wrapper = POWERSHELL_PATH.read_text(encoding="utf-8")
+    assert '"source-paced-multirate-integrated-shadow/v2"' in runner
+    assert "wait_for_shared_start(" in runner
+    assert '"bounded-compressed-scene-buffer/v1"' in runner
+    assert "buffer_compressed_video(" in runner
+    assert '"compressed_scene_prefetch": True' in runner
+    assert '"full_route_rgb_prefetch": False' in runner
+    assert "decode_source(source_capture, expected_size)" in runner
+    assert '"camera_semantics_can_clear_rigid_geometry": False' in runner
+    assert "--runtime-video-cache /tmp/vegetation-right.mp4" in wrapper
+    assert "--inference-stride 2" in wrapper
+    assert "--inference-phase-offset-ms 40.0" in wrapper
+    assert '--tmpfs "/tmp:rw,noexec,nosuid,size=2g"' in wrapper
+    assert "$VegetationLoadGate" in wrapper
+    assert '"vegetation"' in wrapper
+    assert "if ($canonicalAfter.Id -cne $canonicalId" not in wrapper
+    assert "$canonicalAfter.Id -cne $canonicalId" in wrapper

tests/test_laboratory_evidence_registry.py

@@ -127,9 +127,10 @@ def test_product_registry_declares_every_advanced_evidence_source() -> None:
         repository_root / "config" / "laboratories"
     )
 
-    assert len(registry.definitions) == 43
+    assert len(registry.definitions) == 44
     assert {item.work_id for item in registry.definitions} >= {
         "lab-v1-vegetation-shadow",
+        "lab-v1-vegetation-benchmark",
         "e31-source-binding",
         "e46j-raw-fisheye-realtime",
         "e47-semantic-slam-shadow",

tests/test_laboratory_value_review_registry.py

@@ -80,7 +80,7 @@ def test_product_value_review_registry_covers_reviewed_laboratory_families() ->
         root / "config" / "laboratory-value-review.json"
     )
 
-    assert len(registry.entries) == 41
+    assert len(registry.entries) == 42
     assert {entry.catalog_id for entry in registry.entries} >= {
         "e28-local-surface",
         "e46d-temporal-failure-audit",
@@ -94,4 +94,5 @@ def test_product_value_review_registry_covers_reviewed_laboratory_families() ->
         "m49-tgs-fail-closed-evidence",
         "m49-tgs-full-shadow",
         "lab-v1-vegetation-shadow",
+        "lab-v1-vegetation-benchmark",
     }

tests/test_vegetation_shadow_lab.py

@@ -1,23 +1,70 @@
 from __future__ import annotations
 
 import hashlib
+import io
 import json
+import shutil
+import struct
 import zipfile
 from pathlib import Path
 from types import SimpleNamespace
 
+import numpy as np
 from fastapi import FastAPI
 from fastapi.testclient import TestClient
+from PIL import Image
 
-from k1link.laboratory import LaboratoryEvidenceRegistry
+import k1link.laboratory.vegetation_policy_review as policy_review_module
+import k1link.laboratory.vegetation_policy_video as policy_video_module
 import k1link.laboratory.vegetation_shadow_lab as vegetation_lab_module
+from k1link.laboratory import LaboratoryEvidenceRegistry
 from k1link.laboratory.evidence_report import verify_laboratory_evidence_result
+from k1link.laboratory.vegetation_policy_review import seal_vegetation_policy_review
 from k1link.laboratory.vegetation_shadow_lab import seal_vegetation_shadow_lab
 from k1link.web.vegetation_shadow_lab_api import build_vegetation_shadow_lab_router
 
 REPOSITORY_ROOT = Path(__file__).resolve().parents[1]
 
 
+def test_coarse_policy_masks_mark_every_outside_fov_pixel_undefined(
+    tmp_path: Path,
+    monkeypatch,
+) -> None:
+    monkeypatch.setattr(policy_video_module, "FRAME_COUNT", 1)
+    monkeypatch.setattr(
+        policy_video_module,
+        "fine_to_policy_lut",
+        lambda _taxonomy, _provider_map: np.full(256, 4, dtype=np.uint8),
+    )
+    source = tmp_path / "fine.zip"
+    fine_buffer = io.BytesIO()
+    Image.new("L", (800, 600), color=1).save(fine_buffer, format="PNG")
+    with zipfile.ZipFile(source, "w") as archive:
+        archive.writestr("masks/frame-000001.png", fine_buffer.getvalue())
+
+    valid_fov = np.zeros((600, 800), dtype=np.uint8)
+    valid_fov[:, :400] = 255
+    valid_fov_path = tmp_path / "valid-fov.png"
+    Image.fromarray(valid_fov, mode="L").save(valid_fov_path)
+    destination = tmp_path / "coarse.zip"
+    counts = policy_video_module.build_policy_mask_archive(
+        source_archive=source,
+        destination_archive=destination,
+        fine_taxonomy={},
+        provider_label_map={},
+        valid_fov_mask=valid_fov_path,
+    )
+    with (
+        zipfile.ZipFile(destination) as archive,
+        Image.open(io.BytesIO(archive.read("masks/frame-000001.png"))) as image,
+    ):
+        coarse = np.asarray(image.convert("L"))
+    assert np.all(coarse[:, :400] == 4)
+    assert np.all(coarse[:, 400:] == 9)
+    assert counts[4] == 600 * 400
+    assert counts[9] == 600 * 400
+
+
 def _sha256(path: Path) -> str:
     return hashlib.sha256(path.read_bytes()).hexdigest()
 
@@ -224,8 +271,189 @@ def test_vegetation_shadow_lab_seals_autonomous_visual_evidence(
     assert mask.content == b"\x89PNG\r\n\x1a\n"
     assert mask.headers["cache-control"].endswith("immutable")
 
+    full_archive_payloads = (b"\x89PNG\r\n\x1a\ncity", b"\x89PNG\r\n\x1a\nvegetation")
+    full_timeline_payload = struct.pack("<2Q", 1_000_000_000, 1_100_000_000)
+    full_identity = dict(manifest["identity"])
+    full_route = {
+        "frame_count": 2,
+        "timeline": {
+            "path": "video/frame-source-times-ns.bin",
+            "sha256": hashlib.sha256(full_timeline_payload).hexdigest(),
+            "byte_length": len(full_timeline_payload),
+            "encoding": "uint64-le-nanoseconds",
+            "frame_count": 2,
+        },
+        "layers": {
+            layer: {"mask_archive": {"path": "video/full-route-masks.zip"}}
+            for layer in ("city", "vegetation")
+        },
+    }
+    full_identity["route_full_review"] = full_route
+    full_identity_sha = hashlib.sha256(
+        json.dumps(
+            full_identity,
+            ensure_ascii=False,
+            sort_keys=True,
+            separators=(",", ":"),
+        ).encode("utf-8")
+    ).hexdigest()
+    full_result_id = f"lab-v1-vegetation-shadow-{full_identity_sha}"
+    full_root = result_root.parent / full_result_id
+    shutil.copytree(result_root, full_root)
+    full_archive = full_root / "video" / "full-route-masks.zip"
+    full_archive.parent.mkdir(exist_ok=True)
+    with zipfile.ZipFile(full_archive, "x", compression=zipfile.ZIP_STORED) as frozen:
+        for sequence, payload in enumerate(full_archive_payloads, start=1):
+            frozen.writestr(f"masks/frame-{sequence:06d}.png", payload)
+    full_timeline = full_root / "video" / "frame-source-times-ns.bin"
+    full_timeline.write_bytes(full_timeline_payload)
+    full_manifest = dict(manifest)
+    full_manifest["result_id"] = full_result_id
+    full_manifest["identity"] = full_identity
+    full_manifest["identity_sha256"] = full_identity_sha
+    full_manifest["route_full_review"] = full_route
+    full_manifest["artifacts"] = [
+        *manifest["artifacts"],
+        {
+            "role": "full-route-mask-fixture",
+            "path": "video/full-route-masks.zip",
+            "byte_length": full_archive.stat().st_size,
+            "sha256": _sha256(full_archive),
+            "media_type": "application/zip",
+        },
+        {
+            "role": "full-route-frame-timeline",
+            "path": "video/frame-source-times-ns.bin",
+            "byte_length": full_timeline.stat().st_size,
+            "sha256": _sha256(full_timeline),
+            "media_type": "application/octet-stream",
+        },
+    ]
+    (full_root / "result.json").write_text(
+        json.dumps(full_manifest, ensure_ascii=False, sort_keys=True, separators=(",", ":"))
+        + "\n",
+        encoding="utf-8",
+    )
+    for layer, sequence, expected in (
+        ("city", 0, full_archive_payloads[0]),
+        ("vegetation", 1, full_archive_payloads[1]),
+    ):
+        response = client.get(
+            f"/api/v1/laboratory/vegetation-shadow/{full_result_id}"
+            f"/route-masks/{layer}/{sequence}"
+        )
+        assert response.status_code == 200
+        assert response.content == expected
+        assert response.headers["cache-control"].endswith("immutable")
+    assert client.get(
+        f"/api/v1/laboratory/vegetation-shadow/{full_result_id}/route-masks/city/2"
+    ).status_code == 404
+    timeline = client.get(
+        f"/api/v1/laboratory/vegetation-shadow/{full_result_id}/route-timeline"
+    )
+    assert timeline.status_code == 200
+    assert timeline.content == full_timeline_payload
+    assert timeline.headers["cache-control"].endswith("immutable")
+
     (result_root / asset_path).write_bytes(b"tampered")
     assert (
         client.get(f"/api/v1/laboratory/vegetation-shadow/{result_root.name}").status_code
         == 503
     )
+
+
+def test_policy_review_reuses_sealed_video_and_links_yolox_tgs(
+    tmp_path: Path,
+    monkeypatch,
+) -> None:
+    roots = {}
+    for candidate, vegetation_iou in (("ddrnet", 0.64), ("ppliteseg", 0.61)):
+        for mode in ("goose", "ravnoves"):
+            root = tmp_path / "worker" / f"{candidate}-{mode}"
+            _worker_result(root, candidate=candidate, mode=mode, vegetation_iou=vegetation_iou)
+            roots[(candidate, mode)] = root
+    video_root = tmp_path / "worker" / "ddrnet-ravnoves-video"
+    _video_worker_result(video_root)
+    m47_root = tmp_path / f"m47-reference-graph-lab-{'a' * 64}"
+    m47_root.mkdir()
+    base_m4_result_id = f"m4-threat-replay-{'f' * 64}"
+    monkeypatch.setattr(
+        vegetation_lab_module,
+        "read_m47_reference_graph_lab",
+        lambda _root: SimpleNamespace(
+            result_id=m47_root.name,
+            report={
+                "source": {"source_id": "RAVNOVES00"},
+                "visual_evidence": {
+                    "linked_result_id": base_m4_result_id,
+                    "timeline_frames": 4489,
+                },
+            },
+        ),
+    )
+    base_root = seal_vegetation_shadow_lab(
+        ddrnet_goose_root=roots[("ddrnet", "goose")],
+        ppliteseg_goose_root=roots[("ppliteseg", "goose")],
+        ddrnet_ravnoves_root=roots[("ddrnet", "ravnoves")],
+        ppliteseg_ravnoves_root=roots[("ppliteseg", "ravnoves")],
+        output_root=tmp_path / "results",
+        ddrnet_ravnoves_video_root=video_root,
+        m47_reference_graph_lab_root=m47_root,
+    )
+    tgs_result_id = f"m49-tgs-full-shadow-{'9' * 64}"
+    monkeypatch.setattr(
+        policy_review_module,
+        "read_m49_tgs_full_shadow",
+        lambda _root: SimpleNamespace(
+            result_id=tgs_result_id,
+            report={
+                "source": {
+                    "source_id": "RAVNOVES00",
+                    "linked_visual_result_id": base_m4_result_id,
+                },
+                "timeline": {"frame_count": 4489},
+            },
+        ),
+    )
+
+    def fake_policy_archive(**kwargs) -> list[int]:
+        shutil.copyfile(kwargs["source_archive"], kwargs["destination_archive"])
+        assert kwargs["valid_fov_mask"].is_file()
+        return [4489 * 800 * 600, *([0] * 9)]
+
+    monkeypatch.setattr(policy_review_module, "build_policy_mask_archive", fake_policy_archive)
+    valid_fov_mask = tmp_path / "valid-fov-mask.png"
+    Image.new("L", (800, 600), color=255).save(valid_fov_mask)
+    result_root = seal_vegetation_policy_review(
+        base_lab_root=base_root,
+        mission_policy_path=REPOSITORY_ROOT
+        / "config/perception/lab-v1-vegetation-mission-policy-v1.json",
+        provider_label_map_path=REPOSITORY_ROOT
+        / "config/perception/lab-v1-vegetation-provider-label-map-v1.json",
+        m49_tgs_full_shadow_root=tmp_path / "sealed-tgs",
+        valid_fov_mask_path=valid_fov_mask,
+        output_root=tmp_path / "results",
+        created_at_utc="2026-08-28T08:00:00+00:00",
+    )
+    manifest = json.loads((result_root / "result.json").read_text("utf-8"))
+    route = manifest["route_video"]
+    assert route["view_kind"] == "coarse-material-policy-review"
+    assert route["linked_tgs_result_id"] == tgs_result_id
+    assert route["fusion"]["pixel_raster_fusion"] is False
+    assert route["fusion"]["camera_semantic_temporal_filter"] == "none"
+    assert route["taxonomy"]["schema_version"] == (
+        "missioncore.lab-v1-terrain-policy-taxonomy/v1"
+    )
+    assert len(route["taxonomy"]["classes"]) == 10
+    assert route["valid_fov"]["outside_valid_fov_class_id"] == 9
+    assert len(manifest["artifacts"]) == 80
+    assert manifest["authority"]["commands_enabled"] is False
+    assert manifest["decision"]["multilayer_policy_review_ready"] is True
+
+    app = FastAPI()
+    app.include_router(build_vegetation_shadow_lab_router(root_provider=lambda: result_root.parent))
+    response = TestClient(app).get(
+        f"/api/v1/laboratory/vegetation-shadow/{result_root.name}/masks/0"
+    )
+    assert response.status_code == 200
+    assert response.content == b"\x89PNG\r\n\x1a\n"