diff --git a/apps/control-station/src/core/lidar/replayQuality.ts b/apps/control-station/src/core/lidar/replayQuality.ts
new file mode 100644
index 0000000..3604ab7
--- /dev/null
+++ b/apps/control-station/src/core/lidar/replayQuality.ts
@@ -0,0 +1,311 @@
+export interface LidarDistribution {
+  sampleCount: number;
+  minimum: number | null;
+  mean: number | null;
+  p50: number | null;
+  p95: number | null;
+  maximum: number | null;
+}
+
+export interface LidarPackSummary {
+  packId: string;
+  sessionId: string;
+  profileId: string;
+  pointFrames: number;
+  poseFrames: number;
+  points: number;
+  meanPointsPerFrame: number | null;
+  p95FrameIntervalMs: number | null;
+  poseCoverageFraction: number | null;
+  equivalenceStatus: "passed";
+  logicalContentSha256: string;
+  createdAtUtc: string | null;
+}
+
+export interface LidarReplayCatalog {
+  configured: boolean;
+  validTotal: number;
+  invalidTotal: number;
+  duplicateTotal: number;
+  items: LidarPackSummary[];
+}
+
+export interface LidarStageReadiness {
+  stage: string;
+  readiness: "ready" | "degraded" | "blocked";
+  reasons: string[];
+}
+
+export interface LidarReplayDetail {
+  pack: LidarPackSummary;
+  quality: {
+    fieldRetention: Record<string, boolean>;
+    pointCountPerFrame: LidarDistribution;
+    pointFrameIntervalMs: LidarDistribution;
+    intensity: LidarDistribution;
+    poseBinding: {
+      thresholdMs: number;
+      coveredPointFrames: number;
+      coverageFraction: number;
+      nearestDeltaMs: LidarDistribution;
+    };
+    limitations: string[];
+  };
+  equivalence: {
+    status: "passed";
+    arraysCompared: number;
+    arrayMismatches: number;
+  };
+  stages: LidarStageReadiness[];
+}
+
+export class LidarReplayContractError extends Error {}
+
+export class LidarReplayApiError extends Error {
+  constructor(message: string, readonly status: number | null = null) {
+    super(message);
+  }
+}
+
+type LidarFetch = (
+  input: RequestInfo | URL,
+  init?: RequestInit,
+) => Promise<Response>;
+
+const SAFE_PACK_ID = /^lidar-replay-pack-[a-f0-9]{64}$/;
+const SAFE_ID = /^[A-Za-z0-9][A-Za-z0-9._:/-]{0,159}$/;
+const SHA256 = /^[a-f0-9]{64}$/;
+
+function record(value: unknown, label: string): Record<string, unknown> {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new LidarReplayContractError(`${label}: ожидался объект`);
+  }
+  return value as Record<string, unknown>;
+}
+
+function array(value: unknown, label: string): unknown[] {
+  if (!Array.isArray(value)) {
+    throw new LidarReplayContractError(`${label}: ожидался массив`);
+  }
+  return value;
+}
+
+function string(value: unknown, label: string, pattern?: RegExp): string {
+  if (typeof value !== "string" || !value || (pattern && !pattern.test(value))) {
+    throw new LidarReplayContractError(`${label}: некорректная строка`);
+  }
+  return value;
+}
+
+function number(value: unknown, label: string, nullable = false): number | null {
+  if (nullable && value === null) return null;
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    throw new LidarReplayContractError(`${label}: некорректное число`);
+  }
+  return value;
+}
+
+function integer(value: unknown, label: string): number {
+  const parsed = number(value, label);
+  if (parsed === null || !Number.isInteger(parsed) || parsed < 0) {
+    throw new LidarReplayContractError(`${label}: ожидалось неотрицательное целое`);
+  }
+  return parsed;
+}
+
+function boolean(value: unknown, label: string): boolean {
+  if (typeof value !== "boolean") {
+    throw new LidarReplayContractError(`${label}: ожидался boolean`);
+  }
+  return value;
+}
+
+function distribution(value: unknown, label: string): LidarDistribution {
+  const source = record(value, label);
+  return {
+    sampleCount: integer(source.sample_count, `${label}.sample_count`),
+    minimum: number(source.minimum, `${label}.minimum`, true),
+    mean: number(source.mean, `${label}.mean`, true),
+    p50: number(source.p50, `${label}.p50`, true),
+    p95: number(source.p95, `${label}.p95`, true),
+    maximum: number(source.maximum, `${label}.maximum`, true),
+  };
+}
+
+function packSummary(value: unknown): LidarPackSummary {
+  const source = record(value, "LiDAR pack");
+  if (source.equivalence_status !== "passed") {
+    throw new LidarReplayContractError("LiDAR pack не прошёл equivalence gate");
+  }
+  return {
+    packId: string(source.pack_id, "pack_id", SAFE_PACK_ID),
+    sessionId: string(source.session_id, "session_id", SAFE_ID),
+    profileId: string(source.profile_id, "profile_id", SAFE_ID),
+    pointFrames: integer(source.point_frames, "point_frames"),
+    poseFrames: integer(source.pose_frames, "pose_frames"),
+    points: integer(source.points, "points"),
+    meanPointsPerFrame: number(source.mean_points_per_frame, "mean_points_per_frame", true),
+    p95FrameIntervalMs: number(source.p95_frame_interval_ms, "p95_frame_interval_ms", true),
+    poseCoverageFraction: number(
+      source.pose_coverage_fraction,
+      "pose_coverage_fraction",
+      true,
+    ),
+    equivalenceStatus: "passed",
+    logicalContentSha256: string(
+      source.logical_content_sha256,
+      "logical_content_sha256",
+      SHA256,
+    ),
+    createdAtUtc:
+      source.created_at_utc === null || source.created_at_utc === undefined
+        ? null
+        : string(source.created_at_utc, "created_at_utc"),
+  };
+}
+
+export function parseLidarReplayCatalog(value: unknown): LidarReplayCatalog {
+  const source = record(value, "LiDAR catalog");
+  if (source.schema_version !== "missioncore.lidar-replay-pack-catalog/v1") {
+    throw new LidarReplayContractError("LiDAR catalog schema несовместима");
+  }
+  return {
+    configured: boolean(source.configured, "configured"),
+    validTotal: integer(source.valid_total, "valid_total"),
+    invalidTotal: integer(source.invalid_total, "invalid_total"),
+    duplicateTotal: integer(source.duplicate_total, "duplicate_total"),
+    items: array(source.items, "items").map(packSummary),
+  };
+}
+
+export function parseLidarReplayDetail(value: unknown): LidarReplayDetail {
+  const source = record(value, "LiDAR detail");
+  if (
+    source.schema_version !== "missioncore.lidar-replay-pack-detail/v1"
+    || source.access !== "read-only"
+  ) {
+    throw new LidarReplayContractError("LiDAR detail contract несовместим");
+  }
+  const quality = record(source.quality, "quality");
+  const retention = record(quality.field_retention, "field_retention");
+  const fieldRetention: Record<string, boolean> = {};
+  for (const [key, retained] of Object.entries(retention)) {
+    fieldRetention[key] = boolean(retained, `field_retention.${key}`);
+  }
+  const poseBinding = record(quality.pose_binding, "pose_binding");
+  const equivalence = record(source.equivalence, "equivalence");
+  if (equivalence.status !== "passed") {
+    throw new LidarReplayContractError("LiDAR equivalence gate не пройден");
+  }
+  const readiness = record(source.readiness, "readiness");
+  const stages = array(readiness.stages, "readiness.stages").map((value) => {
+    const stage = record(value, "readiness stage");
+    const readinessValue = stage.readiness;
+    if (
+      readinessValue !== "ready"
+      && readinessValue !== "degraded"
+      && readinessValue !== "blocked"
+    ) {
+      throw new LidarReplayContractError("Неизвестный LiDAR readiness status");
+    }
+    const normalizedReadiness: LidarStageReadiness["readiness"] = readinessValue;
+    return {
+      stage: string(stage.stage, "stage", SAFE_ID),
+      readiness: normalizedReadiness,
+      reasons: array(stage.reasons, "stage.reasons").map((reason) =>
+        string(reason, "stage reason", SAFE_ID)
+      ),
+    };
+  });
+  return {
+    pack: packSummary(source.pack),
+    quality: {
+      fieldRetention,
+      pointCountPerFrame: distribution(quality.point_count_per_frame, "point_count"),
+      pointFrameIntervalMs: distribution(
+        quality.point_frame_interval_ms,
+        "point_interval",
+      ),
+      intensity: distribution(quality.intensity_0_255, "intensity"),
+      poseBinding: {
+        thresholdMs: number(poseBinding.threshold_ms, "pose threshold") ?? 0,
+        coveredPointFrames: integer(
+          poseBinding.covered_point_frames,
+          "covered point frames",
+        ),
+        coverageFraction: number(
+          poseBinding.coverage_fraction,
+          "pose coverage",
+        ) ?? 0,
+        nearestDeltaMs: distribution(
+          poseBinding.nearest_delta_ms,
+          "nearest pose delta",
+        ),
+      },
+      limitations: array(quality.limitations, "limitations").map((item) =>
+        string(item, "limitation")
+      ),
+    },
+    equivalence: {
+      status: "passed",
+      arraysCompared: integer(equivalence.arrays_compared, "arrays_compared"),
+      arrayMismatches: integer(
+        equivalence.array_mismatches,
+        "array_mismatches",
+      ),
+    },
+    stages,
+  };
+}
+
+async function responseJson(
+  response: Response,
+  fallback: string,
+): Promise<unknown> {
+  let value: unknown;
+  try {
+    value = await response.json();
+  } catch {
+    throw new LidarReplayApiError(fallback, response.status);
+  }
+  if (!response.ok) {
+    const detail = record(value, "API error").detail;
+    throw new LidarReplayApiError(
+      typeof detail === "string" && detail.trim() ? detail : fallback,
+      response.status,
+    );
+  }
+  return value;
+}
+
+export async function fetchLidarReplayCatalog(
+  options: { signal?: AbortSignal; fetcher?: LidarFetch } = {},
+): Promise<LidarReplayCatalog> {
+  const fetcher = options.fetcher ?? fetch;
+  const response = await fetcher("/api/v1/lidar/replay-packs?limit=50", {
+    method: "GET",
+    headers: { Accept: "application/json" },
+    signal: options.signal,
+  });
+  return parseLidarReplayCatalog(
+    await responseJson(response, "Не удалось получить каталог LiDAR replay."),
+  );
+}
+
+export async function fetchLidarReplayDetail(
+  packId: string,
+  options: { signal?: AbortSignal; fetcher?: LidarFetch } = {},
+): Promise<LidarReplayDetail> {
+  if (!SAFE_PACK_ID.test(packId)) {
+    throw new LidarReplayContractError("Некорректный LiDAR pack id");
+  }
+  const fetcher = options.fetcher ?? fetch;
+  const response = await fetcher(`/api/v1/lidar/replay-packs/${packId}`, {
+    method: "GET",
+    headers: { Accept: "application/json" },
+    signal: options.signal,
+  });
+  return parseLidarReplayDetail(
+    await responseJson(response, "Не удалось получить LiDAR quality report."),
+  );
+}
diff --git a/apps/control-station/src/productModel.ts b/apps/control-station/src/productModel.ts
index 86f18bc..2539690 100644
--- a/apps/control-station/src/productModel.ts
+++ b/apps/control-station/src/productModel.ts
@@ -18,6 +18,7 @@ export type WorkspaceKind =
   | "timeline"
   | "missions"
   | "catalog"
+  | "lidar-quality"
   | "polygon-run";
 
 export type CapabilityStatus = "active" | "ready" | "contract" | "later";
@@ -586,6 +587,18 @@ export const workspaces: WorkspaceDefinition[] = [
       },
     ],
   },
+  {
+    id: "lidar-quality",
+    root: "data",
+    label: "Качество LiDAR",
+    title: "Качество LiDAR",
+    eyebrow: "ДАННЫЕ / LIDAR EVIDENCE",
+    description:
+      "Проверенные поля сканера, частота, плотность, intensity, pose coverage и допуск следующих алгоритмов.",
+    icon: "activity",
+    kind: "lidar-quality",
+    groups: [],
+  },
   {
     id: "entities",
     root: "data",
diff --git a/apps/control-station/src/styles/responsive.css b/apps/control-station/src/styles/responsive.css
index cf1ca12..8ebd791 100644
--- a/apps/control-station/src/styles/responsive.css
+++ b/apps/control-station/src/styles/responsive.css
@@ -13,7 +13,8 @@
   .mission-layout,
   .polygon-live-layout,
   .polygon-run-layout,
-  .polygon-run-evidence-grid {
+  .polygon-run-evidence-grid,
+  .lidar-quality-grid {
     grid-template-columns: 1fr;
   }
 
@@ -157,6 +158,10 @@
     grid-template-columns: 1fr;
   }
 
+  .lidar-quality-facts {
+    grid-template-columns: 1fr;
+  }
+
   .polygon-run-identity dl {
     grid-template-columns: 1fr;
   }
diff --git a/apps/control-station/src/styles/workspaces.css b/apps/control-station/src/styles/workspaces.css
index 4ed9b94..b5e1baf 100644
--- a/apps/control-station/src/styles/workspaces.css
+++ b/apps/control-station/src/styles/workspaces.css
@@ -803,6 +803,157 @@
   font-weight: 650;
 }
 
+.lidar-quality-workspace {
+  gap: 1rem;
+}
+
+.lidar-quality-message {
+  display: grid;
+  min-height: 12rem;
+  align-content: center;
+  justify-items: start;
+  gap: 0.7rem;
+}
+
+.lidar-quality-message h2,
+.lidar-quality-message p {
+  margin: 0;
+}
+
+.lidar-quality-message p {
+  max-width: 46rem;
+  color: var(--nodedc-text-muted);
+  font-size: 0.76rem;
+  line-height: 1.55;
+}
+
+.lidar-quality-grid {
+  display: grid;
+  grid-template-columns: minmax(0, 0.9fr) minmax(0, 1.1fr);
+  gap: 0.85rem;
+}
+
+.lidar-quality-panel {
+  min-width: 0;
+}
+
+.lidar-quality-facts {
+  display: grid;
+  grid-template-columns: repeat(2, minmax(0, 1fr));
+  gap: 0.65rem;
+  margin-top: 1rem;
+}
+
+.lidar-quality-facts > div {
+  display: grid;
+  gap: 0.32rem;
+  border: 1px solid var(--station-hairline);
+  border-radius: 0.8rem;
+  background: rgb(255 255 255 / 0.025);
+  padding: 0.72rem;
+}
+
+.lidar-quality-facts span,
+.lidar-pack-catalog footer,
+.lidar-readiness-list small {
+  color: var(--nodedc-text-muted);
+  font-size: 0.62rem;
+  line-height: 1.45;
+}
+
+.lidar-quality-facts strong {
+  overflow: hidden;
+  color: var(--nodedc-text-primary);
+  font-size: 0.72rem;
+  text-overflow: ellipsis;
+}
+
+.lidar-retention-list {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 0.42rem;
+  margin-top: 0.8rem;
+}
+
+.lidar-retention-list span {
+  display: inline-flex;
+  align-items: center;
+  gap: 0.35rem;
+  border: 1px solid var(--station-hairline);
+  border-radius: 999px;
+  padding: 0.34rem 0.52rem;
+  color: var(--nodedc-text-secondary);
+  font-size: 0.58rem;
+}
+
+.lidar-retention-list i {
+  width: 0.38rem;
+  height: 0.38rem;
+  border-radius: 50%;
+  background: rgb(185 255 74 / 0.9);
+}
+
+.lidar-retention-list span[data-retained="false"] i {
+  background: rgb(255 97 97 / 0.9);
+}
+
+.lidar-readiness-list,
+.lidar-pack-list {
+  display: grid;
+  gap: 0.48rem;
+  margin-top: 1rem;
+}
+
+.lidar-readiness-list > div,
+.lidar-pack-list > button {
+  display: flex;
+  min-width: 0;
+  align-items: center;
+  justify-content: space-between;
+  gap: 0.8rem;
+  border: 1px solid var(--station-hairline);
+  border-radius: 0.78rem;
+  background: rgb(255 255 255 / 0.02);
+  padding: 0.68rem 0.76rem;
+}
+
+.lidar-readiness-list > div > div,
+.lidar-pack-list > button > div {
+  display: grid;
+  min-width: 0;
+  gap: 0.24rem;
+}
+
+.lidar-readiness-list strong,
+.lidar-pack-list strong {
+  color: var(--nodedc-text-primary);
+  font-size: 0.68rem;
+}
+
+.lidar-pack-list > button {
+  width: 100%;
+  color: inherit;
+  text-align: left;
+  cursor: pointer;
+}
+
+.lidar-pack-list > button:hover,
+.lidar-pack-list > button[data-selected="true"] {
+  border-color: rgb(185 255 74 / 0.42);
+  background: rgb(185 255 74 / 0.055);
+}
+
+.lidar-pack-list small {
+  color: var(--nodedc-text-muted);
+  font-size: 0.6rem;
+}
+
+.lidar-pack-catalog footer {
+  display: grid;
+  gap: 0.22rem;
+  margin-top: 0.8rem;
+}
+
 .overview-grid {
   display: grid;
   grid-template-columns: minmax(0, 1.55fr) minmax(19rem, 0.75fr);
diff --git a/apps/control-station/src/workspaces/LidarQualityWorkspace.tsx b/apps/control-station/src/workspaces/LidarQualityWorkspace.tsx
new file mode 100644
index 0000000..3e73a15
--- /dev/null
+++ b/apps/control-station/src/workspaces/LidarQualityWorkspace.tsx
@@ -0,0 +1,269 @@
+import { useEffect, useState } from "react";
+import {
+  Button,
+  GlassSurface,
+  StatusBadge,
+} from "@nodedc/ui-react";
+
+import {
+  fetchLidarReplayCatalog,
+  fetchLidarReplayDetail,
+  type LidarReplayCatalog,
+  type LidarReplayDetail,
+  type LidarStageReadiness,
+} from "../core/lidar/replayQuality";
+import { MetricCard } from "../components/MetricCard";
+import type { WorkspaceDefinition } from "../productModel";
+
+function formatNumber(value: number | null, digits = 1): string {
+  if (value === null) return "—";
+  return value.toLocaleString("ru-RU", { maximumFractionDigits: digits });
+}
+
+function formatFraction(value: number | null): string {
+  return value === null ? "—" : `${(value * 100).toLocaleString("ru-RU", {
+    maximumFractionDigits: 1,
+  })}%`;
+}
+
+function readinessTone(
+  readiness: LidarStageReadiness["readiness"],
+): "success" | "warning" | "danger" {
+  if (readiness === "ready") return "success";
+  if (readiness === "degraded") return "warning";
+  return "danger";
+}
+
+function readinessLabel(readiness: LidarStageReadiness["readiness"]): string {
+  if (readiness === "ready") return "Готов";
+  if (readiness === "degraded") return "С ограничениями";
+  return "Заблокирован";
+}
+
+function errorMessage(error: unknown): string {
+  return error instanceof Error && error.message.trim()
+    ? error.message
+    : "Не удалось прочитать LiDAR evidence.";
+}
+
+export function LidarQualityWorkspace({
+  definition,
+}: {
+  definition: WorkspaceDefinition;
+}) {
+  const [catalog, setCatalog] = useState<LidarReplayCatalog | null>(null);
+  const [detail, setDetail] = useState<LidarReplayDetail | null>(null);
+  const [selectedPackId, setSelectedPackId] = useState<string | null>(null);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState<string | null>(null);
+  const [reloadGeneration, setReloadGeneration] = useState(0);
+
+  useEffect(() => {
+    const controller = new AbortController();
+    setLoading(true);
+    setError(null);
+    void (async () => {
+      try {
+        const nextCatalog = await fetchLidarReplayCatalog({
+          signal: controller.signal,
+        });
+        if (controller.signal.aborted) return;
+        setCatalog(nextCatalog);
+        const target = selectedPackId ?? nextCatalog.items[0]?.packId ?? null;
+        if (!target) {
+          setDetail(null);
+          return;
+        }
+        const nextDetail = await fetchLidarReplayDetail(target, {
+          signal: controller.signal,
+        });
+        if (controller.signal.aborted) return;
+        setSelectedPackId(target);
+        setDetail(nextDetail);
+      } catch (loadError) {
+        if (controller.signal.aborted) return;
+        setDetail(null);
+        setError(errorMessage(loadError));
+      } finally {
+        if (!controller.signal.aborted) setLoading(false);
+      }
+    })();
+    return () => controller.abort();
+  }, [reloadGeneration, selectedPackId]);
+
+  return (
+    <div className="standard-workspace lidar-quality-workspace">
+      <section className="workspace-lead workspace-lead--compact">
+        <div>
+          <span className="section-eyebrow">{definition.eyebrow}</span>
+          <h2>{definition.title}</h2>
+          <p>{definition.description}</p>
+        </div>
+        <span className="workspace-lead__note">Только проверенные replay-артефакты</span>
+      </section>
+
+      {loading && !detail ? (
+        <GlassSurface className="lidar-quality-message" padding="lg">
+          <StatusBadge tone="accent">Проверка evidence</StatusBadge>
+          <h2>Читаем LiDAR replay и quality report</h2>
+          <p>Интерфейс покажет pack только после проверки manifest, hashes и equivalence gate.</p>
+        </GlassSurface>
+      ) : error ? (
+        <GlassSurface className="lidar-quality-message" padding="lg">
+          <StatusBadge tone="danger">Данные недоступны</StatusBadge>
+          <h2>LiDAR quality report не открыт</h2>
+          <p>{error}</p>
+          <Button
+            size="compact"
+            variant="secondary"
+            onClick={() => setReloadGeneration((value) => value + 1)}
+          >
+            Повторить
+          </Button>
+        </GlassSurface>
+      ) : !detail ? (
+        <GlassSurface className="lidar-quality-message" padding="lg">
+          <StatusBadge tone={catalog?.configured ? "neutral" : "warning"}>
+            {catalog?.configured ? "Каталог пуст" : "Storage не настроен"}
+          </StatusBadge>
+          <h2>Lossless LiDAR replay пока не опубликован</h2>
+          <p>
+            После подготовки первого v2 pack здесь появятся field retention, cadence,
+            intensity, pose coverage и readiness следующих стадий.
+          </p>
+        </GlassSurface>
+      ) : (
+        <>
+          <section className="metrics-grid" aria-label="Качество LiDAR replay">
+            <MetricCard
+              featured
+              eyebrow="ТОЧЕЧНЫХ КАДРОВ"
+              value={detail.pack.pointFrames.toLocaleString("ru-RU")}
+              detail={`${detail.pack.points.toLocaleString("ru-RU")} точек сохранено`}
+            />
+            <MetricCard
+              eyebrow="СРЕДНЕЕ ТОЧЕК"
+              value={formatNumber(detail.pack.meanPointsPerFrame, 0)}
+              detail="На один lio_pcl кадр"
+            />
+            <MetricCard
+              eyebrow="P95 ИНТЕРВАЛА"
+              value={formatNumber(detail.pack.p95FrameIntervalMs)}
+              unit="мс"
+              detail="По exact host monotonic time"
+            />
+            <MetricCard
+              eyebrow="POSE COVERAGE"
+              value={formatFraction(detail.pack.poseCoverageFraction)}
+              detail={`Порог ${formatNumber(detail.quality.poseBinding.thresholdMs)} мс`}
+            />
+          </section>
+
+          <div className="lidar-quality-grid">
+            <GlassSurface className="lidar-quality-panel" padding="lg">
+              <header className="panel-heading">
+                <div>
+                  <span className="section-eyebrow">ЦЕЛОСТНОСТЬ</span>
+                  <h2>Lossless replay v2</h2>
+                </div>
+                <StatusBadge tone="success">Equivalence passed</StatusBadge>
+              </header>
+              <div className="lidar-quality-facts">
+                <div>
+                  <span>Сессия</span>
+                  <strong>{detail.pack.sessionId}</strong>
+                </div>
+                <div>
+                  <span>Сверено массивов</span>
+                  <strong>{detail.equivalence.arraysCompared}</strong>
+                </div>
+                <div>
+                  <span>Несовпадений</span>
+                  <strong>{detail.equivalence.arrayMismatches}</strong>
+                </div>
+                <div>
+                  <span>Intensity p50 / p95</span>
+                  <strong>
+                    {formatNumber(detail.quality.intensity.p50)} /{" "}
+                    {formatNumber(detail.quality.intensity.p95)}
+                  </strong>
+                </div>
+              </div>
+              <div className="lidar-retention-list">
+                {Object.entries(detail.quality.fieldRetention).map(([field, retained]) => (
+                  <span key={field} data-retained={retained ? "true" : "false"}>
+                    <i aria-hidden="true" />
+                    {field.replaceAll("_", " ")}
+                  </span>
+                ))}
+              </div>
+            </GlassSurface>
+
+            <GlassSurface className="lidar-quality-panel" padding="lg">
+              <header className="panel-heading">
+                <div>
+                  <span className="section-eyebrow">ДОПУСК СТАДИЙ</span>
+                  <h2>Что можно запускать</h2>
+                </div>
+              </header>
+              <div className="lidar-readiness-list">
+                {detail.stages.map((stage) => (
+                  <div key={stage.stage}>
+                    <div>
+                      <strong>{stage.stage}</strong>
+                      <small>
+                        {stage.reasons.length
+                          ? stage.reasons.join(" · ")
+                          : "Входной контракт выполнен"}
+                      </small>
+                    </div>
+                    <StatusBadge tone={readinessTone(stage.readiness)}>
+                      {readinessLabel(stage.readiness)}
+                    </StatusBadge>
+                  </div>
+                ))}
+              </div>
+            </GlassSurface>
+          </div>
+
+          <GlassSurface className="lidar-pack-catalog" padding="lg">
+            <header className="panel-heading">
+              <div>
+                <span className="section-eyebrow">REPLAY PACKS</span>
+                <h2>Проверенные записи</h2>
+              </div>
+              <small>
+                {catalog?.validTotal ?? 0} valid · {catalog?.duplicateTotal ?? 0} superseded ·{" "}
+                {catalog?.invalidTotal ?? 0} rejected
+              </small>
+            </header>
+            <div className="lidar-pack-list">
+              {catalog?.items.map((pack) => (
+                <button
+                  type="button"
+                  key={pack.packId}
+                  data-selected={pack.packId === detail.pack.packId ? "true" : undefined}
+                  onClick={() => setSelectedPackId(pack.packId)}
+                >
+                  <div>
+                    <strong>{pack.sessionId}</strong>
+                    <small>
+                      {pack.pointFrames.toLocaleString("ru-RU")} кадров ·{" "}
+                      {pack.points.toLocaleString("ru-RU")} точек
+                    </small>
+                  </div>
+                  <StatusBadge tone="success">Passed</StatusBadge>
+                </button>
+              ))}
+            </div>
+            <footer>
+              {detail.quality.limitations.map((limitation) => (
+                <span key={limitation}>{limitation}</span>
+              ))}
+            </footer>
+          </GlassSurface>
+        </>
+      )}
+    </div>
+  );
+}
diff --git a/apps/control-station/src/workspaces/Workspaces.tsx b/apps/control-station/src/workspaces/Workspaces.tsx
index fa87dee..65b68cd 100644
--- a/apps/control-station/src/workspaces/Workspaces.tsx
+++ b/apps/control-station/src/workspaces/Workspaces.tsx
@@ -57,6 +57,7 @@ import {
 import { finiteMetric, formatNumber, pipelineLatency, sourceModeLabel } from "../presentation";
 import type { SceneSettings } from "../sceneSettings";
 import { PolygonRunWorkspace } from "./PolygonRunWorkspace";
+import { LidarQualityWorkspace } from "./LidarQualityWorkspace";
 
 function statusTone(status: CapabilityStatus): "success" | "accent" | "warning" | "neutral" {
   if (status === "active") return "success";
@@ -1306,6 +1307,8 @@ export function WorkspaceRenderer(props: WorkspaceRendererProps) {
       return <MissionWorkspace {...props} />;
     case "catalog":
       return <CatalogWorkspace {...props} />;
+    case "lidar-quality":
+      return <LidarQualityWorkspace definition={props.definition} />;
     case "polygon-run":
       return <PolygonRunWorkspace route={props.polygonRunRoute} />;
     case "device":
diff --git a/apps/control-station/test/lidarReplayQuality.test.mjs b/apps/control-station/test/lidarReplayQuality.test.mjs
new file mode 100644
index 0000000..e58feaa
--- /dev/null
+++ b/apps/control-station/test/lidarReplayQuality.test.mjs
@@ -0,0 +1,179 @@
+import assert from "node:assert/strict";
+import { after, before, test } from "node:test";
+
+import { createServer } from "vite";
+
+let server;
+let parseLidarReplayCatalog;
+let parseLidarReplayDetail;
+let fetchLidarReplayCatalog;
+let fetchLidarReplayDetail;
+let LidarReplayContractError;
+let workspaceById;
+
+before(async () => {
+  server = await createServer({
+    appType: "custom",
+    logLevel: "silent",
+    server: { middlewareMode: true },
+  });
+  ({
+    parseLidarReplayCatalog,
+    parseLidarReplayDetail,
+    fetchLidarReplayCatalog,
+    fetchLidarReplayDetail,
+    LidarReplayContractError,
+  } = await server.ssrLoadModule("/src/core/lidar/replayQuality.ts"));
+  ({ workspaceById } = await server.ssrLoadModule("/src/productModel.ts"));
+});
+
+after(async () => {
+  await server?.close();
+});
+
+const packId = `lidar-replay-pack-${"a".repeat(64)}`;
+
+function summary(overrides = {}) {
+  return {
+    pack_id: packId,
+    session_id: "20260719T220917Z_viewer_live",
+    profile_id: "xgrids-k1-lidar-replay-pack/v2",
+    point_frames: 10,
+    pose_frames: 12,
+    points: 1234,
+    mean_points_per_frame: 123.4,
+    p95_frame_interval_ms: 98.7,
+    pose_coverage_fraction: 0.9,
+    equivalence_status: "passed",
+    logical_content_sha256: "b".repeat(64),
+    created_at_utc: "2026-07-25T00:00:00Z",
+    authority: {
+      commands_enabled: false,
+      navigation_or_safety_accepted: false,
+    },
+    ...overrides,
+  };
+}
+
+function distribution() {
+  return {
+    sample_count: 10,
+    minimum: 1,
+    mean: 2,
+    p50: 2,
+    p95: 3,
+    maximum: 4,
+  };
+}
+
+function catalog(overrides = {}) {
+  return {
+    schema_version: "missioncore.lidar-replay-pack-catalog/v1",
+    configured: true,
+    items: [summary()],
+    valid_total: 1,
+    invalid_total: 0,
+    duplicate_total: 0,
+    access: "read-only",
+    ...overrides,
+  };
+}
+
+function detail() {
+  return {
+    schema_version: "missioncore.lidar-replay-pack-detail/v1",
+    access: "read-only",
+    pack: summary({ created_at_utc: undefined }),
+    quality: {
+      schema_version: "missioncore.lidar-quality-report/v1",
+      field_retention: {
+        xyz_map: true,
+        raw_xyz: true,
+        raw_rgbi: true,
+        intensity_low_byte: true,
+        source_sequence: true,
+        header_seq_stamp_scaler: true,
+        host_epoch_ns: true,
+        host_monotonic_ns: true,
+      },
+      point_count_per_frame: distribution(),
+      point_frame_interval_ms: distribution(),
+      intensity_0_255: distribution(),
+      pose_binding: {
+        threshold_ms: 100,
+        covered_point_frames: 9,
+        coverage_fraction: 0.9,
+        nearest_delta_ms: distribution(),
+      },
+      limitations: ["vendor-mapped increment"],
+    },
+    equivalence: {
+      schema_version: "missioncore.lidar-live-replay-equivalence/v1",
+      status: "passed",
+      arrays_compared: 24,
+      array_mismatches: 0,
+    },
+    readiness: {
+      stages: [
+        {
+          stage: "lidar-3d-detection",
+          readiness: "degraded",
+          reasons: ["pretrained-domain-expects-sensor-scan"],
+        },
+        {
+          stage: "lidar-inertial-slam",
+          readiness: "blocked",
+          reasons: ["lio-requires-unregistered-sensor-scans"],
+        },
+      ],
+    },
+  };
+}
+
+function jsonResponse(payload, status = 200) {
+  return new Response(JSON.stringify(payload), {
+    status,
+    headers: { "content-type": "application/json" },
+  });
+}
+
+test("LiDAR catalog and detail decode only passed, path-free evidence", () => {
+  const parsedCatalog = parseLidarReplayCatalog(catalog());
+  const parsedDetail = parseLidarReplayDetail(detail());
+
+  assert.equal(parsedCatalog.items[0].packId, packId);
+  assert.equal(parsedDetail.quality.fieldRetention.raw_rgbi, true);
+  assert.equal(parsedDetail.equivalence.arrayMismatches, 0);
+  assert.equal(parsedDetail.stages[0].readiness, "degraded");
+  assert.equal("path" in parsedCatalog.items[0], false);
+});
+
+test("LiDAR contract refuses replay that did not pass equivalence", () => {
+  assert.throws(
+    () => parseLidarReplayCatalog(catalog({
+      items: [summary({ equivalence_status: "failed" })],
+    })),
+    LidarReplayContractError,
+  );
+});
+
+test("LiDAR fetchers use read-only endpoints and workspace is registered", async () => {
+  const calls = [];
+  const fetcher = async (input, init) => {
+    calls.push({ input: String(input), method: init?.method });
+    return String(input).includes(packId)
+      ? jsonResponse(detail())
+      : jsonResponse(catalog());
+  };
+  const parsedCatalog = await fetchLidarReplayCatalog({ fetcher });
+  const parsedDetail = await fetchLidarReplayDetail(packId, { fetcher });
+
+  assert.equal(parsedCatalog.validTotal, 1);
+  assert.equal(parsedDetail.pack.packId, packId);
+  assert.deepEqual(calls, [
+    { input: "/api/v1/lidar/replay-packs?limit=50", method: "GET" },
+    { input: `/api/v1/lidar/replay-packs/${packId}`, method: "GET" },
+  ]);
+  assert.equal(workspaceById("lidar-quality").root, "data");
+  assert.equal(workspaceById("lidar-quality").kind, "lidar-quality");
+});
diff --git a/docs/10_EXTERNAL_PERCEPTION_WORKER.md b/docs/10_EXTERNAL_PERCEPTION_WORKER.md
index 22e5d08..3cb782f 100644
--- a/docs/10_EXTERNAL_PERCEPTION_WORKER.md
+++ b/docs/10_EXTERNAL_PERCEPTION_WORKER.md
@@ -7,6 +7,13 @@ successfully is not evidence that its LiDAR assumptions are satisfied. In
 particular, the accepted E10 replay pack v1 has no intensity, and the current K1
 stream is a vendor map increment rather than an unregistered sensor sweep.
 
+`missioncore.lidar-replay-pack/v2` closes the field-retention gap without
+rewriting v1. Its manifest binds exact raw/metadata evidence, logical point/pose
+content, an immutable scanner-quality report and a source-vs-persisted
+equivalence report. The React surface reads those reports through the read-only
+`/api/v1/lidar/replay-packs` boundary; CUDA/TensorRT and ROS do not move into the
+browser.
+
 ## Boundary
 
 ```text
diff --git a/docs/13_LIDAR_WORKER_PRODUCT_AND_ROADMAP.md b/docs/13_LIDAR_WORKER_PRODUCT_AND_ROADMAP.md
index 972dc0e..9aaadd7 100644
--- a/docs/13_LIDAR_WORKER_PRODUCT_AND_ROADMAP.md
+++ b/docs/13_LIDAR_WORKER_PRODUCT_AND_ROADMAP.md
@@ -1,7 +1,7 @@
 # LiDAR worker: product value, evidence boundary and implementation roadmap
 
 Date: 2026-07-25
-Status: accepted architecture plan; L0 contract implemented
+Status: accepted architecture plan; L0 and L1 implemented
 Scope: real scanner records, replay and future live shadow processing
 Explicitly out of scope: Unreal U0/U1, Gaussian assets and simulator rendering
 
@@ -63,6 +63,12 @@ The executable truth is
 `src/k1link/compute/lidar_contract.py`. It assesses each stage as `ready`,
 `degraded` or `blocked` and refuses to infer absent sensor fields.
 
+`missioncore.lidar-replay-pack/v2` is now the admitted field-retaining replay
+input. It preserves raw integer XYZ, derived map XYZ, raw uint32 `rgbi`, its
+verified intensity low byte, source/payload identity, header seq/stamp/scaler,
+exact host epoch/monotonic receive times and the independent pose stream. Pack
+v1 remains immutable for E10–E26.
+
 ## 3. Current system result
 
 The existing camera-heavy E10–E26 line is valuable and remains in place:
@@ -156,21 +162,36 @@ memory, zero-copy or batching optimizations are accepted.
   existing external worker report.
 - [x] Keep authority diagnostic-only.
 
-### L1 — lossless replay v2 and scanner quality
+### L1 — lossless replay v2 and scanner quality — complete
 
-- [ ] Create a new replay schema; do not rewrite pack v1.
-- [ ] Preserve XYZ, intensity, source sequence/header stamp/scaler and exact
+- [x] Create a new replay schema; do not rewrite pack v1.
+- [x] Preserve XYZ, intensity, source sequence/header stamp/scaler and exact
   host capture/receive times.
-- [ ] Record explicitly absent ring, per-point time and IMU fields.
-- [ ] Add bounded reports for frame gaps, arrival jitter, points/frame, range
-  distribution, intensity distribution and pose coverage.
-- [ ] Compare live-vs-replay decoding byte-for-byte on a frozen slice.
-- [ ] Publish the report to the React observation view without bundling a
+- [x] Record explicitly absent ring, per-point time and IMU fields.
+- [x] Add immutable reports for sequence gaps, arrival jitter, points/frame,
+  intensity distribution and pose coverage. Sensor-frame range remains
+  explicitly unavailable because the source is a vendor map increment.
+- [x] Compare source native capture vs persisted replay fields byte-for-byte on
+  a frozen real slice.
+- [x] Publish the report to the React observation view without bundling a
   desktop renderer.
 
 Exit: a recording cannot be called detector-ready when required fields were
 dropped, and an operator can distinguish scanner dropout from model failure.
 
+Accepted real slice:
+
+- session `20260719T220917Z_viewer_live`;
+- 66 point frames, 226,963 points and 70 pose frames;
+- 24 arrays compared, zero mismatches, identical logical content SHA-256;
+- pose coverage 100% at a 100 ms host-arrival gate;
+- 3,439 mean points/frame;
+- point-frame interval p50 80.4 ms, p95 186.6 ms and maximum 1,153.4 ms;
+- intensity p50 248 and p95 255 on the verified `[0, 255]` low byte.
+
+The long interval tail is evidence to investigate in the scanner/transport
+quality line. It is not repaired or hidden by replay.
+
 ### L2 — geometric baseline
 
 - [ ] Run Patchwork++ over the frozen XYZI slice.
diff --git a/docs/adr/0018-lidar-evidence-before-models.md b/docs/adr/0018-lidar-evidence-before-models.md
index 472556c..44a3457 100644
--- a/docs/adr/0018-lidar-evidence-before-models.md
+++ b/docs/adr/0018-lidar-evidence-before-models.md
@@ -45,7 +45,8 @@ be mistaken for geometric validity.
 - Nvblox is blocked until the LiDAR scan geometry and timing/pose contract are
   admitted.
 - LiDAR odometry and LiDAR-inertial SLAM are blocked for current K1 evidence.
-- L1 lossless replay and scanner-quality telemetry precede new model installs.
+- L1 lossless replay and scanner-quality telemetry are implemented and precede
+  new model installs.
 - Future scanners, simulation providers and datasets can use the same
   readiness contract without being forced into K1-specific code.
 
diff --git a/docs/adr/0019-lossless-lidar-replay-v2.md b/docs/adr/0019-lossless-lidar-replay-v2.md
new file mode 100644
index 0000000..2f5f1c4
--- /dev/null
+++ b/docs/adr/0019-lossless-lidar-replay-v2.md
@@ -0,0 +1,62 @@
+# ADR 0019: preserve LiDAR fields before detector evaluation
+
+Date: 2026-07-25
+Status: accepted and implemented
+
+## Context
+
+The accepted E10 LiDAR replay pack v1 is bound to the E10–E26 result line. It
+stores camera-selected map XYZ and pose but drops the verified intensity byte,
+raw `rgbi`, raw integer coordinates, source header fields and exact host
+timestamps. Mutating that schema would invalidate historical evidence while
+still leaving detector and scanner-quality assumptions implicit.
+
+Mission Core also needs one operator surface that can distinguish capture
+quality from later model quality. A successful worker process or a visually
+plausible point cloud is not that evidence.
+
+## Decision
+
+1. Add the separate immutable `missioncore.lidar-replay-pack/v2`; never rewrite
+   E10 replay pack v1.
+2. Bind each v2 pack to the source raw capture and aligned metadata hashes.
+3. Preserve point capture sequence, payload size, exact host epoch and
+   monotonic receive times, header seq/stamp/scaler, raw integer XYZ, derived
+   map XYZ, raw uint32 `rgbi` and its verified uint8 intensity low byte.
+4. Preserve pose messages independently with their source/header/timing,
+   position, quaternion, distance and accuracy fields.
+5. Hash the canonical logical arrays, not only the compressed NPZ bytes.
+6. Re-decode the immutable source and compare all persisted arrays before a
+   pack is accepted. Any mismatch fails the pack.
+7. Publish a separate hashed scanner-quality report: cadence, density,
+   intensity, sequence anomalies and nearest-pose coverage.
+8. Expose only path-free, read-only catalog/detail responses to React.
+9. Deduplicate superseded producers by logical content identity in the UI.
+10. Keep command, navigation and safety authority false.
+
+## Consequences
+
+- PointPillars now has retained XYZI evidence for replay, but remains degraded
+  because K1 supplies vendor-mapped increments rather than admitted raw sweeps.
+- Scanner/transport timing tails become visible before model tuning.
+- Reprocessing can compare new worker/model generations against exactly the
+  same point and pose evidence.
+- The browser displays qualification facts but never loads raw NPZ payloads or
+  runs GPU perception.
+- Ring, per-point time, scan geometry and IMU remain explicitly absent.
+- Nvblox, LiDAR odometry and LIO/SLAM remain blocked.
+
+## Accepted real evidence
+
+The first accepted real pack was built from
+`20260719T220917Z_viewer_live`: 66 point frames, 226,963 points, 70 pose frames,
+24 exact array comparisons and zero mismatches. Pose coverage was 100% at the
+100 ms host-arrival threshold. Point-frame interval was p50 80.4 ms, p95
+186.6 ms and maximum 1,153.4 ms.
+
+## References
+
+- `src/k1link/compute/lidar_replay.py`
+- `src/k1link/web/lidar_api.py`
+- `apps/control-station/src/workspaces/LidarQualityWorkspace.tsx`
+- `docs/13_LIDAR_WORKER_PRODUCT_AND_ROADMAP.md`
diff --git a/experiments/perception/prepare_lidar_replay_pack_v2.py b/experiments/perception/prepare_lidar_replay_pack_v2.py
new file mode 100644
index 0000000..e2d7f16
--- /dev/null
+++ b/experiments/perception/prepare_lidar_replay_pack_v2.py
@@ -0,0 +1,56 @@
+#!/usr/bin/env python3
+"""Build a field-retaining LiDAR replay pack from immutable K1 capture evidence."""
+
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+
+from k1link.compute import LidarReplayPackV2, build_lidar_replay_pack_v2
+
+
+def arguments() -> argparse.Namespace:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--capture", type=Path, required=True)
+    parser.add_argument("--output-root", type=Path, required=True)
+    parser.add_argument("--session-id")
+    parser.add_argument("--pose-coverage-threshold-ms", type=float, default=100.0)
+    return parser.parse_args()
+
+
+def main() -> int:
+    args = arguments()
+    output = build_lidar_replay_pack_v2(
+        args.capture,
+        args.output_root,
+        session_id=args.session_id,
+        pose_coverage_threshold_ms=args.pose_coverage_threshold_ms,
+    )
+    pack = LidarReplayPackV2(output)
+    try:
+        print(
+            json.dumps(
+                {
+                    "pack_id": pack.pack_id,
+                    "output": str(output),
+                    "session_id": pack.identity["session_id"],
+                    "point_frames": pack.point_frame_count,
+                    "pose_frames": pack.pose_frame_count,
+                    "points": pack.point_count,
+                    "equivalence": pack.equivalence["status"],
+                    "pose_coverage_fraction": pack.quality["pose_binding"][
+                        "coverage_fraction"
+                    ],
+                },
+                ensure_ascii=False,
+                sort_keys=True,
+            )
+        )
+    finally:
+        pack.close()
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/src/k1link/compute/__init__.py b/src/k1link/compute/__init__.py
index 98ce7ad..2de393d 100644
--- a/src/k1link/compute/__init__.py
+++ b/src/k1link/compute/__init__.py
@@ -50,6 +50,7 @@ from .lab_instances import (
 )
 from .lidar_contract import (
     K1_LAB_LIDAR_PACK_V1_PROFILE,
+    K1_LIDAR_PACK_V2_PROFILE,
     K1_LIVE_LIDAR_PROFILE,
     LIDAR_EVIDENCE_PROFILE_SCHEMA,
     LIDAR_READINESS_SCHEMA,
@@ -68,6 +69,19 @@ from .lidar_contract import (
     lidar_readiness_document,
     sensor_frame_xyzi,
 )
+from .lidar_replay import (
+    LIDAR_EQUIVALENCE_REPORT_SCHEMA,
+    LIDAR_QUALITY_REPORT_SCHEMA,
+    LIDAR_REPLAY_PACK_SCHEMA,
+    LidarReplayError,
+    LidarReplayPackV2,
+    LidarReplayPointFrame,
+    LidarReplayPoseFrame,
+    build_lidar_replay_pack_v2,
+    lidar_pack_catalog_item,
+    lidar_pack_detail,
+    verify_lidar_replay_equivalence,
+)
 from .live_perception import (
     LIVE_INGRESS_SCHEMA,
     LIVE_INGRESS_WIRE_SCHEMA,
@@ -139,7 +153,10 @@ __all__ = [
     "EvaluationPackFrame",
     "LatestWinsQueue",
     "LIDAR_EVIDENCE_PROFILE_SCHEMA",
+    "LIDAR_EQUIVALENCE_REPORT_SCHEMA",
+    "LIDAR_QUALITY_REPORT_SCHEMA",
     "LIDAR_READINESS_SCHEMA",
+    "LIDAR_REPLAY_PACK_SCHEMA",
     "LIVE_INGRESS_SCHEMA",
     "LIVE_INGRESS_WIRE_SCHEMA",
     "LiveIngressEvent",
@@ -152,6 +169,10 @@ __all__ = [
     "LidarPoseStatus",
     "LidarQualityMonitor",
     "LidarReadiness",
+    "LidarReplayError",
+    "LidarReplayPackV2",
+    "LidarReplayPointFrame",
+    "LidarReplayPoseFrame",
     "LidarRepresentation",
     "LidarStageAssessment",
     "LidarTimeBasis",
@@ -167,6 +188,7 @@ __all__ = [
     "MultiratePerceptionQualificationResult",
     "QUALIFICATION_POLICY",
     "K1_LAB_LIDAR_PACK_V1_PROFILE",
+    "K1_LIDAR_PACK_V2_PROFILE",
     "K1_LIVE_LIDAR_PROFILE",
     "QueueSnapshot",
     "RecordedCalibratedFusion",
@@ -201,6 +223,7 @@ __all__ = [
     "validate_multirate_perception_qualification_result",
     "prepare_recorded_qualification_slice",
     "assess_lidar_profile",
+    "build_lidar_replay_pack_v2",
     "DetectionFrame",
     "ObjectDetection",
     "RecordedPerceptionOverlayError",
@@ -221,5 +244,8 @@ __all__ = [
     "validate_tracked_fusion_qualification_result",
     "validate_annotation_workspace",
     "lidar_readiness_document",
+    "lidar_pack_catalog_item",
+    "lidar_pack_detail",
     "sensor_frame_xyzi",
+    "verify_lidar_replay_equivalence",
 ]
diff --git a/src/k1link/compute/lidar_contract.py b/src/k1link/compute/lidar_contract.py
index ed142c4..1091cd3 100644
--- a/src/k1link/compute/lidar_contract.py
+++ b/src/k1link/compute/lidar_contract.py
@@ -621,3 +621,17 @@ K1_LAB_LIDAR_PACK_V1_PROFILE: Final = LidarEvidenceProfile(
     lidar_imu_extrinsic_available=False,
     camera_extrinsic_available=True,
 )
+
+K1_LIDAR_PACK_V2_PROFILE: Final = LidarEvidenceProfile(
+    profile_id="xgrids-k1-lidar-replay-pack/v2",
+    representation=LidarRepresentation.VENDOR_MAP_INCREMENT,
+    coordinate_space=LidarCoordinateSpace.MAP,
+    coordinate_frame="map",
+    frame_time_basis=LidarTimeBasis.HOST_ARRIVAL,
+    point_fields=(LidarPointField.XYZ, LidarPointField.INTENSITY),
+    pose_status=LidarPoseStatus.BEST_EFFORT,
+    scan_geometry_known=False,
+    imu_samples_available=False,
+    lidar_imu_extrinsic_available=False,
+    camera_extrinsic_available=True,
+)
diff --git a/src/k1link/compute/lidar_replay.py b/src/k1link/compute/lidar_replay.py
new file mode 100644
index 0000000..d934382
--- /dev/null
+++ b/src/k1link/compute/lidar_replay.py
@@ -0,0 +1,1023 @@
+from __future__ import annotations
+
+import hashlib
+import json
+import math
+import os
+import re
+import shutil
+import time
+from dataclasses import dataclass
+from datetime import UTC, datetime
+from pathlib import Path
+from typing import Any, Final
+
+import numpy as np
+import numpy.typing as npt
+
+from k1link.data_plane import (
+    ConsumerFrameContext,
+    DecodedPointCloudView,
+    DecodedPoseView,
+)
+from k1link.device_plugins.xgrids_k1.protocol.streams import (
+    LioPointCloudFrame,
+    LioPoseFrame,
+    decode_lio_pcl,
+    decode_lio_pose,
+)
+from k1link.device_plugins.xgrids_k1.viewer.messages import StreamMessage
+from k1link.device_plugins.xgrids_k1.viewer.replay import iter_replay_messages
+
+from .lidar_contract import (
+    K1_LIDAR_PACK_V2_PROFILE,
+    LidarEvidenceProfile,
+    lidar_readiness_document,
+)
+
+LIDAR_REPLAY_PACK_SCHEMA: Final = "missioncore.lidar-replay-pack/v2"
+LIDAR_QUALITY_REPORT_SCHEMA: Final = "missioncore.lidar-quality-report/v1"
+LIDAR_EQUIVALENCE_REPORT_SCHEMA: Final = (
+    "missioncore.lidar-live-replay-equivalence/v1"
+)
+LIDAR_REPLAY_ARRAYS_NAME: Final = "lidar-replay.npz"
+LIDAR_QUALITY_REPORT_NAME: Final = "quality-report.json"
+LIDAR_EQUIVALENCE_REPORT_NAME: Final = "equivalence-report.json"
+LIDAR_MANIFEST_NAME: Final = "manifest.json"
+DEFAULT_POSE_COVERAGE_THRESHOLD_MS: Final = 100.0
+
+_PACK_ID = re.compile(r"^lidar-replay-pack-[a-f0-9]{64}$")
+_SAFE_SESSION_ID = re.compile(r"^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$")
+_POINT_TOPIC_SUFFIX = "/lio_pcl"
+_POSE_TOPIC_SUFFIX = "/lio_pose"
+
+_ARRAY_DTYPES: Final[dict[str, np.dtype[Any]]] = {
+    "point_capture_sequence": np.dtype("<i8"),
+    "point_payload_bytes": np.dtype("<i8"),
+    "point_received_at_epoch_ns": np.dtype("<i8"),
+    "point_received_monotonic_ns": np.dtype("<i8"),
+    "point_header_seq": np.dtype("<u8"),
+    "point_header_stamp": np.dtype("<i8"),
+    "point_scaler": np.dtype("<i8"),
+    "point_offsets": np.dtype("<i8"),
+    "point_raw_xyz": np.dtype("<i8"),
+    "point_xyz_map": np.dtype("<f8"),
+    "point_rgbi": np.dtype("<u4"),
+    "point_intensity": np.dtype("u1"),
+    "pose_capture_sequence": np.dtype("<i8"),
+    "pose_payload_bytes": np.dtype("<i8"),
+    "pose_received_at_epoch_ns": np.dtype("<i8"),
+    "pose_received_monotonic_ns": np.dtype("<i8"),
+    "pose_header_seq": np.dtype("<u8"),
+    "pose_header_stamp": np.dtype("<i8"),
+    "pose_header_scaler": np.dtype("<i8"),
+    "pose_stamp": np.dtype("<i8"),
+    "pose_positions_map": np.dtype("<f8"),
+    "pose_quaternions_map_from_lidar": np.dtype("<f8"),
+    "pose_distance": np.dtype("<f8"),
+    "pose_accuracy": np.dtype("<f8"),
+}
+
+IntArray = npt.NDArray[np.integer[Any]]
+FloatArray = npt.NDArray[np.floating[Any]]
+
+
+class LidarReplayError(ValueError):
+    """A replay pack or its source evidence violates the v2 contract."""
+
+
+@dataclass(frozen=True, slots=True)
+class LidarReplayPointFrame:
+    capture_sequence: int
+    payload_bytes: int
+    received_at_epoch_ns: int
+    received_monotonic_ns: int
+    header_seq: int
+    header_stamp: int
+    scaler: int
+    raw_xyz: npt.NDArray[np.int64]
+    xyz_map: npt.NDArray[np.float64]
+    rgbi: npt.NDArray[np.uint32]
+    intensity: npt.NDArray[np.uint8]
+
+    def decoded_view(self) -> DecodedPointCloudView:
+        return DecodedPointCloudView(
+            context=ConsumerFrameContext(
+                sequence=self.capture_sequence,
+                captured_at_epoch_ns=self.received_at_epoch_ns,
+                received_monotonic_ns=self.received_monotonic_ns,
+                processing_started_monotonic_ns=time.monotonic_ns(),
+                encoded_size_bytes=self.payload_bytes,
+                live=False,
+            ),
+            frame_id="map",
+            positions_xyz=tuple(
+                (float(point[0]), float(point[1]), float(point[2]))
+                for point in self.xyz_map
+            ),
+            intensities=self.intensity.tobytes(),
+        )
+
+
+@dataclass(frozen=True, slots=True)
+class LidarReplayPoseFrame:
+    capture_sequence: int
+    payload_bytes: int
+    received_at_epoch_ns: int
+    received_monotonic_ns: int
+    header_seq: int
+    header_stamp: int
+    header_scaler: int
+    pose_stamp: int
+    position_map: tuple[float, float, float]
+    orientation_map_from_lidar: tuple[float, float, float, float]
+    distance: float
+    pose_accuracy: float
+
+    def decoded_view(self) -> DecodedPoseView:
+        return DecodedPoseView(
+            context=ConsumerFrameContext(
+                sequence=self.capture_sequence,
+                captured_at_epoch_ns=self.received_at_epoch_ns,
+                received_monotonic_ns=self.received_monotonic_ns,
+                processing_started_monotonic_ns=time.monotonic_ns(),
+                encoded_size_bytes=self.payload_bytes,
+                live=False,
+            ),
+            frame_id="map",
+            child_frame_id="lidar",
+            position_xyz=self.position_map,
+            orientation_xyzw=self.orientation_map_from_lidar,
+        )
+
+
+class LidarReplayPackV2:
+    """Strict reader for immutable, field-retaining K1 LiDAR replay evidence."""
+
+    def __init__(self, root: Path) -> None:
+        candidate = root.expanduser().absolute()
+        if candidate.is_symlink():
+            raise LidarReplayError("LiDAR replay pack directory cannot be a symlink")
+        self.root = candidate.resolve(strict=True)
+        if not self.root.is_dir() or _PACK_ID.fullmatch(self.root.name) is None:
+            raise LidarReplayError("LiDAR replay pack directory id is invalid")
+        manifest_path = self.root / LIDAR_MANIFEST_NAME
+        self.manifest = _read_json_object(manifest_path)
+        self.identity = _object(self.manifest.get("identity"), "LiDAR replay identity")
+        identity_sha256 = self.manifest.get("identity_sha256")
+        if (
+            self.manifest.get("schema_version") != LIDAR_REPLAY_PACK_SCHEMA
+            or self.identity.get("schema_version") != LIDAR_REPLAY_PACK_SCHEMA
+            or not isinstance(identity_sha256, str)
+            or hashlib.sha256(_canonical_json(self.identity)).hexdigest()
+            != identity_sha256
+            or self.root.name != f"lidar-replay-pack-{identity_sha256}"
+            or self.manifest.get("pack_id") != self.root.name
+        ):
+            raise LidarReplayError("LiDAR replay pack identity is invalid")
+        self.pack_id = self.root.name
+        artifacts = _validate_artifacts(self.root, self.manifest.get("artifacts"))
+        self.arrays_path = artifacts["lidar-arrays"]
+        self.quality_path = artifacts["lidar-quality"]
+        self.equivalence_path = artifacts["live-replay-equivalence"]
+        self.arrays = np.load(self.arrays_path, allow_pickle=False)
+        if set(self.arrays.files) != set(_ARRAY_DTYPES):
+            self.close()
+            raise LidarReplayError("LiDAR replay array set is incompatible")
+        try:
+            _validate_arrays(self.arrays, self.identity)
+            logical_sha256 = _logical_content_sha256(self.arrays)
+            if logical_sha256 != self.identity.get("logical_content_sha256"):
+                raise LidarReplayError("LiDAR replay logical content identity changed")
+            self.profile = LidarEvidenceProfile.from_dict(
+                self.identity.get("lidar_evidence_profile")
+            )
+            if self.profile != K1_LIDAR_PACK_V2_PROFILE:
+                raise LidarReplayError("LiDAR replay evidence profile is incompatible")
+            self.quality = _read_json_object(self.quality_path)
+            self.equivalence = _read_json_object(self.equivalence_path)
+            _validate_reports(
+                self.quality,
+                self.equivalence,
+                self.pack_id,
+                logical_sha256,
+            )
+        except BaseException:
+            self.close()
+            raise
+
+    @property
+    def point_frame_count(self) -> int:
+        return int(self.arrays["point_capture_sequence"].shape[0])
+
+    @property
+    def pose_frame_count(self) -> int:
+        return int(self.arrays["pose_capture_sequence"].shape[0])
+
+    @property
+    def point_count(self) -> int:
+        return int(self.arrays["point_raw_xyz"].shape[0])
+
+    def close(self) -> None:
+        self.arrays.close()
+
+    def point_frame(self, index: int) -> LidarReplayPointFrame:
+        if not 0 <= index < self.point_frame_count:
+            raise IndexError(index)
+        start = int(self.arrays["point_offsets"][index])
+        end = int(self.arrays["point_offsets"][index + 1])
+        return LidarReplayPointFrame(
+            capture_sequence=int(self.arrays["point_capture_sequence"][index]),
+            payload_bytes=int(self.arrays["point_payload_bytes"][index]),
+            received_at_epoch_ns=int(
+                self.arrays["point_received_at_epoch_ns"][index]
+            ),
+            received_monotonic_ns=int(
+                self.arrays["point_received_monotonic_ns"][index]
+            ),
+            header_seq=int(self.arrays["point_header_seq"][index]),
+            header_stamp=int(self.arrays["point_header_stamp"][index]),
+            scaler=int(self.arrays["point_scaler"][index]),
+            raw_xyz=np.asarray(self.arrays["point_raw_xyz"][start:end], dtype=np.int64),
+            xyz_map=np.asarray(self.arrays["point_xyz_map"][start:end], dtype=np.float64),
+            rgbi=np.asarray(self.arrays["point_rgbi"][start:end], dtype=np.uint32),
+            intensity=np.asarray(
+                self.arrays["point_intensity"][start:end],
+                dtype=np.uint8,
+            ),
+        )
+
+    def pose_frame(self, index: int) -> LidarReplayPoseFrame:
+        if not 0 <= index < self.pose_frame_count:
+            raise IndexError(index)
+        position = self.arrays["pose_positions_map"][index]
+        orientation = self.arrays["pose_quaternions_map_from_lidar"][index]
+        return LidarReplayPoseFrame(
+            capture_sequence=int(self.arrays["pose_capture_sequence"][index]),
+            payload_bytes=int(self.arrays["pose_payload_bytes"][index]),
+            received_at_epoch_ns=int(
+                self.arrays["pose_received_at_epoch_ns"][index]
+            ),
+            received_monotonic_ns=int(
+                self.arrays["pose_received_monotonic_ns"][index]
+            ),
+            header_seq=int(self.arrays["pose_header_seq"][index]),
+            header_stamp=int(self.arrays["pose_header_stamp"][index]),
+            header_scaler=int(self.arrays["pose_header_scaler"][index]),
+            pose_stamp=int(self.arrays["pose_stamp"][index]),
+            position_map=(
+                float(position[0]),
+                float(position[1]),
+                float(position[2]),
+            ),
+            orientation_map_from_lidar=(
+                float(orientation[0]),
+                float(orientation[1]),
+                float(orientation[2]),
+                float(orientation[3]),
+            ),
+            distance=float(self.arrays["pose_distance"][index]),
+            pose_accuracy=float(self.arrays["pose_accuracy"][index]),
+        )
+
+
+def build_lidar_replay_pack_v2(
+    capture_path: Path,
+    output_root: Path,
+    *,
+    session_id: str | None = None,
+    pose_coverage_threshold_ms: float = DEFAULT_POSE_COVERAGE_THRESHOLD_MS,
+) -> Path:
+    """Materialize a content-bound replay without mutating the source capture."""
+
+    source = capture_path.expanduser().resolve(strict=True)
+    if source.name != "mqtt.raw.k1mqtt" or not source.is_file():
+        raise LidarReplayError("LiDAR replay source must be mqtt.raw.k1mqtt")
+    metadata = source.with_name("mqtt.metadata.jsonl")
+    if not metadata.is_file():
+        raise LidarReplayError("exact host timing requires mqtt.metadata.jsonl")
+    if (
+        not math.isfinite(pose_coverage_threshold_ms)
+        or not 0 < pose_coverage_threshold_ms <= 10_000
+    ):
+        raise LidarReplayError("pose coverage threshold is invalid")
+    resolved_session_id = session_id or _infer_session_id(source)
+    if _SAFE_SESSION_ID.fullmatch(resolved_session_id) is None:
+        raise LidarReplayError("LiDAR replay session id is unsafe")
+
+    arrays = _capture_arrays(source)
+    logical_sha256 = _logical_content_sha256(arrays)
+    source_evidence = {
+        "raw": _artifact_identity(source),
+        "metadata": _artifact_identity(metadata),
+    }
+    clock_origin = source.with_name("mqtt.timeline.origin.json")
+    if clock_origin.is_file():
+        source_evidence["clock_origin"] = _artifact_identity(clock_origin)
+    identity = {
+        "schema_version": LIDAR_REPLAY_PACK_SCHEMA,
+        "session_id": resolved_session_id,
+        "source_evidence": source_evidence,
+        "lidar_evidence_profile": K1_LIDAR_PACK_V2_PROFILE.to_dict(),
+        "field_retention": {
+            "point": [
+                "capture-sequence",
+                "payload-bytes",
+                "received-at-epoch-ns",
+                "received-monotonic-ns",
+                "header-seq",
+                "header-stamp",
+                "header-scaler",
+                "raw-xyz",
+                "xyz-map",
+                "raw-rgbi",
+                "intensity-low-byte",
+            ],
+            "pose": [
+                "capture-sequence",
+                "payload-bytes",
+                "received-at-epoch-ns",
+                "received-monotonic-ns",
+                "header-seq",
+                "header-stamp",
+                "header-scaler",
+                "pose-stamp",
+                "position-map",
+                "orientation-map-from-lidar",
+                "distance",
+                "pose-accuracy",
+            ],
+        },
+        "point_frame_count": int(arrays["point_capture_sequence"].shape[0]),
+        "pose_frame_count": int(arrays["pose_capture_sequence"].shape[0]),
+        "point_count": int(arrays["point_raw_xyz"].shape[0]),
+        "logical_content_sha256": logical_sha256,
+        "producer_sha256": _sha256(Path(__file__).resolve(strict=True)),
+        "authority": {
+            "commands_enabled": False,
+            "navigation_or_safety_accepted": False,
+        },
+    }
+    identity_sha256 = hashlib.sha256(_canonical_json(identity)).hexdigest()
+    pack_id = f"lidar-replay-pack-{identity_sha256}"
+    parent = output_root.expanduser().resolve()
+    parent.mkdir(mode=0o700, parents=True, exist_ok=True)
+    output = parent / pack_id
+    if output.exists():
+        existing = LidarReplayPackV2(output)
+        existing.close()
+        return output
+
+    staging = parent / f".{pack_id}.{os.getpid()}.incomplete"
+    staging.mkdir(mode=0o700, exist_ok=False)
+    try:
+        arrays_path = staging / LIDAR_REPLAY_ARRAYS_NAME
+        np.savez_compressed(arrays_path, **arrays)  # type: ignore[arg-type]
+        quality = _quality_report(
+            pack_id,
+            logical_sha256,
+            arrays,
+            pose_coverage_threshold_ms=pose_coverage_threshold_ms,
+        )
+        _write_json(staging / LIDAR_QUALITY_REPORT_NAME, quality)
+        equivalence = _equivalence_report(
+            pack_id,
+            logical_sha256,
+            source,
+            arrays,
+        )
+        _write_json(staging / LIDAR_EQUIVALENCE_REPORT_NAME, equivalence)
+        artifacts = [
+            _artifact_descriptor("lidar-arrays", arrays_path, "application/x-npz"),
+            _artifact_descriptor(
+                "lidar-quality",
+                staging / LIDAR_QUALITY_REPORT_NAME,
+                "application/json",
+            ),
+            _artifact_descriptor(
+                "live-replay-equivalence",
+                staging / LIDAR_EQUIVALENCE_REPORT_NAME,
+                "application/json",
+            ),
+        ]
+        manifest = {
+            "schema_version": LIDAR_REPLAY_PACK_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-replay-input",
+            "ground_truth": False,
+            "artifacts": artifacts,
+        }
+        _write_json(staging / LIDAR_MANIFEST_NAME, manifest)
+        os.replace(staging, output)
+        try:
+            validation = LidarReplayPackV2(output)
+            validation.close()
+        except BaseException:
+            shutil.rmtree(output, ignore_errors=True)
+            raise
+    except BaseException:
+        shutil.rmtree(staging, ignore_errors=True)
+        raise
+    return output
+
+
+def verify_lidar_replay_equivalence(
+    capture_path: Path,
+    pack: LidarReplayPackV2,
+) -> dict[str, object]:
+    """Re-run the exact source-to-pack comparison for an accepted pack."""
+
+    source = capture_path.expanduser().resolve(strict=True)
+    source_identity = _object(
+        pack.identity.get("source_evidence"),
+        "LiDAR source evidence",
+    )
+    raw_identity = _object(source_identity.get("raw"), "LiDAR raw evidence")
+    if (
+        raw_identity.get("sha256") != _sha256(source)
+        or raw_identity.get("byte_length") != source.stat().st_size
+    ):
+        raise LidarReplayError("LiDAR equivalence source differs from pack identity")
+    return _equivalence_report(
+        pack.pack_id,
+        str(pack.identity["logical_content_sha256"]),
+        source,
+        pack.arrays,
+    )
+
+
+def lidar_pack_catalog_item(pack: LidarReplayPackV2) -> dict[str, object]:
+    point_count = _object(pack.quality.get("point_count_per_frame"), "point count")
+    cadence = _object(pack.quality.get("point_frame_interval_ms"), "point cadence")
+    pose = _object(pack.quality.get("pose_binding"), "pose binding")
+    return {
+        "pack_id": pack.pack_id,
+        "session_id": pack.identity["session_id"],
+        "profile_id": pack.profile.profile_id,
+        "point_frames": pack.point_frame_count,
+        "pose_frames": pack.pose_frame_count,
+        "points": pack.point_count,
+        "mean_points_per_frame": point_count.get("mean"),
+        "p95_frame_interval_ms": cadence.get("p95"),
+        "pose_coverage_fraction": pose.get("coverage_fraction"),
+        "equivalence_status": pack.equivalence.get("status"),
+        "logical_content_sha256": pack.identity["logical_content_sha256"],
+        "authority": {
+            "commands_enabled": False,
+            "navigation_or_safety_accepted": False,
+        },
+    }
+
+
+def lidar_pack_detail(pack: LidarReplayPackV2) -> dict[str, object]:
+    return {
+        "schema_version": "missioncore.lidar-replay-pack-detail/v1",
+        "pack": lidar_pack_catalog_item(pack),
+        "quality": pack.quality,
+        "equivalence": pack.equivalence,
+        "readiness": lidar_readiness_document(pack.profile),
+        "access": "read-only",
+    }
+
+
+def _capture_arrays(path: Path) -> dict[str, npt.NDArray[Any]]:
+    point_messages: list[tuple[StreamMessage, LioPointCloudFrame]] = []
+    pose_messages: list[tuple[StreamMessage, LioPoseFrame]] = []
+    for message in iter_replay_messages(path):
+        if message.source != "k1mqtt" or message.received_monotonic_ns is None:
+            raise LidarReplayError("LiDAR v2 requires native capture with exact host time")
+        if message.topic.endswith(_POINT_TOPIC_SUFFIX):
+            point_messages.append((message, decode_lio_pcl(message.payload)))
+        elif message.topic.endswith(_POSE_TOPIC_SUFFIX):
+            pose_messages.append((message, decode_lio_pose(message.payload)))
+    if not point_messages:
+        raise LidarReplayError("LiDAR replay source contains no lio_pcl frames")
+
+    point_offsets = [0]
+    point_raw: list[npt.NDArray[np.int64]] = []
+    point_xyz: list[npt.NDArray[np.float64]] = []
+    point_rgbi: list[npt.NDArray[np.uint32]] = []
+    point_intensity: list[npt.NDArray[np.uint8]] = []
+    for _, frame in point_messages:
+        raw = np.asarray(
+            [(point.x_raw, point.y_raw, point.z_raw) for point in frame.points],
+            dtype="<i8",
+        ).reshape((-1, 3))
+        rgbi = np.asarray([point.rgbi for point in frame.points], dtype="<u4")
+        intensity = (rgbi & np.uint32(0xFF)).astype(np.uint8)
+        xyz = raw.astype(np.float64) / float(frame.header.scaler)
+        point_raw.append(raw)
+        point_xyz.append(xyz)
+        point_rgbi.append(rgbi)
+        point_intensity.append(intensity)
+        point_offsets.append(point_offsets[-1] + raw.shape[0])
+
+    arrays: dict[str, npt.NDArray[Any]] = {
+        "point_capture_sequence": _message_int_array(point_messages, "sequence"),
+        "point_payload_bytes": np.asarray(
+            [len(message.payload) for message, _ in point_messages],
+            dtype="<i8",
+        ),
+        "point_received_at_epoch_ns": _message_int_array(
+            point_messages,
+            "received_at_epoch_ns",
+        ),
+        "point_received_monotonic_ns": np.asarray(
+            [message.received_monotonic_ns for message, _ in point_messages],
+            dtype="<i8",
+        ),
+        "point_header_seq": np.asarray(
+            [frame.header.seq for _, frame in point_messages],
+            dtype="<u8",
+        ),
+        "point_header_stamp": np.asarray(
+            [frame.header.stamp for _, frame in point_messages],
+            dtype="<i8",
+        ),
+        "point_scaler": np.asarray(
+            [frame.header.scaler for _, frame in point_messages],
+            dtype="<i8",
+        ),
+        "point_offsets": np.asarray(point_offsets, dtype="<i8"),
+        "point_raw_xyz": np.concatenate(point_raw),
+        "point_xyz_map": np.concatenate(point_xyz),
+        "point_rgbi": np.concatenate(point_rgbi),
+        "point_intensity": np.concatenate(point_intensity),
+        "pose_capture_sequence": _message_int_array(pose_messages, "sequence"),
+        "pose_payload_bytes": np.asarray(
+            [len(message.payload) for message, _ in pose_messages],
+            dtype="<i8",
+        ),
+        "pose_received_at_epoch_ns": _message_int_array(
+            pose_messages,
+            "received_at_epoch_ns",
+        ),
+        "pose_received_monotonic_ns": np.asarray(
+            [message.received_monotonic_ns for message, _ in pose_messages],
+            dtype="<i8",
+        ),
+        "pose_header_seq": np.asarray(
+            [frame.header.seq for _, frame in pose_messages],
+            dtype="<u8",
+        ),
+        "pose_header_stamp": np.asarray(
+            [frame.header.stamp for _, frame in pose_messages],
+            dtype="<i8",
+        ),
+        "pose_header_scaler": np.asarray(
+            [frame.header.scaler for _, frame in pose_messages],
+            dtype="<i8",
+        ),
+        "pose_stamp": np.asarray(
+            [frame.pose_stamp for _, frame in pose_messages],
+            dtype="<i8",
+        ),
+        "pose_positions_map": np.asarray(
+            [frame.position_xyz for _, frame in pose_messages],
+            dtype="<f8",
+        ).reshape((-1, 3)),
+        "pose_quaternions_map_from_lidar": np.asarray(
+            [frame.orientation_xyzw for _, frame in pose_messages],
+            dtype="<f8",
+        ).reshape((-1, 4)),
+        "pose_distance": np.asarray(
+            [frame.distance for _, frame in pose_messages],
+            dtype="<f8",
+        ),
+        "pose_accuracy": np.asarray(
+            [frame.pose_accuracy for _, frame in pose_messages],
+            dtype="<f8",
+        ),
+    }
+    return arrays
+
+
+def _message_int_array(
+    messages: list[tuple[StreamMessage, Any]],
+    attribute: str,
+) -> npt.NDArray[np.int64]:
+    return np.asarray(
+        [getattr(message, attribute) for message, _ in messages],
+        dtype="<i8",
+    )
+
+
+def _validate_arrays(arrays: Any, identity: dict[str, Any]) -> None:
+    for name, dtype in _ARRAY_DTYPES.items():
+        if arrays[name].dtype != dtype:
+            raise LidarReplayError(f"LiDAR replay array {name} dtype changed")
+    point_frames = int(arrays["point_capture_sequence"].shape[0])
+    pose_frames = int(arrays["pose_capture_sequence"].shape[0])
+    points = int(arrays["point_raw_xyz"].shape[0])
+    point_vector_names = {
+        "point_payload_bytes",
+        "point_received_at_epoch_ns",
+        "point_received_monotonic_ns",
+        "point_header_seq",
+        "point_header_stamp",
+        "point_scaler",
+    }
+    pose_vector_names = {
+        "pose_payload_bytes",
+        "pose_received_at_epoch_ns",
+        "pose_received_monotonic_ns",
+        "pose_header_seq",
+        "pose_header_stamp",
+        "pose_header_scaler",
+        "pose_stamp",
+        "pose_distance",
+        "pose_accuracy",
+    }
+    if (
+        point_frames < 1
+        or any(arrays[name].shape != (point_frames,) for name in point_vector_names)
+        or arrays["point_offsets"].shape != (point_frames + 1,)
+        or arrays["point_raw_xyz"].shape != (points, 3)
+        or arrays["point_xyz_map"].shape != (points, 3)
+        or arrays["point_rgbi"].shape != (points,)
+        or arrays["point_intensity"].shape != (points,)
+        or any(arrays[name].shape != (pose_frames,) for name in pose_vector_names)
+        or arrays["pose_positions_map"].shape != (pose_frames, 3)
+        or arrays["pose_quaternions_map_from_lidar"].shape != (pose_frames, 4)
+        or int(arrays["point_offsets"][0]) != 0
+        or int(arrays["point_offsets"][-1]) != points
+        or np.any(np.diff(arrays["point_offsets"]) <= 0)
+        or np.any(np.diff(arrays["point_capture_sequence"]) <= 0)
+        or np.any(np.diff(arrays["point_received_monotonic_ns"]) < 0)
+        or np.any(arrays["point_payload_bytes"] <= 0)
+        or np.any(arrays["point_scaler"] == 0)
+        or (
+            pose_frames > 0
+            and (
+                np.any(np.diff(arrays["pose_capture_sequence"]) <= 0)
+                or np.any(np.diff(arrays["pose_received_monotonic_ns"]) < 0)
+                or np.any(arrays["pose_payload_bytes"] <= 0)
+            )
+        )
+        or identity.get("point_frame_count") != point_frames
+        or identity.get("pose_frame_count") != pose_frames
+        or identity.get("point_count") != points
+    ):
+        raise LidarReplayError("LiDAR replay array shapes or counts are invalid")
+    expected_intensity = (arrays["point_rgbi"] & np.uint32(0xFF)).astype(np.uint8)
+    if not np.array_equal(arrays["point_intensity"], expected_intensity):
+        raise LidarReplayError("LiDAR intensity is not the exact rgbi low byte")
+    expected_xyz = np.empty_like(arrays["point_xyz_map"])
+    for index in range(point_frames):
+        start = int(arrays["point_offsets"][index])
+        end = int(arrays["point_offsets"][index + 1])
+        expected_xyz[start:end] = (
+            arrays["point_raw_xyz"][start:end].astype(np.float64)
+            / float(arrays["point_scaler"][index])
+        )
+    if not np.array_equal(arrays["point_xyz_map"], expected_xyz):
+        raise LidarReplayError("LiDAR XYZ does not reproduce raw coordinates and scaler")
+    finite_names = {
+        "point_xyz_map",
+        "pose_positions_map",
+        "pose_quaternions_map_from_lidar",
+        "pose_distance",
+        "pose_accuracy",
+    }
+    if any(not np.isfinite(arrays[name]).all() for name in finite_names):
+        raise LidarReplayError("LiDAR replay contains non-finite geometry")
+
+
+def _quality_report(
+    pack_id: str,
+    logical_sha256: str,
+    arrays: dict[str, npt.NDArray[Any]],
+    *,
+    pose_coverage_threshold_ms: float,
+) -> dict[str, object]:
+    offsets = arrays["point_offsets"]
+    point_counts = np.diff(offsets).astype(np.float64)
+    point_times = arrays["point_received_monotonic_ns"]
+    point_intervals_ms = np.diff(point_times).astype(np.float64) / 1_000_000
+    pose_times = arrays["pose_received_monotonic_ns"]
+    pose_delta_ms = _nearest_time_delta_ms(point_times, pose_times)
+    covered = pose_delta_ms <= pose_coverage_threshold_ms
+    point_sequence = _sequence_report(arrays["point_header_seq"])
+    pose_sequence = _sequence_report(arrays["pose_header_seq"])
+    return {
+        "schema_version": LIDAR_QUALITY_REPORT_SCHEMA,
+        "pack_id": pack_id,
+        "profile_id": K1_LIDAR_PACK_V2_PROFILE.profile_id,
+        "logical_content_sha256": logical_sha256,
+        "field_retention": {
+            "xyz_map": True,
+            "raw_xyz": True,
+            "raw_rgbi": True,
+            "intensity_low_byte": True,
+            "source_sequence": True,
+            "header_seq_stamp_scaler": True,
+            "host_epoch_ns": True,
+            "host_monotonic_ns": True,
+        },
+        "frames": {
+            "point": int(point_times.shape[0]),
+            "pose": int(pose_times.shape[0]),
+            "points": int(arrays["point_raw_xyz"].shape[0]),
+        },
+        "point_count_per_frame": _distribution(point_counts),
+        "point_frame_interval_ms": _distribution(point_intervals_ms),
+        "intensity_0_255": _distribution(
+            arrays["point_intensity"].astype(np.float64)
+        ),
+        "sensor_range_m": _distribution(np.empty((0,), dtype=np.float64)),
+        "sensor_range_status": (
+            "unavailable-vendor-map-increment-with-independent-best-effort-pose"
+        ),
+        "scaler": _distribution(arrays["point_scaler"].astype(np.float64)),
+        "point_header_sequence": point_sequence,
+        "pose_header_sequence": pose_sequence,
+        "point_header_stamp": _timestamp_report(arrays["point_header_stamp"]),
+        "pose_header_stamp": _timestamp_report(arrays["pose_header_stamp"]),
+        "pose_binding": {
+            "basis": "nearest-recorded-host-monotonic-arrival",
+            "threshold_ms": pose_coverage_threshold_ms,
+            "covered_point_frames": int(np.count_nonzero(covered)),
+            "coverage_fraction": (
+                float(np.mean(covered)) if covered.size else 0.0
+            ),
+            "nearest_delta_ms": _distribution(pose_delta_ms),
+        },
+        "limitations": [
+            "vendor-mapped increment, not an admitted raw sensor sweep",
+            "no admitted ring, per-point firing time, scan geometry or IMU samples",
+            "host-arrival time is exact evidence but not a shared sensor hardware clock",
+        ],
+        "authority": {
+            "commands_enabled": False,
+            "navigation_or_safety_accepted": False,
+        },
+    }
+
+
+def _equivalence_report(
+    pack_id: str,
+    logical_sha256: str,
+    capture_path: Path,
+    replay_arrays: Any,
+) -> dict[str, object]:
+    source_arrays = _capture_arrays(capture_path)
+    comparisons: dict[str, dict[str, object]] = {}
+    mismatch_count = 0
+    for name in sorted(_ARRAY_DTYPES):
+        source = source_arrays[name]
+        replay = replay_arrays[name]
+        equal = bool(
+            source.dtype == replay.dtype
+            and source.shape == replay.shape
+            and np.array_equal(source, replay)
+        )
+        comparisons[name] = {
+            "equal": equal,
+            "dtype": source.dtype.str,
+            "shape": list(source.shape),
+        }
+        mismatch_count += int(not equal)
+    source_logical_sha256 = _logical_content_sha256(source_arrays)
+    status = (
+        "passed"
+        if mismatch_count == 0 and source_logical_sha256 == logical_sha256
+        else "failed"
+    )
+    return {
+        "schema_version": LIDAR_EQUIVALENCE_REPORT_SCHEMA,
+        "pack_id": pack_id,
+        "status": status,
+        "comparison": "source-native-capture-vs-persisted-replay-fields",
+        "source_logical_content_sha256": source_logical_sha256,
+        "replay_logical_content_sha256": logical_sha256,
+        "arrays_compared": len(comparisons),
+        "array_mismatches": mismatch_count,
+        "fields": comparisons,
+        "authority": {
+            "commands_enabled": False,
+            "navigation_or_safety_accepted": False,
+        },
+    }
+
+
+def _validate_reports(
+    quality: dict[str, Any],
+    equivalence: dict[str, Any],
+    pack_id: str,
+    logical_sha256: str,
+) -> None:
+    if (
+        quality.get("schema_version") != LIDAR_QUALITY_REPORT_SCHEMA
+        or quality.get("pack_id") != pack_id
+        or quality.get("logical_content_sha256") != logical_sha256
+        or quality.get("profile_id") != K1_LIDAR_PACK_V2_PROFILE.profile_id
+    ):
+        raise LidarReplayError("LiDAR quality report is incompatible")
+    if (
+        equivalence.get("schema_version") != LIDAR_EQUIVALENCE_REPORT_SCHEMA
+        or equivalence.get("pack_id") != pack_id
+        or equivalence.get("status") != "passed"
+        or equivalence.get("source_logical_content_sha256") != logical_sha256
+        or equivalence.get("replay_logical_content_sha256") != logical_sha256
+        or equivalence.get("array_mismatches") != 0
+    ):
+        raise LidarReplayError("LiDAR live/replay equivalence gate did not pass")
+
+
+def _nearest_time_delta_ms(
+    points: npt.NDArray[Any],
+    poses: npt.NDArray[Any],
+) -> npt.NDArray[np.float64]:
+    if points.size == 0:
+        return np.empty((0,), dtype=np.float64)
+    if poses.size == 0:
+        return np.full(points.shape, np.inf, dtype=np.float64)
+    pose_values = poses.astype(np.int64)
+    result = np.empty(points.shape, dtype=np.float64)
+    for index, value in enumerate(points.astype(np.int64)):
+        insertion = int(np.searchsorted(pose_values, value))
+        candidates: list[int] = []
+        if insertion < pose_values.size:
+            candidates.append(abs(int(pose_values[insertion]) - int(value)))
+        if insertion > 0:
+            candidates.append(abs(int(pose_values[insertion - 1]) - int(value)))
+        result[index] = min(candidates) / 1_000_000
+    return result
+
+
+def _sequence_report(values: npt.NDArray[Any]) -> dict[str, int]:
+    items = [int(value) for value in values]
+    differences = [
+        current - previous for previous, current in zip(items, items[1:], strict=False)
+    ]
+    return {
+        "samples": len(items),
+        "nonincreasing": sum(value <= 0 for value in differences),
+        "duplicate": sum(value == 0 for value in differences),
+        "forward_gaps": sum(max(0, value - 1) for value in differences),
+    }
+
+
+def _timestamp_report(values: npt.NDArray[Any]) -> dict[str, object]:
+    items = [int(value) for value in values]
+    differences = np.asarray(
+        [
+            current - previous
+            for previous, current in zip(items, items[1:], strict=False)
+        ],
+        dtype=np.float64,
+    )
+    return {
+        "samples": len(items),
+        "nonincreasing": int(np.count_nonzero(differences <= 0)),
+        "duplicate": int(np.count_nonzero(differences == 0)),
+        "positive_delta": _distribution(differences[differences > 0]),
+    }
+
+
+def _distribution(values: npt.NDArray[Any]) -> dict[str, float | int | None]:
+    finite = np.asarray(values, dtype=np.float64)
+    finite = finite[np.isfinite(finite)]
+    if finite.size == 0:
+        return {
+            "sample_count": 0,
+            "minimum": None,
+            "mean": None,
+            "p50": None,
+            "p95": None,
+            "maximum": None,
+        }
+    return {
+        "sample_count": int(finite.size),
+        "minimum": float(np.min(finite)),
+        "mean": float(np.mean(finite)),
+        "p50": float(np.percentile(finite, 50)),
+        "p95": float(np.percentile(finite, 95)),
+        "maximum": float(np.max(finite)),
+    }
+
+
+def _logical_content_sha256(arrays: Any) -> str:
+    digest = hashlib.sha256()
+    for name in sorted(_ARRAY_DTYPES):
+        array = np.ascontiguousarray(arrays[name])
+        descriptor = {
+            "name": name,
+            "dtype": array.dtype.str,
+            "shape": list(array.shape),
+        }
+        encoded = _canonical_json(descriptor)
+        digest.update(len(encoded).to_bytes(8, "big"))
+        digest.update(encoded)
+        digest.update(array.tobytes(order="C"))
+    return digest.hexdigest()
+
+
+def _validate_artifacts(root: Path, raw: object) -> dict[str, Path]:
+    expected = {
+        "lidar-arrays": (LIDAR_REPLAY_ARRAYS_NAME, "application/x-npz"),
+        "lidar-quality": (LIDAR_QUALITY_REPORT_NAME, "application/json"),
+        "live-replay-equivalence": (
+            LIDAR_EQUIVALENCE_REPORT_NAME,
+            "application/json",
+        ),
+    }
+    if not isinstance(raw, list) or len(raw) != len(expected):
+        raise LidarReplayError("LiDAR replay artifact set is incomplete")
+    result: dict[str, Path] = {}
+    for value in raw:
+        kind = value.get("kind") if isinstance(value, dict) else None
+        if not isinstance(kind, str) or kind not in expected or kind in result:
+            raise LidarReplayError("LiDAR replay artifact descriptor is invalid")
+        name, media_type = expected[kind]
+        path = root / name
+        if (
+            not path.is_file()
+            or path.is_symlink()
+            or path.resolve(strict=True).parent != root
+            or value.get("path") != name
+            or value.get("media_type") != media_type
+            or value.get("byte_length") != path.stat().st_size
+            or value.get("sha256") != _sha256(path)
+        ):
+            raise LidarReplayError("LiDAR replay artifact identity changed")
+        result[kind] = path
+    return result
+
+
+def _artifact_identity(path: Path) -> dict[str, object]:
+    return {
+        "byte_length": path.stat().st_size,
+        "sha256": _sha256(path),
+    }
+
+
+def _artifact_descriptor(
+    kind: str,
+    path: Path,
+    media_type: str,
+) -> dict[str, object]:
+    return {
+        "kind": kind,
+        "path": path.name,
+        "media_type": media_type,
+        "byte_length": path.stat().st_size,
+        "sha256": _sha256(path),
+    }
+
+
+def _infer_session_id(capture_path: Path) -> str:
+    parents = capture_path.parents
+    if len(parents) < 3:
+        raise LidarReplayError("LiDAR replay session id cannot be inferred")
+    return parents[2].name
+
+
+def _canonical_json(value: object) -> bytes:
+    return json.dumps(
+        value,
+        ensure_ascii=False,
+        sort_keys=True,
+        separators=(",", ":"),
+        allow_nan=False,
+    ).encode()
+
+
+def _write_json(path: Path, value: object) -> None:
+    path.write_bytes(
+        json.dumps(
+            value,
+            ensure_ascii=False,
+            sort_keys=True,
+            indent=2,
+            allow_nan=False,
+        ).encode()
+        + b"\n"
+    )
+
+
+def _read_json_object(path: Path) -> dict[str, Any]:
+    try:
+        value = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, UnicodeDecodeError, json.JSONDecodeError) as exc:
+        raise LidarReplayError(f"{path.name} is not valid JSON") from exc
+    return _object(value, path.name)
+
+
+def _object(value: object, label: str) -> dict[str, Any]:
+    if not isinstance(value, dict) or any(not isinstance(key, str) for key in value):
+        raise LidarReplayError(f"{label} must be an object")
+    return value
+
+
+def _sha256(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as stream:
+        while chunk := stream.read(1024 * 1024):
+            digest.update(chunk)
+    return digest.hexdigest()
diff --git a/src/k1link/web/app.py b/src/k1link/web/app.py
index e21404b..962c8cc 100644
--- a/src/k1link/web/app.py
+++ b/src/k1link/web/app.py
@@ -33,6 +33,7 @@ from k1link.sessions import (
     SessionStore,
 )
 from k1link.web.device_plugin_composition import load_installed_device_plugins
+from k1link.web.lidar_api import build_lidar_router
 from k1link.web.plugin_catalog import DevicePluginCatalog, PluginCatalogError
 from k1link.web.plugin_runtime import (
     STATE_READ_ACTION_ID,
@@ -398,6 +399,17 @@ app.include_router(
     )
 )
 app.include_router(build_polygon_router())
+app.include_router(
+    build_lidar_router(
+        root_provider=lambda: (
+            REPOSITORY_ROOT
+            / ".runtime"
+            / "compute-experiments"
+            / "lidar-replay-v2"
+            / "packs"
+        )
+    )
+)
 
 
 frontend_dist = REPOSITORY_ROOT / "apps" / "control-station" / "dist"
diff --git a/src/k1link/web/lidar_api.py b/src/k1link/web/lidar_api.py
new file mode 100644
index 0000000..c63c5a1
--- /dev/null
+++ b/src/k1link/web/lidar_api.py
@@ -0,0 +1,110 @@
+from __future__ import annotations
+
+import os
+import re
+from collections.abc import Callable
+from pathlib import Path
+from typing import Any, Final
+
+from fastapi import APIRouter, HTTPException, Query
+
+from k1link.compute import (
+    LidarReplayError,
+    LidarReplayPackV2,
+    lidar_pack_catalog_item,
+    lidar_pack_detail,
+)
+
+LIDAR_CATALOG_SCHEMA: Final = "missioncore.lidar-replay-pack-catalog/v1"
+_PACK_ID = re.compile(r"^lidar-replay-pack-[a-f0-9]{64}$")
+RootProvider = Callable[[], Path | None]
+
+
+def configured_lidar_replay_root() -> Path | None:
+    value = os.environ.get("MISSIONCORE_LIDAR_REPLAY_ROOT", "").strip()
+    return Path(value).expanduser().absolute() if value else None
+
+
+def build_lidar_router(
+    *,
+    root_provider: RootProvider = configured_lidar_replay_root,
+) -> APIRouter:
+    router = APIRouter(prefix="/api/v1/lidar", tags=["lidar"])
+
+    @router.get("/replay-packs")
+    def list_lidar_replay_packs(
+        limit: int = Query(default=20, ge=1, le=100),
+    ) -> dict[str, Any]:
+        root = root_provider()
+        if root is None or not root.is_dir():
+            return {
+                "schema_version": LIDAR_CATALOG_SCHEMA,
+                "configured": root is not None,
+                "items": [],
+                "valid_total": 0,
+                "invalid_total": 0,
+                "duplicate_total": 0,
+                "access": "read-only",
+            }
+        items: list[dict[str, object]] = []
+        invalid_total = 0
+        duplicate_total = 0
+        seen_logical_content: set[str] = set()
+        candidates = sorted(
+            (
+                candidate
+                for candidate in root.iterdir()
+                if candidate.is_dir() and _PACK_ID.fullmatch(candidate.name) is not None
+            ),
+            key=lambda candidate: candidate.stat().st_mtime_ns,
+            reverse=True,
+        )
+        for candidate in candidates:
+            try:
+                pack = LidarReplayPackV2(candidate)
+                try:
+                    item = lidar_pack_catalog_item(pack)
+                    logical_content = str(item["logical_content_sha256"])
+                    if logical_content in seen_logical_content:
+                        duplicate_total += 1
+                        continue
+                    seen_logical_content.add(logical_content)
+                    item["created_at_utc"] = pack.manifest.get("created_at_utc")
+                    items.append(item)
+                finally:
+                    pack.close()
+            except (LidarReplayError, OSError):
+                invalid_total += 1
+        return {
+            "schema_version": LIDAR_CATALOG_SCHEMA,
+            "configured": True,
+            "items": items[:limit],
+            "valid_total": len(items),
+            "invalid_total": invalid_total,
+            "duplicate_total": duplicate_total,
+            "access": "read-only",
+        }
+
+    @router.get("/replay-packs/{pack_id}")
+    def get_lidar_replay_pack(pack_id: str) -> dict[str, object]:
+        if _PACK_ID.fullmatch(pack_id) is None:
+            raise HTTPException(status_code=404, detail="LiDAR replay pack не найден")
+        root = root_provider()
+        if root is None or not root.is_dir():
+            raise HTTPException(status_code=503, detail="LiDAR replay storage не настроен")
+        candidate = root / pack_id
+        if not candidate.is_dir():
+            raise HTTPException(status_code=404, detail="LiDAR replay pack не найден")
+        try:
+            pack = LidarReplayPackV2(candidate)
+            try:
+                return lidar_pack_detail(pack)
+            finally:
+                pack.close()
+        except (LidarReplayError, OSError) as exc:
+            raise HTTPException(
+                status_code=409,
+                detail="LiDAR replay pack не прошёл проверку целостности",
+            ) from exc
+
+    return router
diff --git a/tests/test_lidar_replay.py b/tests/test_lidar_replay.py
new file mode 100644
index 0000000..c098234
--- /dev/null
+++ b/tests/test_lidar_replay.py
@@ -0,0 +1,264 @@
+from __future__ import annotations
+
+import json
+import struct
+from pathlib import Path
+
+import lz4.block
+import pytest
+from fastapi import APIRouter
+from fastapi.routing import APIRoute
+
+from k1link.compute import (
+    K1_LIDAR_PACK_V2_PROFILE,
+    LidarPipelineStage,
+    LidarReadiness,
+    LidarReplayError,
+    LidarReplayPackV2,
+    assess_lidar_profile,
+    build_lidar_replay_pack_v2,
+    verify_lidar_replay_equivalence,
+)
+from k1link.device_plugins.xgrids_k1.mqtt.capture import FRAME_HEADER, RAW_MAGIC
+from k1link.web.lidar_api import build_lidar_router
+
+
+def _varint(value: int) -> bytes:
+    encoded = bytearray()
+    while value > 0x7F:
+        encoded.append((value & 0x7F) | 0x80)
+        value >>= 7
+    encoded.append(value)
+    return bytes(encoded)
+
+
+def _key(number: int, wire_type: int) -> bytes:
+    return _varint((number << 3) | wire_type)
+
+
+def _uint(number: int, value: int) -> bytes:
+    return _key(number, 0) + _varint(value)
+
+
+def _sint(number: int, value: int) -> bytes:
+    zigzag = (value << 1) ^ (value >> 63)
+    return _uint(number, zigzag & 0xFFFFFFFFFFFFFFFF)
+
+
+def _bytes(number: int, value: bytes) -> bytes:
+    return _key(number, 2) + _varint(len(value)) + value
+
+
+def _fixed32(number: int, value: float) -> bytes:
+    return _key(number, 5) + struct.pack("<f", value)
+
+
+def _fixed64(number: int, value: float) -> bytes:
+    return _key(number, 1) + struct.pack("<d", value)
+
+
+def _header(sequence: int, stamp: int, scaler: int = 1000) -> bytes:
+    return b"".join(
+        (
+            _uint(1, sequence),
+            _sint(2, stamp),
+            _sint(3, scaler),
+            _bytes(4, b"device-redacted"),
+            _bytes(5, b"session-redacted"),
+        )
+    )
+
+
+def _pcl_payload(sequence: int, stamp: int, first_rgbi: int) -> bytes:
+    point_1 = (
+        _sint(1, 1000 * sequence)
+        + _sint(2, -2000)
+        + _sint(3, 500)
+        + _uint(4, first_rgbi)
+    )
+    point_2 = (
+        _sint(1, -250)
+        + _sint(2, sequence)
+        + _sint(3, 4000)
+        + _uint(4, 0xAABBCC09)
+    )
+    report = (
+        _bytes(1, _header(sequence, stamp))
+        + _bytes(2, point_1)
+        + _bytes(2, point_2)
+    )
+    compressed = lz4.block.compress(report, store_size=False)
+    return _uint(3, len(report)) + _bytes(4, compressed)
+
+
+def _pose_payload(sequence: int, stamp: int) -> bytes:
+    position = (
+        _fixed64(1, float(sequence))
+        + _fixed64(2, -2.5)
+        + _fixed64(3, 3.75)
+    )
+    orientation = (
+        _fixed64(1, 0.0)
+        + _fixed64(2, 0.0)
+        + _fixed64(3, 0.0)
+        + _fixed64(4, 1.0)
+    )
+    pose = _bytes(1, position) + _bytes(2, orientation)
+    stamped = _sint(1, stamp + 1) + _bytes(2, pose)
+    return (
+        _bytes(1, _header(sequence, stamp))
+        + _bytes(2, stamped)
+        + _fixed32(3, 12.5)
+        + _fixed32(4, 0.001)
+    )
+
+
+def _capture(tmp_path: Path) -> Path:
+    session = tmp_path / "session-001"
+    root = session / "captures" / "mqtt_live"
+    root.mkdir(parents=True)
+    messages = [
+        ("lixel/application/report/lio_pcl", _pcl_payload(10, 1_000, 0x11223344)),
+        ("lixel/application/report/lio_pose", _pose_payload(20, 1_010)),
+        ("lixel/application/report/lio_pcl", _pcl_payload(11, 2_000, 0x55667788)),
+        ("lixel/application/report/lio_pose", _pose_payload(21, 2_010)),
+    ]
+    raw = bytearray(RAW_MAGIC)
+    metadata: list[str] = []
+    for sequence, (topic, payload) in enumerate(messages, start=1):
+        topic_bytes = topic.encode()
+        raw.extend(FRAME_HEADER.pack(len(topic_bytes), len(payload)))
+        raw.extend(topic_bytes)
+        raw.extend(payload)
+        metadata.append(
+            json.dumps(
+                {
+                    "schema_version": 1,
+                    "record_type": "message",
+                    "sequence": sequence,
+                    "received_at_epoch_ns": 1_000_000_000 + sequence * 10_000_000,
+                    "received_monotonic_ns": 5_000_000_000 + sequence * 10_000_000,
+                },
+                separators=(",", ":"),
+            )
+        )
+    capture = root / "mqtt.raw.k1mqtt"
+    capture.write_bytes(raw)
+    (root / "mqtt.metadata.jsonl").write_text(
+        "\n".join(metadata) + "\n",
+        encoding="utf-8",
+    )
+    (root / "mqtt.timeline.origin.json").write_text(
+        json.dumps(
+            {
+                "schema_version": 1,
+                "started_at_epoch_ns": 1_000_000_000,
+                "started_monotonic_ns": 5_000_000_000,
+            }
+        ),
+        encoding="utf-8",
+    )
+    return capture
+
+
+def _endpoint(router: APIRouter, path: str) -> object:
+    for route in router.routes:
+        if isinstance(route, APIRoute) and route.path == path and "GET" in route.methods:
+            return route.endpoint
+    raise AssertionError(f"GET {path} route is missing")
+
+
+def test_lidar_replay_v2_retains_fields_and_passes_equivalence(tmp_path: Path) -> None:
+    capture = _capture(tmp_path)
+    output = build_lidar_replay_pack_v2(capture, tmp_path / "packs")
+    pack = LidarReplayPackV2(output)
+    try:
+        assert pack.identity["session_id"] == "session-001"
+        assert pack.identity["lidar_evidence_profile"] == K1_LIDAR_PACK_V2_PROFILE.to_dict()
+        assert pack.point_frame_count == 2
+        assert pack.pose_frame_count == 2
+        assert pack.point_count == 4
+
+        point = pack.point_frame(0)
+        assert point.capture_sequence == 1
+        assert point.received_at_epoch_ns == 1_010_000_000
+        assert point.received_monotonic_ns == 5_010_000_000
+        assert point.header_seq == 10
+        assert point.header_stamp == 1_000
+        assert point.scaler == 1_000
+        assert point.raw_xyz.tolist() == [[10_000, -2_000, 500], [-250, 10, 4_000]]
+        assert point.xyz_map.tolist() == [[10.0, -2.0, 0.5], [-0.25, 0.01, 4.0]]
+        assert point.rgbi.tolist() == [0x11223344, 0xAABBCC09]
+        assert point.intensity.tolist() == [0x44, 0x09]
+        assert point.decoded_view().intensities == bytes((0x44, 0x09))
+
+        pose = pack.pose_frame(0)
+        assert pose.capture_sequence == 2
+        assert pose.header_seq == 20
+        assert pose.pose_stamp == 1_011
+        assert pose.position_map == (20.0, -2.5, 3.75)
+        assert pose.decoded_view().frame_id == "map"
+
+        assert pack.quality["field_retention"]["raw_rgbi"] is True
+        assert pack.quality["field_retention"]["host_monotonic_ns"] is True
+        assert pack.quality["sensor_range_m"]["sample_count"] == 0
+        assert pack.quality["sensor_range_status"].startswith("unavailable-")
+        assert pack.quality["pose_binding"]["coverage_fraction"] == pytest.approx(1.0)
+        assert pack.equivalence["status"] == "passed"
+        assert pack.equivalence["array_mismatches"] == 0
+        rerun = verify_lidar_replay_equivalence(capture, pack)
+        assert rerun["status"] == "passed"
+    finally:
+        pack.close()
+
+    assert build_lidar_replay_pack_v2(capture, tmp_path / "packs") == output
+
+
+def test_lidar_replay_v2_unblocks_detector_input_but_not_mapping() -> None:
+    assessments = {
+        item.stage: item for item in assess_lidar_profile(K1_LIDAR_PACK_V2_PROFILE)
+    }
+    assert (
+        assessments[LidarPipelineStage.LIDAR_3D_DETECTION].readiness
+        is LidarReadiness.DEGRADED
+    )
+    assert (
+        assessments[LidarPipelineStage.LIDAR_INERTIAL_SLAM].readiness
+        is LidarReadiness.BLOCKED
+    )
+    assert (
+        assessments[LidarPipelineStage.NVIDIA_NVBLOX].readiness
+        is LidarReadiness.BLOCKED
+    )
+
+
+def test_lidar_replay_v2_fails_closed_without_exact_host_timing(
+    tmp_path: Path,
+) -> None:
+    capture = _capture(tmp_path)
+    capture.with_name("mqtt.metadata.jsonl").unlink()
+    with pytest.raises(LidarReplayError, match="exact host timing"):
+        build_lidar_replay_pack_v2(capture, tmp_path / "packs")
+
+
+def test_lidar_api_exposes_path_free_quality_and_equivalence(tmp_path: Path) -> None:
+    capture = _capture(tmp_path)
+    root = tmp_path / "packs"
+    output = build_lidar_replay_pack_v2(capture, root)
+    router = build_lidar_router(root_provider=lambda: root)
+
+    catalog_route = _endpoint(router, "/api/v1/lidar/replay-packs")
+    detail_route = _endpoint(router, "/api/v1/lidar/replay-packs/{pack_id}")
+    catalog = catalog_route(limit=20)  # type: ignore[operator]
+    detail = detail_route(pack_id=output.name)  # type: ignore[operator]
+
+    assert catalog["schema_version"] == "missioncore.lidar-replay-pack-catalog/v1"
+    assert catalog["valid_total"] == 1
+    assert catalog["invalid_total"] == 0
+    assert catalog["items"][0]["equivalence_status"] == "passed"
+    assert detail["pack"]["pack_id"] == output.name
+    assert detail["quality"]["field_retention"]["raw_rgbi"] is True
+    assert detail["equivalence"]["status"] == "passed"
+    assert detail["access"] == "read-only"
+    serialized = repr({"catalog": catalog, "detail": detail})
+    assert str(tmp_path) not in serialized