sync processor from GitLab ac3323f: 深度格式兼容(legacy_mm10+逐批次覆盖)+ UMI Gripper 模块与测试

processor/app/api/projects.py

@@ -186,6 +186,24 @@ def _device_input_sources(episodes: list[dict]) -> list[dict]:
             continue
         low = [key.lower() for key in keys]
         kind = f"{item.get('kind') or ''} {item.get('name') or ''}".lower()
+        if "gripper" in kind or "umi" in kind:
+            # RGB/stereo/force channels published by UMI are one physical
+            # acquisition device.  Keep video source keys for compatibility,
+            # but expose one composite workflow input card.
+            rgb_key = next(
+                (key for key in keys
+                 if "rgb" in key.lower()
+                 and "stereo_left" not in key.lower()
+                 and "stereo_right" not in key.lower()),
+                keys[0],
+            )
+            item["source_keys"] = keys
+            item["slots"] = slots
+            item["input_type"] = "gripper_device"
+            item["source_key"] = rgb_key
+            item["label"] = f"{item['name']} · UMI Gripper"
+            result.append(item)
+            continue
         left_right = (any(key.endswith("_left") or "_left_" in key for key in low)
                       and any(key.endswith("_right") or "_right_" in key for key in low))
         is_stereo = len(keys) >= 2 and (left_right or "stereo" in kind)
@@ -244,6 +262,23 @@ def _online_input_sources(devices: list[dict]) -> list[dict]:
                           if str(key).strip()]
             stereo = len(keys) >= 2 and (left_right or "stereo" in kind)
             has_depth = bool(depth_keys) or "depth" in kind or "rgbd" in kind
+            if "gripper" in kind or "umi" in kind:
+                result.append({
+                    "id": str(device.get("device_id") or name), "name": name,
+                    "kind": device.get("kind") or "gripper",
+                    "input_type": "gripper_device",
+                    "source_key": next(
+                        (key for key in keys
+                         if "rgb" in key.lower()
+                         and "stereo_left" not in key.lower()
+                         and "stereo_right" not in key.lower()),
+                        keys[0],
+                    ),
+                    "source_keys": keys,
+                    "depth_keys": depth_keys,
+                    "label": f"{name} · UMI Gripper",
+                })
+                continue
             result.append({
                 "id": str(device.get("device_id") or name), "name": name,
                 "kind": device.get("kind") or "camera",

processor/app/artifact_resolver.py

@@ -121,8 +121,17 @@ def _canonical_episode_data(session_dir: Path, episode_id: str | None,
                 / f"episode_{index:06d}.parquet")
         if not path.is_file():
             return None
-        import pandas as pd
-        columns = {str(name) for name in pd.read_parquet(path, engine="pyarrow").columns}
+        try:
+            import pyarrow.parquet as pq
+            # Use logical top-level names; physical schema names flatten nested
+            # landmark lists to ``element`` and make valid 3D artifacts look
+            # empty.
+            columns = {str(name) for name in
+                       pq.ParquetFile(path).schema_arrow.names}
+        except Exception:
+            import pandas as pd
+            columns = {str(name) for name in
+                       pd.read_parquet(path, columns=[], engine="pyarrow").columns}
         if dimension == "3d":
             marker = any(
                 "landmarks_3d" in name or "world_position" in name

processor/app/device_naming.py

@@ -18,6 +18,7 @@ DEVICE_LABELS = {
     "mono_rgb": "RGB Camera",
     "stereo_rgb": "Stereo RGB Camera",
     "glove_sensor": "Glove Sensor",
+    "gripper_device": "UMI Gripper",
 }
 
 
@@ -59,6 +60,12 @@ def camera_profile(kind: object = "", name: object = "",
     slot_keys = _keys(slots)
     text = " ".join([kind_text, name_text, *[key.lower() for key in slot_keys]])
 
+    # UMI publishes several internal channels (RGB, stereo and tactile data)
+    # but it is one physical workflow input.  Do this before stereo detection
+    # so its internal left/right camera slots are not exposed as a camera card.
+    if "gripper" in kind_text or "umi" in name_text:
+        return "gripper_device", None
+
     # Collectors do not always spell RGB slots with ``rgb``/``color``;
     # ``stereo_left`` and ``stereo_right`` are also color video streams. Any
     # non-depth-only slot is therefore a color/video slot unless metadata
@@ -105,6 +112,8 @@ def decorate_device_sources(sources: list[dict]) -> list[dict]:
         input_type = str(source.get("input_type") or "")
         if input_type == "glove_sensor":
             profile, lens = "glove_sensor", None
+        elif input_type == "gripper_device":
+            profile, lens = "gripper_device", None
         else:
             profile, lens = camera_profile(
                 source.get("kind"), source.get("name"),

processor/app/lerobot_v21.py

@@ -170,16 +170,33 @@ def _depth_video_info_from_path(path: Path) -> dict[str, Any]:
         info = _read_json(info_path)
         feature = (info.get("features") or {}).get(
             f"observation.images.{source}", {})
-        video_info = feature.get("video_info") if isinstance(feature, dict) else None
-        return dict(video_info) if isinstance(video_info, dict) else {}
+        video_info = dict(feature.get("video_info")) if isinstance(feature, dict) and isinstance(feature.get("video_info"), dict) else {}
+        # 逐批次覆盖:episodes 索引行可声明 video.depth_encoding,
+        # 用于"同一会话混合新旧格式"的历史数据(如 9/4 对数批次与
+        # 8 月 mm/10 批次并存于一个会话)。
+        try:
+            import pyarrow.parquet as pq
+            idx = info_path.parent / "episodes" / "chunk-000" / f"{path.stem}.parquet"
+            if idx.is_file():
+                row = pq.read_table(idx).to_pandas().iloc[0]
+                override = row.get("video.depth_encoding")
+                if override and str(override).strip():
+                    video_info["video.depth_encoding"] = str(override).strip()
+        except Exception:
+            pass
+        return video_info
     return {}
 
 
 def _depth_video_mode(video_info: dict[str, Any]) -> str:
-    """Return ``log``, ``legacy_log`` or ``direct_mm`` for a stored stream."""
+    """Return ``log``, ``legacy_log``, ``legacy_mm10`` or ``direct_mm`` for a stored stream."""
     if not isinstance(video_info, dict):
         video_info = {}
     encoding = str(video_info.get("video.depth_encoding") or "").lower()
+    # 8 月老采集端深度按 0.1 系数存储(毫米/10),显式声明为 legacy_mm10。
+    # 该检查必须在 uint16_mm 检查之前,否则会被当成直接毫米读出 10 倍偏小。
+    if "mm10" in encoding or "mm/10" in encoding:
+        return "legacy_mm10"
     # Older uploads explicitly identify the gray12le samples as direct
     # millimetres.  This check must happen before the generic gray12le
     # fallback below; otherwise a direct-mm stream is interpreted as a log
@@ -765,6 +782,12 @@ class DepthVideoReader:
             # processing must retain its invalid-pixel semantics.
             depth[codes == 0] = 0
             return depth
+        if self.mode == "legacy_mm10":
+            # 8 月老采集端把毫米深度按 0.1 系数存储(码值 = mm/10),
+            # ×10 还原毫米;0 仍保持无效像素语义。
+            depth = codes.astype(np.float64) * 10.0
+            depth[codes == 0] = 0.0
+            return np.rint(np.clip(depth, 0, 65535)).astype("<u2")
         if self.mode == "legacy_log":
             low = float(self.video_info["video.depth_min"])
             high = float(self.video_info["video.depth_max"])

processor/app/main.py

@@ -80,6 +80,7 @@ app.add_middleware(AuthMiddleware)
 # 像卡死。这些路径直接透传原始字节(去掉 accept-encoding 头即可)。
 _NO_COMPRESS_PATH_HINTS = (
     "download", "stream", "depth-codes", "depth-preview", "skeleton", "hdf5",
+    "tactile-matrix-data",
 )
 
 

processor/app/processing/batch.py

@@ -40,7 +40,7 @@ _CAMERA_TYPE_RULES: dict[str, tuple[str, ...]] = {
 }
 
 # 匹配优先级(显式顺序,不依赖注册序):双目先认领,单目兜底
-_MATCH_PRIORITY = ["stereo_rgbd_camera", "stereo_camera", "rgbd_camera", "mono_camera"]
+_MATCH_PRIORITY = ["gripper_device", "stereo_rgbd_camera", "stereo_camera", "rgbd_camera", "mono_camera"]
 
 # 传感器类输入源关键词:mono 兜底认领时跳过(不抢手套/IMU/深度等)
 _SENSOR_NAME_KEYWORDS = ("glove", "imu", "action", "tactile", "sensor",
@@ -89,7 +89,18 @@ def match_input_modules(available: set[str]) -> list[dict]:
                     break
         # 2) 类型兜底
         if not hits:
-            if node_type == "mono_camera":
+            if node_type == "gripper_device":
+                # A UMI gripper publishes several internal channel names but
+                # represents one physical acquisition source.
+                gripper_hits = []
+                for a in sorted(available):
+                    if a in used:
+                        continue
+                    if "gripper" in a or "umi" in a:
+                        gripper_hits.append(a)
+                        used.add(a)
+                hits.extend(gripper_hits)
+            elif node_type == "mono_camera":
                 # 单目 = 兜底认领剩余相机名(跳过传感器/深度类名称)
                 for a in sorted(available):
                     if a in used:

processor/app/processing/modules/gripper_device.py

@@ -0,0 +1,191 @@
+"""UMI Gripper device input.
+
+This is a composite workflow *source* node.  The acquisition client uploads
+one gripper episode, while the workflow receives its RGB video, ESP32 grip
+state, SLAM trajectory and the two calibrated tactile force matrices through
+typed output ports.  The node does not control hardware or recapture data.
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from app.processing import ArtifactRef, JobContext, ProcessingModule, field
+from app.processing.registry import register
+from app.processing.theme import INPUT_COLOR
+
+
+_VIDEO_OUTPUT = "rgb_video"
+_PARQUET_COLUMNS = {
+    "gripper_state": "observation.gripper_state",
+    "slam_trajectory": "observation.slam_pose",
+}
+_TACTILE_COLUMNS = {
+    "left": "observation.gripper_left_force_matrix",
+    "right": "observation.gripper_right_force_matrix",
+}
+_ALL_PARQUET_COLUMNS = set(_PARQUET_COLUMNS.values()) | set(_TACTILE_COLUMNS.values())
+
+
+def _read_info(root: Path) -> dict:
+    path = root / "meta" / "info.json"
+    try:
+        value = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, ValueError, TypeError):
+        return {}
+    return value if isinstance(value, dict) else {}
+
+
+def _values(value: object) -> list[str]:
+    if isinstance(value, str):
+        return [item.strip() for item in value.split(",") if item.strip()]
+    if isinstance(value, (list, tuple, set)):
+        return [str(item).strip() for item in value if str(item).strip()]
+    return []
+
+
+def _selected_gripper(info: dict, config: dict) -> dict:
+    """Return the selected physical gripper declaration, if any."""
+    wanted = {item.casefold() for item in (
+        _values(config.get("source_keys"))
+        + _values(config.get("source_key"))
+        + _values(config.get("device_id"))
+        + _values(config.get("device_name"))
+    )}
+    candidates = []
+    for item in info.get("devices") or []:
+        if not isinstance(item, dict):
+            continue
+        kind = str(item.get("kind") or "").casefold()
+        name = str(item.get("name") or "")
+        key = str(item.get("key") or "")
+        slots = _values(item.get("slots"))
+        haystack = {value.casefold() for value in (name, key, *slots) if value}
+        if "gripper" in kind or "gripper" in name.casefold() or "umi" in name.casefold():
+            candidates.append((bool(wanted & haystack), item))
+    if candidates:
+        candidates.sort(key=lambda pair: (not pair[0], str(pair[1].get("key") or pair[1].get("name") or "")))
+        return candidates[0][1]
+    return {}
+
+
+def _video_entries(root: Path) -> list[tuple[str, Path]]:
+    from app.lerobot_v21 import iter_video_streams
+    videos_root = root / "videos"
+    if not videos_root.is_dir():
+        return []
+    return [(str(source), path) for source, path in iter_video_streams(videos_root)]
+
+
+def _find_rgb_video(root: Path, info: dict, config: dict) -> tuple[str, Path] | None:
+    entries = _video_entries(root)
+    if not entries:
+        return None
+    device = _selected_gripper(info, config)
+    slots = {value.casefold() for value in _values(device.get("slots"))}
+    configured = {value.casefold() for value in (
+        _values(config.get("source_keys")) + _values(config.get("source_key"))
+    )}
+
+    def is_primary(source: str) -> bool:
+        low = source.casefold()
+        return (low in slots or low in configured
+                or "gripper_rgb" in low or ("gripper" in low and "rgb" in low)) and not (
+                    "stereo_left" in low or "stereo_right" in low
+                    or low.endswith("_left") or low.endswith("_right"))
+
+    for source, path in entries:
+        if is_primary(source):
+            return source, path
+    # A valid device declaration may use a non-standard RGB slot name.  If
+    # the selected gripper has exactly one non-stereo video, use that slot.
+    non_stereo = [item for item in entries if not any(
+        token in item[0].casefold() for token in ("stereo_left", "stereo_right"))]
+    if len(non_stereo) == 1 and (device or configured):
+        return non_stereo[0]
+    return None
+
+
+def _parquet_columns(root: Path) -> tuple[Path, set[str]] | None:
+    try:
+        import pyarrow.parquet as pq
+    except ImportError:
+        return None
+    candidates: list[tuple[Path, set[str]]] = []
+    for path in sorted(root.rglob("*.parquet")):
+        if "/meta/" in path.as_posix().casefold():
+            continue
+        try:
+            names = set(str(name) for name in pq.read_schema(path).names)
+        except (OSError, ValueError):
+            continue
+        if names & _ALL_PARQUET_COLUMNS:
+            candidates.append((path, names))
+    if not candidates:
+        return None
+    candidates.sort(key=lambda item: (-len(item[1] & _ALL_PARQUET_COLUMNS), item[0].as_posix()))
+    return candidates[0]
+
+
+@register
+class GripperDeviceModule(ProcessingModule):
+    slug = "gripper_device"
+    version = "1.1"
+    category = "input"
+    label = "UMI Gripper"
+    icon = "ant-design:robot-outlined"
+    color = INPUT_COLOR
+    outputs = (
+        {"key": "rgb_video", "label": "RGB Video"},
+        {"key": "gripper_state", "label": "ESP Gripper State"},
+        {"key": "slam_trajectory", "label": "SLAM Trajectory"},
+        {"key": "tactile_force_matrices", "label": "Left and Right Force Matrices"},
+    )
+    default_config = {"source_key": "", "fps": 30}
+    config_schema = (
+        field("source_key", "string", "Gripper device / source key", ""),
+    )
+    execution_target = "server"
+    capabilities = ("composite_device", "video_input", "gripper", "slam", "tactile")
+
+    def run(self, ctx: JobContext) -> dict[str, ArtifactRef] | None:
+        info = _read_info(ctx.input_root)
+        outputs: dict[str, ArtifactRef] = {}
+        rgb = _find_rgb_video(ctx.input_root, info, ctx.config)
+        if rgb is not None:
+            source, path = rgb
+            outputs[_VIDEO_OUTPUT] = ctx.ref(
+                "gripper_rgb_video", path, source_key=source,
+                metadata={"device_type": "umi_gripper"},
+            )
+
+        parquet = _parquet_columns(ctx.input_root)
+        if parquet is not None:
+            path, columns = parquet
+            for output, column in _PARQUET_COLUMNS.items():
+                if column not in columns:
+                    continue
+                metadata = {"column": column, "device_type": "umi_gripper"}
+                if output == "slam_trajectory":
+                    metadata.update({"shape": [7], "names": ["x", "y", "z", "qx", "qy", "qz", "qw"]})
+                outputs[output] = ctx.ref(
+                    output, path, source_key=column, metadata=metadata,
+                )
+            tactile_columns = [column for column in _TACTILE_COLUMNS.values() if column in columns]
+            if len(tactile_columns) == len(_TACTILE_COLUMNS):
+                outputs["tactile_force_matrices"] = ctx.ref(
+                    "tactile_force_matrices", path,
+                    source_key="observation.gripper_force_matrices",
+                    metadata={
+                        "columns": tactile_columns,
+                        "sides": ["left", "right"],
+                        "shape": [2, 250, 250, 3],
+                        "components": ["fx", "fy", "fz"],
+                        "device_type": "umi_gripper",
+                    },
+                )
+
+        if not outputs:
+            ctx.skip("UMI gripper RGB/video and data channels were not found")
+        return outputs

processor/app/project_dataset.py

@@ -876,6 +876,55 @@ def _merge_unique_dicts(existing: list[dict[str, Any]], additions: Any,
     return result
 
 
+def _project_data_contract(project_root: Path) -> tuple[set[str], set[str], set[str]]:
+    """Return the data columns, real video sources and semantic device slots.
+
+    ``meta/info.json`` is an aggregate and can outlive a camera stream after a
+    re-upload.  The canonical files are authoritative for the feature list.
+    This helper deliberately treats unreadable Parquet as empty instead of
+    preserving stale declarations that make the UI request missing media.
+    """
+    root = Path(project_root)
+    data_columns: set[str] = set()
+    data_root = root / "data"
+    if data_root.is_dir():
+        try:
+            import pyarrow.parquet as pq
+            for path in data_root.rglob("*.parquet"):
+                try:
+                    data_columns.update(str(name) for name in pq.read_schema(path).names)
+                except (OSError, ValueError):
+                    continue
+        except ImportError:
+            pass
+
+    video_sources = {
+        str(source) for source, _path in iter_video_streams(root / "videos")
+        if str(source).strip()
+    }
+    semantic_slots = set(video_sources)
+    if "observation.slam_pose" in data_columns:
+        semantic_slots.add("gripper_pose")
+    if "observation.gripper_left_force" in data_columns:
+        semantic_slots.add("gripper_force_left")
+    if "observation.gripper_right_force" in data_columns:
+        semantic_slots.add("gripper_force_right")
+    if "observation.gripper_left_force_matrix" in data_columns:
+        semantic_slots.add("gripper_force_matrix_left")
+    if "observation.gripper_right_force_matrix" in data_columns:
+        semantic_slots.add("gripper_force_matrix_right")
+    return data_columns, video_sources, semantic_slots
+
+
+def _feature_is_present(key: str, feature: Any,
+                       data_columns: set[str], video_sources: set[str]) -> bool:
+    if not isinstance(feature, dict):
+        return key in data_columns
+    if feature.get("dtype") == "video" or key.startswith("observation.images."):
+        return key.removeprefix("observation.images.") in video_sources
+    return key in data_columns
+
+
 def _merge_info(project_root: Path, source_info: dict[str, Any], rows: list[dict[str, Any]],
                 tasks: list[dict[str, Any]]) -> dict[str, Any]:
     target = _read_json(project_root / "meta" / "info.json", {})
@@ -885,8 +934,16 @@ def _merge_info(project_root: Path, source_info: dict[str, Any], rows: list[dict
     source_info = normalize_metadata_sources(source_info)
     if not target:
         target = dict(source_info)
+    for key in ("project_id", "project_name"):
+        if source_info.get(key) and not target.get(key):
+            target[key] = source_info[key]
     features = dict(target.get("features") or {})
     features.update(dict(source_info.get("features") or {}))
+    data_columns, video_sources, semantic_slots = _project_data_contract(project_root)
+    features = {
+        key: value for key, value in features.items()
+        if _feature_is_present(key, value, data_columns, video_sources)
+    }
     target.update({
         "format": "lerobot_v2.1",
         "codebase_version": "v2.1",
@@ -917,17 +974,71 @@ def _merge_info(project_root: Path, source_info: dict[str, Any], rows: list[dict
     target["devices"] = _merge_unique_dicts(
         target.get("devices") or [], source_info.get("devices"), ("key",),
     )
+    filtered_devices: list[dict[str, Any]] = []
+    for device in target["devices"]:
+        if not isinstance(device, dict):
+            continue
+        slots = [str(slot) for slot in (device.get("slots") or [])
+                 if str(slot) in semantic_slots]
+        if not slots:
+            continue
+        item = dict(device)
+        item["slots"] = slots
+        filtered_devices.append(item)
+    target["devices"] = filtered_devices
     names = dict(target.get("device_names") or {})
     names.update(dict(source_info.get("device_names") or {}))
-    target["device_names"] = names
+    target["device_names"] = {
+        key: value for key, value in names.items()
+        if key in semantic_slots
+    }
     cameras = dict(target.get("cameras") or {})
     cameras.update(dict(source_info.get("cameras") or {}))
-    target["cameras"] = cameras
+    target["cameras"] = {
+        key: value for key, value in cameras.items()
+        if key in video_sources
+    }
     sensors = list(dict.fromkeys(
         [str(value) for value in (target.get("sensors") or [])]
         + [str(value) for value in (source_info.get("sensors") or [])]
     ))
-    target["sensors"] = sensors
+    target["sensors"] = [
+        sensor for sensor in sensors
+        if any(sensor.casefold() in column.casefold() for column in data_columns)
+    ]
+    # Make the common UMI/SLAM contract machine-readable without guessing the
+    # meaning of the legacy three-value ``gripper_state`` vector.
+    semantic_fields = {
+        "observation.slam_pose": {
+            "names": ["x", "y", "z", "qx", "qy", "qz", "qw"],
+            "units": ["m", "m", "m", "unitless", "unitless", "unitless", "unitless"],
+            "quaternion_order": "xyzw",
+        },
+        "observation.gripper_left_force": {
+            "names": ["fx", "fy", "fz"],
+            "units": ["sensor_unit", "sensor_unit", "sensor_unit"],
+        },
+        "observation.gripper_right_force": {
+            "names": ["fx", "fy", "fz"],
+            "units": ["sensor_unit", "sensor_unit", "sensor_unit"],
+        },
+        "observation.gripper_left_force_matrix": {
+            "names": ["fx", "fy", "fz"],
+            "units": ["mN", "mN", "mN"],
+            "encoding": "row_diff_quantized",
+        },
+        "observation.gripper_right_force_matrix": {
+            "names": ["fx", "fy", "fz"],
+            "units": ["mN", "mN", "mN"],
+            "encoding": "row_diff_quantized",
+        },
+    }
+    for key, metadata in semantic_fields.items():
+        if key in target["features"]:
+            target["features"][key] = {
+                **target["features"][key],
+                **metadata,
+            }
     return target
 
 
@@ -1741,8 +1852,13 @@ def allocate_project_episode_id(project_root: Path, incoming_name: str,
         return incoming
     used = [int(row.get("episode_index")) for row in existing
             if _episode_index(row.get("episode_index")) is not None]
-    next_index = max(used, default=0) + 1
+    next_index = max(used, default=-1) + 1
     prefix = str(project_name or project_root.name or "episode").strip()
+    # Old projects may already contain a malformed pair such as
+    # episode_index=0 / episode_id=Project_000001.  Never reuse that ID for a
+    # new upload; the storage index and the public ID are separate concerns.
+    while f"{prefix}_{next_index:06d}" in existing_ids:
+        next_index += 1
     return f"{prefix}_{next_index:06d}"
 
 

processor/app/routes/ingestion.py

@@ -642,6 +642,20 @@ def episode_media_groups(episode_id: str):
         """单个原始视频条目;手部骨骼由前端 SVG 覆盖层显示。"""
         cam = item["source_key"]
         stream = streams.get(cam) or {}
+        video_cache_key = None
+        try:
+            raw_path = Path(str(stream.get("path") or ""))
+            candidates = [raw_path] if raw_path.is_absolute() else [
+                batch_dir / raw_path,
+                batch_dir.parents[1] / raw_path,
+            ]
+            for video_path in candidates:
+                if video_path.is_file():
+                    stat = video_path.stat()
+                    video_cache_key = f"{stat.st_size:x}-{stat.st_mtime_ns:x}"
+                    break
+        except OSError:
+            pass
         entry = {
             "source_key": cam,
             "role": item.get("role", "primary"),
@@ -654,6 +668,7 @@ def episode_media_groups(episode_id: str):
             # raw endpoint remains available for download/diagnostics.
             "stream_url": f"/api/v1/video/{episode_id}/{cam}/preview-stream",
             "raw_stream_url": f"/api/v1/video/{episode_id}/{cam}/stream",
+            "video_cache_key": video_cache_key,
         }
         return entry
 
@@ -666,6 +681,7 @@ def episode_media_groups(episode_id: str):
             "label": entry["label"],
             "stream_url": entry["stream_url"],
             "raw_stream_url": entry.get("raw_stream_url"),
+            "video_cache_key": entry.get("video_cache_key"),
             "frame_count": entry["frame_count"],
             "fps": entry["fps"],
         }

processor/app/routes/session.py

@@ -267,6 +267,8 @@ async def _process_upload_job(
         # ---- 读任务名 ----
         meta_root = _find_meta_dir(extract_tmp) or extract_tmp
         info = _read_json(meta_root / "meta" / "info.json")
+        if not isinstance(info, dict):
+            info = {}
         fps = info.get("fps", 30)
         codebase_version = info.get("codebase_version", "v3.0")
 
@@ -310,12 +312,22 @@ async def _process_upload_job(
             list_projects, write_episode_state, list_upload_history,
         )
         requested_project_id = str(project_id or "").strip()
-        project_name = (name or zip_info['prefix']).strip()
+        archive_project_name = str(
+            info.get("project_name") or info.get("task_name") or ""
+        ).strip()
+        archive_project_id = str(info.get("project_id") or "").strip()
+        # ``task_name`` is the project display name for collector archives.
+        # The upload form name remains a backwards-compatible fallback, while
+        # an explicit project_id still has highest priority below.
+        project_name = (archive_project_name or name or zip_info['prefix']).strip()
         # 项目可以先建好再搭工作流。只有 archived 项目不再接收新批次；
         # draft/active/paused 都保留数据归属，active 才决定是否自动派发。
         active_projects = [p for p in list_projects()
                            if p.get("status", "active") != "archived"]
 
+        def _name_key(value: object) -> str:
+            return sanitize_task_name(str(value or "")).casefold()
+
         def _project_aliases(project: dict) -> set[str]:
             aliases = {str(project.get("name") or "").strip()}
             raw_aliases = project.get("name_aliases") or []
@@ -364,10 +376,11 @@ async def _process_upload_job(
             # Legacy clients may still send only name. Keep compatibility, but
             # require a unique exact/prefix resolution when no project_id was
             # supplied; the selected project remains visible in the response.
-            project_name_low = project_name.lower()
             exact_hits = [
                 p for p in active_projects
-                if project_name_low in {alias.lower() for alias in aliases_by_project[id(p)]}
+                if (_name_key(project_name) in {
+                    _name_key(alias) for alias in aliases_by_project[id(p)]
+                })
             ]
             if len(exact_hits) == 1:
                 matched_project = exact_hits[0]
@@ -380,7 +393,7 @@ async def _process_upload_job(
             else:
                 prefix_hits = [
                     p for p in active_projects
-                    if any(project_name_low.startswith(alias.lower())
+                    if any(_name_key(project_name).startswith(_name_key(alias))
                            for alias in aliases_by_project[id(p)])
                 ]
                 # Only use a prefix fallback when exactly one project wins.
@@ -390,13 +403,13 @@ async def _process_upload_job(
                         len(alias)
                         for p in prefix_hits
                         for alias in aliases_by_project[id(p)]
-                        if project_name_low.startswith(alias.lower())
+                        if _name_key(project_name).startswith(_name_key(alias))
                     )
                     longest_hits = [
                         p for p in prefix_hits
                         if any(
-                            project_name_low.startswith(alias.lower())
-                            and len(alias) == longest
+                            _name_key(project_name).startswith(_name_key(alias))
+                            and len(_name_key(alias)) == longest
                             for alias in aliases_by_project[id(p)]
                         )
                     ]
@@ -408,7 +421,18 @@ async def _process_upload_job(
                             detail=(f"Ambiguous project prefix '{project_name}'; "
                                     "provide project_id explicitly"),
                         )
-        project_folder = sanitize_task_name(matched_project["name"]) if matched_project else "Uncategorized"
+        resolved_project_name = str(
+            matched_project.get("name") if matched_project
+            else project_name or "Uncategorized"
+        ).strip() or "Uncategorized"
+        resolved_project_id = (
+            str(matched_project.get("id")) if matched_project and matched_project.get("id")
+            else archive_project_id or None
+        )
+        # A collector archive with a task/project name gets its own project
+        # root even when no server-side workflow/project record exists yet.
+        # This keeps ingestion isolated without creating a workflow.
+        project_folder = sanitize_task_name(resolved_project_name)
         upload_history = list_upload_history()
         project_dir = settings.storage_root / "sessions" / project_folder
         from app.project_dataset import (
@@ -435,7 +459,10 @@ async def _process_upload_job(
             project_dir, incoming_name,
             matched_project["name"] if matched_project else project_folder,
         )
-        batch_preexisted = batch_name in existing_ids
+        # Only an ID that came from an existing upload is a re-upload.  Never
+        # infer replacement from the generated candidate ID; old datasets may
+        # contain mismatched IDs such as index=0 / id=..._000001.
+        batch_preexisted = incoming_name in existing_ids
         is_reupload = batch_preexisted
         batch_dir = project_dir
         archive_size_bytes = archive_path.stat().st_size if archive_path.is_file() else 0
@@ -463,6 +490,13 @@ async def _process_upload_job(
         )
         normalize_extracted_dataset(staging_dir, batch_name)
         info = _read_json(staging_dir / "meta" / "info.json")
+        if not isinstance(info, dict):
+            info = {}
+        info["project_name"] = resolved_project_name
+        if resolved_project_id:
+            info["project_id"] = resolved_project_id
+        info["task_name"] = str(info.get("task_name") or resolved_project_name)
+        _write_json(staging_dir / "meta" / "info.json", info)
 
         # ---- 直接扫描规范化后的源视频,不把纯深度流当成 RGB 相机 ----
         video_records = []
@@ -492,7 +526,8 @@ async def _process_upload_job(
         new_state = {
             "id": batch_name,
             "name": batch_name,
-            "project": matched_project["name"] if matched_project else "Uncategorized",
+            "project": resolved_project_name,
+            "project_id": resolved_project_id,
             "status": "to_review",
             "fps": fps,
             "frame_count": master_frame_count,
@@ -647,8 +682,8 @@ async def _process_upload_job(
             "session_name": zip_info['prefix'],
             "files_preserved": str(batch_dir),
             "imported": 1 if video_records else 0,
-            "project_id": matched_project.get("id") if matched_project else None,
-            "project_name": matched_project.get("name") if matched_project else None,
+            "project_id": resolved_project_id,
+            "project_name": resolved_project_name,
             "dispatch": dispatch_result,
             "episodes": [{
                 "episode_id": batch_name,
@@ -1059,6 +1094,16 @@ def _read_json(path: Path) -> dict:
     return {}
 
 
+def _write_json(path: Path, value: dict) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    temporary = path.with_suffix(path.suffix + ".tmp")
+    temporary.write_text(
+        json.dumps(value, ensure_ascii=False, indent=2) + "\n",
+        encoding="utf-8",
+    )
+    temporary.replace(path)
+
+
 def _read_lines(path: Path) -> list[str]:
     if path.exists():
         with open(path) as f: return f.readlines()

processor/app/routes/video.py

@@ -5,6 +5,8 @@ import re
 import asyncio
 import shutil
 import threading
+import math
+from collections import OrderedDict
 from pathlib import Path
 from uuid import UUID, uuid4
 
@@ -33,6 +35,28 @@ _DEPTH_READER_POOL_LOCK = threading.Lock()
 _DEPTH_READER_POOL_MAX = 8
 _DEPTH_FRAME_CACHE: dict[tuple[str, int], object] = {}
 _DEPTH_FRAME_CACHE_MAX = 48
+# Canonical SLAM rows are shared by the trajectory and frame-window requests.
+# The cache is keyed by file size/mtime so a workflow reprocess cannot return
+# a trajectory from an older parquet.
+_SLAM_DATA_CACHE: dict[str, tuple[str, list[dict]]] = {}
+_SLAM_DATA_CACHE_MAX = 8
+# UMI tactile matrices are stored as three flattened int16 planes per frame
+# (250*250*3).  Keep only encoded preview images here; never retain a whole
+# episode of matrices in the API process.
+_TACTILE_PREVIEW_CACHE: OrderedDict[tuple, bytes] = OrderedDict()
+_TACTILE_PREVIEW_CACHE_MAX = 48
+_TACTILE_FIELD_CACHE: OrderedDict[tuple, tuple[bytes, float, float]] = OrderedDict()
+_TACTILE_FIELD_CACHE_MAX = 96
+_TACTILE_PREVIEW_LOCK = threading.Lock()
+_TACTILE_SHAPE = (250, 250)
+_TACTILE_COLUMNS = {
+    "left": "observation.gripper_left_force_matrix",
+    "right": "observation.gripper_right_force_matrix",
+}
+_TACTILE_FORCE_COLUMNS = {
+    "left": "observation.gripper_left_force",
+    "right": "observation.gripper_right_force",
+}
 # Sequential decode is cheap, but decoding through more than this many
 # frames to reach a scrub target is not; jump via a seek reader instead.
 _DEPTH_WINDOW_SEEK_GAP = 6
@@ -225,6 +249,621 @@ def _canonical_episode_data_files(session_dir: Path, episode_id: str) -> list[Pa
     except (OSError, TypeError, ValueError):
         return []
 
+
+def _read_gripper_state(value) -> list[float] | None:
+    """Read the legacy UMI state vector without changing its raw values.
+
+    The acquisition contract used by the current gripper writer is
+    ``[percent, gripped, raw]``.  Keep the complete vector in the response so
+    future renderers can use the encoder value without recomputing it.
+    """
+    if value is None:
+        return None
+    try:
+        values = list(value)
+    except TypeError:
+        return None
+    result: list[float] = []
+    for item in values[:3]:
+        try:
+            number = float(item)
+        except (TypeError, ValueError, OverflowError):
+            return None
+        if not math.isfinite(number):
+            return None
+        result.append(number)
+    return result or None
+
+
+def _read_slam_rows(path: Path) -> tuple[str, list[dict]]:
+    """Read canonical ``observation.slam_pose`` rows once per parquet revision."""
+    import numpy as np
+    import pandas as pd
+
+    path = Path(path)
+    try:
+        stat = path.stat()
+        revision = f"{int(stat.st_size):x}-{int(stat.st_mtime_ns):x}"
+    except OSError:
+        return "unknown", []
+    cache_key = str(path.resolve())
+    cached = _SLAM_DATA_CACHE.get(cache_key)
+    if cached is not None and cached[0] == revision:
+        return cached
+    columns = ["frame_index", "timestamp", "observation.slam_pose"]
+    has_gripper_state = False
+    try:
+        import pyarrow.parquet as pq
+        available_columns = set(pq.ParquetFile(path).schema_arrow.names)
+        has_gripper_state = "observation.gripper_state" in available_columns
+    except Exception:
+        pass
+    if has_gripper_state:
+        columns.append("observation.gripper_state")
+    try:
+        df = pd.read_parquet(path, columns=columns, engine="pyarrow")
+    except Exception:
+        return revision, []
+
+    rows: list[dict] = []
+    for _, row in df.iterrows():
+        try:
+            frame = int(row.get("frame_index", len(rows)))
+        except (TypeError, ValueError):
+            continue
+        timestamp = row.get("timestamp")
+        try:
+            timestamp = float(timestamp) if np.isfinite(float(timestamp)) else None
+        except (TypeError, ValueError):
+            timestamp = None
+        pose = row.get("observation.slam_pose")
+        try:
+            values = np.asarray(pose, dtype=np.float64).reshape(-1)
+        except (TypeError, ValueError):
+            values = np.empty(0, dtype=np.float64)
+
+        # A missing native SLAM sample is represented by an all-zero pose in
+        # some recordings.  It is not the same thing as a valid pose at the
+        # origin: a valid pose always has a unit quaternion.  Keep only valid
+        # poses and remember the gap so the renderer can break the polyline.
+        valid = values.size >= 7 and np.isfinite(values[:7]).all()
+        if valid:
+            quaternion_norm = float(np.linalg.norm(values[3:7]))
+            valid = 0.5 <= quaternion_norm <= 1.5
+        if not valid:
+            continue
+        rows.append({
+            "f": frame,
+            "p": [float(value) for value in values[:7]],
+            "t": timestamp,
+            "g": _read_gripper_state(row.get("observation.gripper_state"))
+            if has_gripper_state else None,
+        })
+    rows.sort(key=lambda item: item["f"])
+
+    # Decimation can legitimately make frame numbers non-consecutive, so the
+    # frontend must not infer a gap from every frame jump.  Mark only gaps
+    # caused by missing/invalid source rows; sampled long trajectories remain
+    # a continuous polyline.
+    previous_frame = None
+    for item in rows:
+        frame = int(item["f"])
+        item["gap_before"] = (
+            previous_frame is not None and frame != previous_frame + 1
+        )
+        previous_frame = frame
+    result = (revision, rows)
+    _SLAM_DATA_CACHE[cache_key] = result
+    while len(_SLAM_DATA_CACHE) > _SLAM_DATA_CACHE_MAX:
+        _SLAM_DATA_CACHE.pop(next(iter(_SLAM_DATA_CACHE)))
+    return result
+
+
+def _decimate_slam_rows(rows: list[dict], max_points: int) -> list[dict]:
+    if max_points <= 0 or len(rows) <= max_points:
+        return rows
+    if max_points == 1:
+        return [rows[0]]
+    indexes = {
+        round(index * (len(rows) - 1) / (max_points - 1))
+        for index in range(max_points)
+    }
+    return [rows[index] for index in sorted(indexes)]
+
+
+def _tactile_episode_file(episode_id: str) -> Path | None:
+    ep = get_episode(episode_id)
+    if ep is None:
+        return None
+    files = _canonical_episode_data_files(Path(ep["path"]), episode_id)
+    return files[0] if files else None
+
+
+def _tactile_matrix_columns(path: Path) -> set[str]:
+    try:
+        import pyarrow.parquet as pq
+        return set(pq.ParquetFile(path).schema_arrow.names)
+    except Exception:
+        return set()
+
+
+def _read_tactile_force_series(path: Path) -> dict | None:
+    """Read the small scalar-force series used by the matrix value badges."""
+    import numpy as np
+    import pyarrow.parquet as pq
+
+    try:
+        available = set(pq.ParquetFile(path).schema_arrow.names)
+        selected = [
+            column for column in _TACTILE_FORCE_COLUMNS.values()
+            if column in available
+        ]
+        if not selected:
+            return None
+        table = pq.read_table(path, columns=["frame_index", *selected])
+        frames = [int(value) for value in table.column("frame_index").to_pylist()]
+        result = {"frames": frames, "left": [], "right": []}
+        for side, column in _TACTILE_FORCE_COLUMNS.items():
+            if column not in selected:
+                result[side] = [None] * len(frames)
+                continue
+            values = table.column(column).to_pylist()
+            normalized = []
+            for value in values:
+                try:
+                    vector = np.asarray(value, dtype=np.float64).reshape(-1)
+                    if vector.size < 3 or not np.isfinite(vector[:3]).all():
+                        normalized.append(None)
+                    else:
+                        normalized.append([float(item) for item in vector[:3]])
+                except (TypeError, ValueError, OverflowError):
+                    normalized.append(None)
+            result[side] = normalized
+        return result
+    except Exception:
+        return None
+
+
+def _decode_tactile_matrix(value):
+    """Decode one canonical 250x250x3 row-diff force matrix to mN.
+
+    The recorder difference-encodes each sensor row after interleaving the
+    three components: ``[fx0, fy0, fz0, fx1, fy1, fz1, ...]``.  Therefore the
+    prefix sum must run over the full 750-value row before reshaping back to
+    HWC.  Splitting H/W/C first and accumulating each channel independently
+    produces a different matrix and was the cause of the incorrect preview.
+    The int16 cast is intentional: the recorder's contract is modulo-2^16 and
+    the final values are integer mN.
+    """
+    import numpy as np
+
+    if value is None:
+        return None
+    try:
+        if isinstance(value, (bytes, bytearray, memoryview)):
+            raw = np.frombuffer(value, dtype="<i2")
+        else:
+            raw = np.asarray(value, dtype=np.int16).reshape(-1)
+    except (TypeError, ValueError):
+        return None
+    if raw.size == 0:
+        return None
+    pixels = _TACTILE_SHAPE[0] * _TACTILE_SHAPE[1]
+    if raw.size == pixels * 3:
+        # Canonical data: row-diff over H x (W*3), then H x W x [fx,fy,fz].
+        flat_rows = raw.reshape(_TACTILE_SHAPE[0], _TACTILE_SHAPE[1] * 3)
+        decoded_hwc = np.cumsum(flat_rows, axis=1, dtype=np.int16)
+        decoded = decoded_hwc.reshape(*_TACTILE_SHAPE, 3).transpose(2, 0, 1)
+    elif raw.size == pixels:
+        # Legacy single-channel field: row-diff over H x W.
+        rows = raw.reshape(*_TACTILE_SHAPE)
+        decoded = np.cumsum(rows, axis=1, dtype=np.int16)[None, ...]
+    else:
+        return None
+    decoded = decoded.astype(np.float32)
+    if decoded.shape[0] == 1:
+        decoded = decoded.repeat(3, axis=0)
+    return decoded
+
+
+def _read_tactile_frame(path: Path, frame_index: int, side: str):
+    """Read only the requested parquet row and side.
+
+    PyArrow applies the frame_index predicate before materialising the list
+    column.  This keeps normal scrubbing bounded to one matrix row instead of
+    loading both force streams into the browser.
+    """
+    import numpy as np
+    import pyarrow as pa
+    import pyarrow.parquet as pq
+
+    column = _TACTILE_COLUMNS.get(side)
+    if column is None:
+        return None
+    try:
+        table = pq.read_table(
+            path,
+            columns=["frame_index", column],
+            filters=[("frame_index", "=", int(frame_index))],
+        )
+        if table.num_rows == 0:
+            return None
+        frames = table.column("frame_index").to_pylist()
+        column_data = table.column(column)
+        if isinstance(column_data, pa.ChunkedArray):
+            column_data = column_data.combine_chunks()
+        offsets = np.asarray(column_data.offsets, dtype=np.int64)
+        values = np.asarray(column_data.values, dtype=np.int16)
+        for index, frame in enumerate(frames):
+            if int(frame) == int(frame_index):
+                decoded = _decode_tactile_matrix(
+                    values[offsets[index]:offsets[index + 1]])
+                # Some writers emit an empty vector for a valid first frame
+                # before the tactile device publishes its first sample. Keep
+                # that frame drawable as an all-zero matrix rather than
+                # making the UI show a broken image.
+                if decoded is None:
+                    return np.zeros((3, *_TACTILE_SHAPE), dtype=np.float32)
+                return decoded
+    except Exception:
+        return None
+    return None
+
+
+def _tactile_force_field(
+    path: Path, frame_index: int, side: str,
+) -> tuple[bytes, float, float] | None:
+    """Return one smoothed fz pressure field as float32 bytes.
+
+    The payload is numeric data, not a rendered image.  The frontend applies
+    the color map in WebGL2.  ``lo``/``hi`` preserve the acquisition-side
+    per-frame contrast normalization without sending a rendered image.
+    """
+    import cv2
+    import numpy as np
+
+    try:
+        stat = path.stat()
+        revision = (int(stat.st_size), int(stat.st_mtime_ns))
+    except OSError:
+        revision = (0, 0)
+    if side not in _TACTILE_COLUMNS:
+        return None
+    cache_key = (str(path.resolve()), revision, int(frame_index), side)
+    with _TACTILE_PREVIEW_LOCK:
+        cached = _TACTILE_FIELD_CACHE.get(cache_key)
+        if cached is not None:
+            _TACTILE_FIELD_CACHE.move_to_end(cache_key)
+            return cached
+
+    matrix = _read_tactile_frame(path, frame_index, side)
+    if matrix is None:
+        return None
+    # Match the acquisition-side heatmap exactly: the color field is the
+    # calibrated normal-pressure channel fz.  fx/fy remain available in the
+    # numeric force badge and are intentionally not mixed into this primary
+    # pressure visualization.
+    pressure = np.maximum(matrix[2], 0.0)
+    pressure = cv2.GaussianBlur(pressure, (3, 3), 0.8)
+    valid = pressure[pressure > 0.01]
+    lo = 0.0
+    hi = 1.0
+    if valid.size > 50:
+        lo = float(np.percentile(valid, 10))
+        hi = max(float(np.percentile(valid, 98)) * 1.3, lo + 0.5)
+    field = np.ascontiguousarray(pressure, dtype="<f4")
+    result = (field.tobytes(), lo, hi)
+    with _TACTILE_PREVIEW_LOCK:
+        _TACTILE_FIELD_CACHE[cache_key] = result
+        _TACTILE_FIELD_CACHE.move_to_end(cache_key)
+        while len(_TACTILE_FIELD_CACHE) > _TACTILE_FIELD_CACHE_MAX:
+            _TACTILE_FIELD_CACHE.popitem(last=False)
+    return result
+
+
+_TACTILE_RANGE_CACHE: OrderedDict[tuple, bytes] = OrderedDict()
+_TACTILE_RANGE_CACHE_MAX = 24
+
+
+def _tactile_range_payload(path: Path, first: int, last: int,
+                           side: str) -> bytes | None:
+    """Encode a run of consecutive fz fields as R8 plus per-frame min/max.
+
+    Body layout: ``frames * 250 * 250`` bytes of R8 (one byte per cell, row
+    major) followed by ``frames * 2`` little-endian float32 values holding
+    each frame's ``lo``/``hi`` normalisation pair.  One request per window
+    replaces one 250 KB request per frame, which is what saturated the
+    browser's socket buffers (net::ERR_NO_BUFFER_SPACE) during playback.
+    """
+    import cv2
+    import numpy as np
+    import pyarrow.parquet as pq
+
+    column = _TACTILE_COLUMNS.get(side)
+    if column is None or last <= first:
+        return None
+    try:
+        stat = path.stat()
+        revision = f"{int(stat.st_size):x}-{int(stat.st_mtime_ns):x}"
+    except OSError:
+        revision = "0-0"
+    cache_key = (str(path.resolve()), revision, int(first), int(last), side)
+    with _TACTILE_PREVIEW_LOCK:
+        cached = _TACTILE_RANGE_CACHE.get(cache_key)
+        if cached is not None:
+            _TACTILE_RANGE_CACHE.move_to_end(cache_key)
+            return cached
+    try:
+        table = pq.read_table(
+            path,
+            columns=["frame_index", column],
+            filters=[("frame_index", ">=", int(first)),
+                     ("frame_index", "<", int(last))],
+        )
+    except Exception:
+        return None
+    frames = [int(value) for value in table.column("frame_index").to_pylist()]
+    # Read the list column straight out of the arrow buffers: as_py() would
+    # materialise 187500 Python ints per frame (~100 ms each).
+    import pyarrow as pa
+    column_data = table.column(column)
+    if isinstance(column_data, pa.ChunkedArray):
+        column_data = column_data.combine_chunks()
+    offsets = np.asarray(column_data.offsets, dtype=np.int64)
+    values = np.asarray(column_data.values, dtype=np.int16)
+    rows = {frame: values[offsets[index]:offsets[index + 1]]
+            for index, frame in enumerate(frames)}
+    pixels = _TACTILE_SHAPE[0] * _TACTILE_SHAPE[1]
+    blocks: list[bytes] = []
+    pairs: list[float] = []
+    for frame in range(int(first), int(last)):
+        matrix = _decode_tactile_matrix(rows.get(frame))
+        if matrix is None:
+            blocks.append(bytes(pixels))
+            pairs.extend((0.0, 1.0))
+            continue
+        pressure = np.maximum(matrix[2], 0.0)
+        pressure = cv2.GaussianBlur(pressure, (3, 3), 0.8)
+        valid = pressure[pressure > 0.01]
+        lo = 0.0
+        hi = 1.0
+        if valid.size > 50:
+            lo = float(np.percentile(valid, 10))
+            hi = max(float(np.percentile(valid, 98)) * 1.3, lo + 0.5)
+        scaled = np.clip((pressure - lo) / (hi - lo + 1e-6), 0.0, 1.0)
+        blocks.append(np.rint(scaled * 255.0).astype(np.uint8).tobytes())
+        pairs.extend((lo, hi))
+    payload = b"".join(blocks) + np.asarray(pairs, dtype="<f4").tobytes()
+    with _TACTILE_PREVIEW_LOCK:
+        _TACTILE_RANGE_CACHE[cache_key] = payload
+        _TACTILE_RANGE_CACHE.move_to_end(cache_key)
+        while len(_TACTILE_RANGE_CACHE) > _TACTILE_RANGE_CACHE_MAX:
+            _TACTILE_RANGE_CACHE.popitem(last=False)
+    return payload
+
+
+def _tactile_preview_png(path: Path, frame_index: int, side: str) -> bytes | None:
+    """Render the numeric force field as a legacy WebP preview."""
+    import cv2
+    import numpy as np
+
+    try:
+        stat = path.stat()
+        revision = (int(stat.st_size), int(stat.st_mtime_ns))
+    except OSError:
+        revision = (0, 0)
+    cache_key = (str(path.resolve()), revision, int(frame_index), side)
+    with _TACTILE_PREVIEW_LOCK:
+        cached = _TACTILE_PREVIEW_CACHE.get(cache_key)
+        if cached is not None:
+            _TACTILE_PREVIEW_CACHE.move_to_end(cache_key)
+            return cached
+    field_data = _tactile_force_field(path, frame_index, side)
+    if field_data is None:
+        return None
+    raw, lo, hi = field_data
+    force_magnitude = np.frombuffer(raw, dtype="<f4").reshape(_TACTILE_SHAPE)
+    force_magnitude = np.clip(
+        (force_magnitude - lo) / (hi - lo + 1e-6), 0.0, 1.0
+    )
+    gray = np.uint8(np.round(force_magnitude * 255.0))
+    # Keep the complete 250x250 field visible as a real heatmap.  JET's
+    # lowest value is the cold blue end of the scale, so zero-pressure cells
+    # remain visible instead of turning the preview into a mostly-black image
+    # with a thin coloured line.  This changes only the visualization; the
+    # decoded force matrix and its zero cells are not modified.
+    colored = cv2.applyColorMap(gray, cv2.COLORMAP_JET)
+    _, encoded = cv2.imencode(".webp", colored,
+                              [cv2.IMWRITE_WEBP_QUALITY, 90])
+    result = encoded.tobytes()
+    with _TACTILE_PREVIEW_LOCK:
+        _TACTILE_PREVIEW_CACHE[cache_key] = result
+        _TACTILE_PREVIEW_CACHE.move_to_end(cache_key)
+        while len(_TACTILE_PREVIEW_CACHE) > _TACTILE_PREVIEW_CACHE_MAX:
+            _TACTILE_PREVIEW_CACHE.popitem(last=False)
+    return result
+
+
+@router.get("/{episode_id}/tactile-matrix-data/{frame_index}")
+def get_tactile_matrix_data(
+    episode_id: str,
+    frame_index: int,
+    side: str = Query("left", pattern="^(left|right)$"),
+):
+    """Return one numeric all-component force field for WebGL2 rendering."""
+    if frame_index < 0:
+        raise HTTPException(status_code=400, detail="frame_index must be non-negative")
+    path = _tactile_episode_file(episode_id)
+    if path is None or not _tactile_matrix_columns(path).intersection(_TACTILE_COLUMNS.values()):
+        raise HTTPException(status_code=404, detail="force matrices are unavailable")
+    field = _tactile_force_field(path, frame_index, side)
+    if field is None:
+        raise HTTPException(status_code=404, detail=f"no force matrix at frame {frame_index}")
+    raw, lo, hi = field
+    return Response(
+        content=raw,
+        media_type="application/octet-stream",
+        headers={
+            "Cache-Control": "public, max-age=31536000, immutable",
+            "X-Force-Width": str(_TACTILE_SHAPE[1]),
+            "X-Force-Height": str(_TACTILE_SHAPE[0]),
+            "X-Force-Dtype": "float32-le",
+            "X-Force-Min": repr(lo),
+            "X-Force-Max": repr(hi),
+        },
+    )
+
+
+@router.get("/{episode_id}/tactile-matrix-meta")
+def get_tactile_matrix_meta(episode_id: str):
+    path = _tactile_episode_file(episode_id)
+    columns = _tactile_matrix_columns(path) if path else set()
+    sides = [side for side, column in _TACTILE_COLUMNS.items() if column in columns]
+    ep = get_episode(episode_id)
+    try:
+        stat = path.stat() if path else None
+        revision = f"{int(stat.st_size):x}-{int(stat.st_mtime_ns):x}" if stat else None
+    except OSError:
+        revision = None
+    force_series = _read_tactile_force_series(path) if path else None
+    return {
+        "available": bool(sides),
+        "episode_id": episode_id,
+        "sides": sides,
+        "shape": [250, 250, 3],
+        "units": ["mN", "mN", "mN"],
+        "channel_order": ["fx", "fy", "fz"],
+        "layout": "HWC",
+        "encoding": "row_diff_quantized",
+        "force_order": ["fx", "fy", "fz"],
+        "force_units": "mN",
+        "force_series": force_series,
+        "artifact_revision": revision,
+        "frame_count": int(ep.get("frame_count") or 0) if ep else 0,
+        "fps": float(ep.get("fps") or 30) if ep else 30.0,
+    }
+
+
+@router.get("/{episode_id}/tactile-matrix-range")
+def get_tactile_matrix_range(
+    episode_id: str,
+    side: str = Query("left", pattern="^(left|right)$"),
+    start: int = Query(0, ge=0),
+    end: int = Query(0, ge=0),
+    limit: int = Query(96, ge=1, le=256),
+):
+    """Return a run of consecutive fz fields for one side (R8 + min/max)."""
+    path = _tactile_episode_file(episode_id)
+    if path is None or not _tactile_matrix_columns(path).intersection(
+            _TACTILE_COLUMNS.values()):
+        raise HTTPException(status_code=404, detail="force matrices are unavailable")
+    ep = get_episode(episode_id)
+    total = int(ep.get("frame_count") or 0) if ep else 0
+    first = max(0, int(start))
+    last = int(end) if int(end) > first else first + int(limit)
+    last = min(last, first + int(limit))
+    if total:
+        first = min(first, max(0, total - 1))
+        last = min(last, total)
+    if last <= first:
+        raise HTTPException(status_code=404, detail="empty range")
+    payload = _tactile_range_payload(path, first, last, side)
+    if payload is None:
+        raise HTTPException(status_code=404, detail="no force matrices in range")
+    return Response(
+        content=payload,
+        media_type="application/octet-stream",
+        headers={
+            "Cache-Control": "public, max-age=31536000, immutable",
+            "X-Force-First": str(first),
+            "X-Force-Frames": str(last - first),
+            "X-Force-Width": str(_TACTILE_SHAPE[1]),
+            "X-Force-Height": str(_TACTILE_SHAPE[0]),
+            "X-Force-Encoding": "r8+minmax",
+        },
+    )
+
+
+@router.get("/{episode_id}/tactile-matrix/{frame_index}")
+def get_tactile_matrix_preview(
+    episode_id: str,
+    frame_index: int,
+    side: str = Query("left", pattern="^(left|right)$"),
+):
+    if frame_index < 0:
+        raise HTTPException(status_code=400, detail="frame_index must be non-negative")
+    path = _tactile_episode_file(episode_id)
+    if path is None or not _tactile_matrix_columns(path).intersection(_TACTILE_COLUMNS.values()):
+        raise HTTPException(status_code=404, detail="force matrices are unavailable")
+    image = _tactile_preview_png(path, frame_index, side)
+    if image is None:
+        raise HTTPException(status_code=404, detail=f"no force matrix at frame {frame_index}")
+    return Response(
+        content=image,
+        media_type="image/webp",
+        headers={"Cache-Control": "public, max-age=31536000, immutable"},
+    )
+
+
+@router.get("/{episode_id}/slam-trajectory")
+def get_slam_trajectory(
+    episode_id: str,
+    start_frame: int | None = Query(None, ge=0),
+    end_frame: int | None = Query(None, ge=0),
+    max_points: int = Query(2400, ge=1, le=10000),
+):
+    """Return synchronized SLAM poses and a display-ready 3D trajectory.
+
+    Without a range, long episodes return a decimated trajectory.  With a
+    range, every valid pose in that frame window is returned so the browser
+    can place the current marker exactly without one request per frame.
+    Pose order is ``x,y,z,qx,qy,qz,qw`` and coordinates are metres when the
+    collector follows the UMI SLAM contract.
+    """
+    ep = get_episode(episode_id)
+    if ep is None:
+        return {"available": False, "episode_id": episode_id, "frames": [], "trajectory": []}
+    sdir = Path(ep["path"])
+    files = _canonical_episode_data_files(sdir, episode_id)
+    if not files:
+        return {"available": False, "episode_id": episode_id, "frames": [], "trajectory": []}
+    revision, rows = _read_slam_rows(files[0])
+    frame_count = int(ep.get("frame_count") or 0)
+    if rows:
+        frame_count = max(frame_count, int(rows[-1]["f"]) + 1)
+
+    ranged = start_frame is not None or end_frame is not None
+    if ranged:
+        start = max(0, int(start_frame or 0))
+        end = max(start, int(end_frame if end_frame is not None else start))
+        selected = [row for row in rows if start <= row["f"] <= end]
+        selected = _decimate_slam_rows(selected, max_points)
+        trajectory = selected
+    else:
+        start = 0
+        end = max(0, frame_count - 1)
+        trajectory = _decimate_slam_rows(rows, max_points)
+        # A short episode is returned in full, while long episodes use the
+        # same bounded sample for the initial current-frame lookup.
+        selected = trajectory
+    return {
+        "available": bool(rows),
+        "episode_id": episode_id,
+        "frame_count": frame_count,
+        "fps": float(ep.get("fps") or 30),
+        "unit": "m",
+        "pose_order": ["x", "y", "z", "qx", "qy", "qz", "qw"],
+        "gripper_state_order": ["percent", "gripped", "raw"] if any(
+            row.get("g") is not None for row in rows) else None,
+        "coordinate_frame": "slam_world",
+        "artifact_revision": revision,
+        "valid_frames": len(rows),
+        "start": start,
+        "end": end,
+        "frames": selected,
+        "trajectory": trajectory,
+    }
+
 async def _get_hand_keypoints_data(
     episode_id: str,
     frame_index: int,
@@ -770,7 +1409,9 @@ def get_hand_3d(
     if cacheable_meta:
         from app.media_cache import get_hand3d_meta
         cached = get_hand3d_meta(episode_id)
-        if cached is not None and cached.get("meta_schema_version") == 2:
+        if (cached is not None
+                and cached.get("meta_schema_version") == 2
+                and cached.get("artifact_revision")):
             return cached
 
     # 手部产物只从 canonical episode parquet 读取；渲染视频不再持久化。
@@ -857,7 +1498,7 @@ def get_hand_3d(
     # canonical parquet.  Select the view with the most valid landmarks;
     # ties are stable and prefer the left camera.  The selected view still
     # contains both physical hand slots (hand_0 and hand_1).
-    columns = set(_pd.read_parquet(path, engine="pyarrow").columns)
+    columns = _hand3d_parquet_columns(path)
     source_keys = _hand3d_source_keys(columns)
     source_meta = {
         key: _hand3d_meta(path, key) for key in source_keys
@@ -914,7 +1555,7 @@ def get_hand_3d(
 
     def _read_hand3d_frames():
         """Read whichever canonical or legacy 3D columns this episode has."""
-        available = set(_pd.read_parquet(path, engine="pyarrow").columns)
+        available = _hand3d_parquet_columns(path)
         field_map = _hand3d_column_map(available, active_source)
         wanted = ["frame_index"]
         for hk, side in (("hand_0", "left"), ("hand_1", "right")):
@@ -1181,6 +1822,20 @@ def _hand3d_column_map(columns, source_key: str | None) -> dict[str, str]:
             if not name.startswith("processing.hand_3d.")}
 
 
+def _hand3d_parquet_columns(path: Path) -> set[str]:
+    """Read parquet column names without materializing any row data."""
+    try:
+        import pyarrow.parquet as _pq
+        # ``schema.names`` exposes physical leaf names for nested list columns
+        # (often just ``element``), which hides hand_N_landmarks_3d. Use the
+        # logical Arrow schema so the frame reader sees the real top-level
+        # parquet fields.
+        return set(_pq.ParquetFile(path).schema_arrow.names)
+    except Exception:
+        import pandas as _pd
+        return set(_pd.read_parquet(path, columns=[]).columns)
+
+
 def _hand3d_meta(path: Path, source_key: str | None = None) -> dict:
     """Describe canonical 3D data using the coordinate contract it stores.
 
@@ -1201,20 +1856,27 @@ def _hand3d_meta(path: Path, source_key: str | None = None) -> dict:
     valid_landmark_points = 0
     counted = False  # 计数是否真实执行过(前端据此区分"全空"与"统计失败")
     try:
-        columns = set(_pd.read_parquet(path, engine="pyarrow").columns)
+        # The browser must be able to distinguish two workflow outputs that
+        # happen to have the same episode id/frame count.  Size + mtime is a
+        # cheap revision for the canonical parquet and is stable for the
+        # lifetime of one published artifact.
+        artifact_stat = path.stat()
+        artifact_revision = (
+            f"{int(artifact_stat.st_size):x}-"
+            f"{int(artifact_stat.st_mtime_ns):x}"
+        )
+    except OSError:
+        artifact_revision = "unknown"
+    try:
+        columns = _hand3d_parquet_columns(path)
         field_map = _hand3d_column_map(columns, source_key)
         source_columns = [name for name in field_map.values()
                           if name.endswith("_depth_source")]
         if source_columns:
-            values = []
-            for name in source_columns:
-                values.extend(_pd.read_parquet(
-                    path, columns=[name], engine="pyarrow")[name]
-                    .dropna().astype(str).tolist())
-            is_rgb_estimated = any(
-                "rgb_estimate" in value.lower() or
-                "rgb_estimated" in value.lower()
-                for value in values)
+            # New metric depth artifacts always carry *_depth_source. Avoid
+            # decoding that entire object column during the click-time meta
+            # request; the source namespace is enough to classify the preview.
+            is_rgb_estimated = False
         else:
             is_rgb_estimated = any(
                 name.endswith("hand_left_3d") or
@@ -1231,10 +1893,15 @@ def _hand3d_meta(path: Path, source_key: str | None = None) -> dict:
         # metadata for the review UI; it never changes the stored data.
         # 采样统计:均匀散布读 1/3 的 row group(NAS 上全量读这些列
         # 实测 ~20s),计数按采样率放大保持量级;采样失败回退全量读。
-        count_raw = [field_map.get(name) for name in (
+        present_raw = [field_map.get(name) for name in (
             "hand_0_present", "hand_1_present",
+        ) if field_map.get(name)]
+        landmark_raw = [field_map.get(name) for name in (
             "hand_0_landmarks_3d", "hand_1_landmarks_3d",
         ) if field_map.get(name)]
+        # Presence booleans are enough for source selection and are much
+        # cheaper than decoding nested 21x3 landmark arrays over SSHFS.
+        count_raw = present_raw or landmark_raw
 
         def _count_rows(rows_iter) -> None:
             nonlocal valid_hand_frames, valid_landmark_points
@@ -1246,6 +1913,10 @@ def _hand3d_meta(path: Path, source_key: str | None = None) -> dict:
                     present = count_row.get(present_name) if present_name else True
                     points = count_row.get(points_name) if points_name else None
                     if present is False or points is None:
+                        if (points is None and present is not None
+                                and bool(present)):
+                            valid_landmark_points += 21
+                            row_has_hand = True
                         continue
                     try:
                         arr = _np.asarray(points, dtype=_np.float64)
@@ -1311,6 +1982,7 @@ def _hand3d_meta(path: Path, source_key: str | None = None) -> dict:
         "valid_hand_frames": int(valid_hand_frames),
         "valid_landmark_points": int(valid_landmark_points),
         "counted": bool(counted),
+        "artifact_revision": artifact_revision,
         "meta_schema_version": 2,
     }
 def _parse_range(range_header: str, file_size: int) -> tuple[int, int]:

processor/app/workflow_dispatch.py

@@ -36,6 +36,7 @@ _CAMERA_INPUTS = {
     "mono_camera", "rgbd_camera", "fisheye_camera", "rgb_camera",
     "stereo_camera", "stereo_rgbd_camera",
 }
+_COMPOSITE_INPUTS = {"gripper_device"}
 
 
 def project_workflow_ids(project: dict | None) -> list[str]:
@@ -100,10 +101,10 @@ def _node_source_groups(workflow: dict, bindings: dict | None) -> tuple[list[str
             continue
         data = node.get("data") or {}
         node_type = str(data.get("nodeType") or "")
-        if node_type not in _CAMERA_INPUTS and node_type != "glove_sensor":
+        if node_type not in _CAMERA_INPUTS | _COMPOSITE_INPUTS and node_type != "glove_sensor":
             continue
         values = _config_source_keys(data.get("config") or {})
-        target = sensor_keys if node_type == "glove_sensor" else camera_keys
+        target = sensor_keys if node_type in {"glove_sensor", "gripper_device"} else camera_keys
         target.extend(values)
     return camera_keys, sensor_keys
 
@@ -144,7 +145,8 @@ def _episode_input_groups(episode: dict) -> list[dict]:
     """Build physical input groups from the uploaded episode metadata.
 
     A group is the matching unit: one RGB stream, one Stereo pair, one RGB-D
-    device, or one Stereo RGB-D device with an RGB pair plus depth metadata.
+    device, one UMI gripper, or one Stereo RGB-D device with an RGB pair plus
+    depth metadata.
     The real source
     keys are kept for the worker snapshot, while ``input_type`` is the stable
     workflow contract.
@@ -282,10 +284,11 @@ def _workflow_input_specs(workflow: dict, bindings: dict | None) -> list[dict]:
             continue
         data = node.get("data") or {}
         node_type = str(data.get("nodeType") or "")
-        if node_type not in _CAMERA_INPUTS and node_type != "glove_sensor":
+        if node_type not in _CAMERA_INPUTS | _COMPOSITE_INPUTS and node_type != "glove_sensor":
             continue
         semantic = (
             "glove_sensor" if node_type == "glove_sensor"
+            else "gripper_device" if node_type == "gripper_device"
             else "stereo_rgbd_camera" if node_type == "stereo_rgbd_camera"
             else "rgbd_camera" if node_type == "rgbd_camera"
             else "stereo_rgb" if node_type == "stereo_camera"
@@ -348,7 +351,7 @@ def _auto_bindings_for_episode(workflow: dict, episode: dict,
             continue
         auto[spec["node_id"]] = (
             {"source_keys": ",".join(keys)}
-            if len(keys) > 1 or spec["semantic_type"] == "glove_sensor"
+            if len(keys) > 1 or spec["semantic_type"] in {"glove_sensor", "gripper_device"}
             else {"source_key": keys[0]}
         )
         matched.add(spec["node_id"])
@@ -363,7 +366,7 @@ def _clear_unmatched_input_configs(graph: dict, matched: set[str]) -> None:
         node_id = str(node.get("id") or "")
         data = node.get("data") or {}
         node_type = str(data.get("nodeType") or "")
-        if node_id in matched or (node_type not in _CAMERA_INPUTS and node_type != "glove_sensor"):
+        if node_id in matched or (node_type not in _CAMERA_INPUTS | _COMPOSITE_INPUTS and node_type != "glove_sensor"):
             continue
         config = data.get("config")
         if not isinstance(config, dict):

processor/app/workflow_instantiate.py

@@ -39,7 +39,7 @@ from app.workflow_types import HAND_PROCESS_TYPES, migrate_graph_types
 # increment-instance de-duplication.
 INPUT_MODULES = {
     "mono_camera", "rgbd_camera", "rgb_camera", "fisheye_camera",
-    "stereo_camera", "stereo_rgbd_camera", "glove_sensor",
+    "stereo_camera", "stereo_rgbd_camera", "glove_sensor", "gripper_device",
 }
 VIDEO_PROCESS_TYPES = {
     "mediapipe_hand", *HAND_PROCESS_TYPES,
@@ -273,7 +273,22 @@ def complete_graph(graph: dict, camera_names: list[str], sensors: list[str]) ->
         key for module, key in covered
         if module in {"stereo_camera", "stereo_rgbd_camera"}
     }
-    for group in _camera_groups(mains):
+    # UMI publishes a primary RGB stream and internal left/right streams. They
+    # belong to one physical source node, not three camera inputs.
+    gripper_mains = [
+        c for c in mains
+        if "gripper" in str(c).lower() or "umi" in str(c).lower()
+    ]
+    camera_mains = [c for c in mains if c not in gripper_mains]
+    covered_gripper = any(
+        module == "gripper_device" and key in {
+            value.lower() for value in gripper_mains
+        }
+        for module, key in covered
+    )
+    if gripper_mains and not covered_gripper:
+        video_groups.append(("gripper_device", gripper_mains))
+    for group in _camera_groups(camera_mains):
         mod = "stereo_camera" if len(group) > 1 else _camera_module(group[0])
         if mod in {"stereo_camera", "stereo_rgbd_camera"}:
             # A complete existing pair is already covered. An unpaired
@@ -340,7 +355,9 @@ def complete_graph(graph: dict, camera_names: list[str], sensors: list[str]) ->
 
     # ── 5. 视频输入节点:连接模板中的视频处理节点 ──
     for mod, keys in video_groups:
-        if mod in {"stereo_camera", "stereo_rgbd_camera"}:
+        if mod == "gripper_device":
+            handles = ["rgb_video"]
+        elif mod in {"stereo_camera", "stereo_rgbd_camera"}:
             handles = ["video_left"] if len(keys) < 2 else ["video_left", "video_right"]
         else:
             handles = ["video"]
@@ -484,7 +501,7 @@ def batch_covers_instance(instance: dict, camera_names: list[str]) -> bool:
     }
     for n in graph.get("nodes", []):
         data = n.get("data") or {}
-        if data.get("category") != "input" or data.get("nodeType") == "glove_sensor":
+        if data.get("category") != "input" or data.get("nodeType") in {"glove_sensor", "gripper_device"}:
             continue
         keys = [str(k).lower() for k in _keys_of(data.get("config") or {})]
         if not keys:

processor/app/workflow_types.py

@@ -89,6 +89,17 @@ def _migrate_hand_ports(node_type: str, data: dict[str, Any]) -> bool:
         if outputs != old_outputs:
             data["outputs"] = outputs
             changed = True
+    if node_type == "gripper_device":
+        old_outputs = data.get("outputs") or []
+        outputs = [
+            _port("rgb_video", "RGB Video"),
+            _port("gripper_state", "ESP Gripper State"),
+            _port("slam_trajectory", "SLAM Trajectory"),
+            _port("tactile_force_matrices", "Left and Right Force Matrices"),
+        ]
+        if outputs != old_outputs:
+            data["outputs"] = outputs
+            changed = True
     if node_type in RGB_2D_TYPES:
         old_outputs = data.get("outputs") or []
         # The public contract is intentionally one output. Multi-view files
@@ -176,6 +187,15 @@ def migrate_graph_types(graph: dict | None) -> tuple[dict, bool]:
             )
             changed = True
             continue
+        if source_type == "gripper_device" and handle in {"tactile_left", "tactile_right"}:
+            edge["sourceHandle"] = "tactile_force_matrices"
+            edge["id"] = (
+                f"xy-edge__{edge.get('source') or ''}"
+                f"{edge.get('sourceHandle') or ''}-"
+                f"{edge.get('target') or ''}{edge.get('targetHandle') or ''}"
+            )
+            changed = True
+            continue
         if source_type not in RGB_2D_TYPES:
             continue
         if handle == "hand_3d" or handle.startswith("hand_3d#"):
@@ -205,6 +225,30 @@ def migrate_graph_types(graph: dict | None) -> tuple[dict, bool]:
             )
             changed = True
 
+    # Merging the two tactile ports can make two historical edges identical
+    # when both sides were connected to the same downstream input.
+    unique_edges: list[dict[str, Any]] = []
+    seen_gripper_edges: set[tuple[str, str, str, str]] = set()
+    for edge in result.get("edges") or []:
+        if not isinstance(edge, dict):
+            unique_edges.append(edge)
+            continue
+        if (node_types.get(str(edge.get("source") or "")) == "gripper_device"
+                and edge.get("sourceHandle") == "tactile_force_matrices"):
+            key = (
+                str(edge.get("source") or ""),
+                str(edge.get("sourceHandle") or ""),
+                str(edge.get("target") or ""),
+                str(edge.get("targetHandle") or ""),
+            )
+            if key in seen_gripper_edges:
+                changed = True
+                continue
+            seen_gripper_edges.add(key)
+        unique_edges.append(edge)
+    if len(unique_edges) != len(result.get("edges") or []):
+        result["edges"] = unique_edges
+
     # If an old workflow already used an RGB-D input card, complete its new
     # typed depth edge. Do not invent a depth source for old mono cards: those
     # remain executable through the processing module's legacy auto-pair path.

processor/scripts/ensure_stack_linux.sh

@@ -57,12 +57,15 @@ while :; do
         continue
     fi
 
-    ensure_unit_started egodata-backend.service
+    # The active installation uses the processor-local API/worker units.
+    # The old egodata-backend/egodata-workers units point at the pre-split
+    # Data Acquisition directory and must not be started after boot.
+    ensure_unit_started egodata-api.service
 
     # Workers must only be started after the API has confirmed both the
     # PostgreSQL tunnel and the remote storage are usable.
     if backend_ready; then
-        ensure_unit_started egodata-workers.service
+        ensure_unit_started egodata-worker.service
     fi
 
     sleep "${sleep_until_ready}"

processor/tests/test_gripper_device.py

@@ -0,0 +1,109 @@
+import json
+import tempfile
+import unittest
+from pathlib import Path
+
+import pyarrow as pa
+import pyarrow.parquet as pq
+
+from app.processing import JobContext
+from app.processing.modules.gripper_device import GripperDeviceModule
+from app.workflow_dispatch import _episode_input_groups
+from app.workflow_types import migrate_graph_types
+
+
+class GripperDeviceModuleTests(unittest.TestCase):
+    def _context(self, root: Path) -> JobContext:
+        return JobContext(
+            node_id="gripper",
+            node_type="gripper_device",
+            config={"source_key": "gripper_rgb"},
+            job={},
+            input_root=root,
+            output_root=root / "outputs",
+            incoming={},
+            progress=lambda _value: None,
+            node_states={},
+        )
+
+    def test_publishes_one_composite_device_with_paired_force_output(self):
+        with tempfile.TemporaryDirectory() as temp:
+            root = Path(temp)
+            (root / "meta").mkdir()
+            (root / "videos" / "observation.images.gripper_rgb" / "chunk-000").mkdir(parents=True)
+            (root / "videos" / "observation.images.gripper_rgb" / "chunk-000" / "episode_000000.mp4").touch()
+            (root / "meta" / "info.json").write_text(json.dumps({
+                "devices": [{
+                    "key": "gripper:test",
+                    "kind": "gripper",
+                    "name": "UMI Gripper",
+                    "slots": ["gripper_rgb", "gripper_force_left", "gripper_force_right"],
+                }],
+            }), encoding="utf-8")
+            (root / "data" / "chunk-000").mkdir(parents=True)
+            pq.write_table(pa.table({
+                "observation.gripper_state": [[0.5, 1.0, 0.0]],
+                "observation.slam_pose": [[0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0]],
+                "observation.gripper_left_force_matrix": [list(range(3))],
+                "observation.gripper_right_force_matrix": [list(range(3))],
+            }), root / "data" / "chunk-000" / "episode_000000.parquet")
+
+            outputs = GripperDeviceModule().run(self._context(root))
+
+            self.assertEqual(set(outputs), {
+                "rgb_video", "gripper_state", "slam_trajectory",
+                "tactile_force_matrices",
+            })
+            self.assertEqual(outputs["slam_trajectory"].metadata["names"],
+                             ["x", "y", "z", "qx", "qy", "qz", "qw"])
+            self.assertEqual(outputs["tactile_force_matrices"].metadata["columns"], [
+                "observation.gripper_left_force_matrix",
+                "observation.gripper_right_force_matrix",
+            ])
+            self.assertEqual(outputs["tactile_force_matrices"].metadata["shape"],
+                             [2, 250, 250, 3])
+
+    def test_dispatch_groups_gripper_stream_as_one_device(self):
+        episode = {
+            "camera_names": ["gripper_rgb", "gripper_stereo_left", "gripper_stereo_right"],
+            "device_names": {
+                "gripper_rgb": "UMI Gripper",
+                "gripper_stereo_left": "UMI Gripper",
+                "gripper_stereo_right": "UMI Gripper",
+            },
+            "devices": [],
+            "sensors": [],
+        }
+        groups = _episode_input_groups(episode)
+        self.assertEqual([group["input_type"] for group in groups], ["gripper_device"])
+        self.assertEqual(groups[0]["source_keys"], [
+            "gripper_rgb", "gripper_stereo_left", "gripper_stereo_right",
+        ])
+
+    def test_migrates_old_force_ports_to_one_connection(self):
+        graph, changed = migrate_graph_types({
+            "nodes": [{
+                "id": "gripper", "data": {
+                    "nodeType": "gripper_device",
+                    "outputs": [
+                        {"key": "tactile_left", "label": "Left Force Matrix"},
+                        {"key": "tactile_right", "label": "Right Force Matrix"},
+                    ],
+                },
+            }, {"id": "target", "data": {"nodeType": "annotation"}}],
+            "edges": [
+                {"id": "left", "source": "gripper", "sourceHandle": "tactile_left",
+                 "target": "target", "targetHandle": "data"},
+                {"id": "right", "source": "gripper", "sourceHandle": "tactile_right",
+                 "target": "target", "targetHandle": "data"},
+            ],
+        })
+        self.assertTrue(changed)
+        self.assertEqual(graph["nodes"][0]["data"]["outputs"][-1]["key"],
+                         "tactile_force_matrices")
+        self.assertEqual(len(graph["edges"]), 1)
+        self.assertEqual(graph["edges"][0]["sourceHandle"], "tactile_force_matrices")
+
+
+if __name__ == "__main__":
+    unittest.main()

processor/tests/test_project_dataset.py

@@ -0,0 +1,93 @@
+from pathlib import Path
+
+import pyarrow as pa
+import pyarrow.parquet as pq
+
+from app.project_dataset import (
+    _merge_info,
+    allocate_project_episode_id,
+    write_project_episode_index,
+)
+
+
+def _write_frame_data(root: Path) -> None:
+    path = root / "data" / "chunk-000" / "episode_000000.parquet"
+    path.parent.mkdir(parents=True, exist_ok=True)
+    pq.write_table(pa.table({
+        "episode_index": pa.array([0]),
+        "frame_index": pa.array([0]),
+        "observation.slam_pose": pa.array([[0.0] * 7]),
+        "observation.gripper_left_force": pa.array([[1.0, 2.0, 3.0]]),
+    }), path)
+
+
+def test_new_episode_id_does_not_reuse_malformed_existing_id(tmp_path: Path):
+    write_project_episode_index(tmp_path, [{
+        "episode_index": 0,
+        "episode_id": "Uncategorized_000001",
+        "length": 10,
+    }])
+
+    assert allocate_project_episode_id(
+        tmp_path, "Test9_4", "Uncategorized",
+    ) == "Uncategorized_000002"
+
+
+def test_empty_project_starts_at_episode_zero(tmp_path: Path):
+    assert allocate_project_episode_id(
+        tmp_path, "new_upload", "UMI夹爪项目",
+    ) == "UMI夹爪项目_000000"
+
+
+def test_info_is_filtered_to_real_files_and_columns(tmp_path: Path):
+    _write_frame_data(tmp_path)
+    video = (tmp_path / "videos" / "observation.images.gripper_rgb"
+             / "chunk-000" / "episode_000000.mp4")
+    video.parent.mkdir(parents=True, exist_ok=True)
+    video.write_bytes(b"placeholder")
+
+    stale_info = {
+        "task_name": "Test9/4",
+        "features": {
+            "observation.slam_pose": {"dtype": "float32", "shape": [7]},
+            "observation.gripper_left_force": {
+                "dtype": "float32", "shape": [3],
+            },
+            "observation.images.gripper_rgb": {"dtype": "video"},
+            "observation.images.D435_rgb": {"dtype": "video"},
+            "observation.imu": {"dtype": "float32", "shape": [6]},
+        },
+        "devices": [
+            {"key": "d435", "name": "D435", "slots": ["D435_rgb"]},
+            {"key": "gripper", "name": "UMI", "slots": [
+                "gripper_rgb", "gripper_pose", "gripper_force_left",
+            ]},
+        ],
+        "device_names": {
+            "D435_rgb": "D435",
+            "gripper_rgb": "UMI",
+            "gripper_pose": "UMI",
+            "gripper_force_left": "UMI",
+        },
+        "cameras": {
+            "D435_rgb": {"width": 1280},
+            "gripper_rgb": {"width": 1280},
+        },
+        "sensors": ["right_glove"],
+    }
+    merged = _merge_info(tmp_path, stale_info, [{
+        "episode_index": 0,
+        "length": 1,
+    }], [{"task_index": 0, "task": "Test9/4"}])
+
+    assert set(merged["features"]) == {
+        "observation.slam_pose",
+        "observation.gripper_left_force",
+        "observation.images.gripper_rgb",
+    }
+    assert merged["cameras"] == {"gripper_rgb": {"width": 1280}}
+    assert [d["key"] for d in merged["devices"]] == ["gripper"]
+    assert merged["features"]["observation.slam_pose"]["quaternion_order"] == "xyzw"
+    assert merged["features"]["observation.gripper_left_force"]["names"] == [
+        "fx", "fy", "fz",
+    ]

processor/tests/test_tactile_decode.py

@@ -0,0 +1,27 @@
+import unittest
+
+import numpy as np
+
+from app.routes.video import _decode_tactile_matrix
+
+
+class TactileDecodeTests(unittest.TestCase):
+    def test_interleaved_row_diff_is_decoded_before_hwc_reshape(self):
+        matrix = np.zeros((250, 250, 3), dtype=np.int16)
+        matrix[12, 34] = [7, -2, 19]
+        matrix[12, 35] = [8, -1, 23]
+        matrix[200, 249] = [-11, 3, 31]
+
+        rows = matrix.reshape(250, 750)
+        diff = np.empty_like(rows)
+        diff[:, 0] = rows[:, 0]
+        diff[:, 1:] = rows[:, 1:] - rows[:, :-1]
+
+        decoded = _decode_tactile_matrix(diff.reshape(-1).tolist())
+
+        self.assertEqual(decoded.shape, (3, 250, 250))
+        np.testing.assert_array_equal(decoded.transpose(1, 2, 0), matrix)
+
+
+if __name__ == "__main__":
+    unittest.main()

processor/web/static/js/hand-overlay.js

@@ -257,6 +257,24 @@
         overlays.set(key, state);
         updateMenuStatus();
 
+        // The keypoint request and video metadata arrive independently. If
+        // keypoints win the race, _render() sees videoWidth === 0 and exits;
+        // without a later metadata event the overlay only appears after the
+        // central clock advances a few frames. Re-render on the first usable
+        // video layout while keeping the exact current frame.
+        const video = holder.querySelector('video');
+        const renderWhenVideoReady = () => {
+            if (overlays.get(key) !== state || state.status !== 'ready') return;
+            _render(state);
+        };
+        state.video = video;
+        state.renderWhenVideoReady = renderWhenVideoReady;
+        if (video) {
+            ['loadedmetadata', 'loadeddata', 'canplay', 'playing', 'resize']
+                .forEach(eventName => video.addEventListener(
+                    eventName, renderWhenVideoReady));
+        }
+
         // 首帧探测:数据存在性 + 第一窗口
         const initialReady = (async () => {
             const count = Number(source.frame_count) || 0;
@@ -290,6 +308,11 @@
         const st = overlays.get(key);
         if (!st) return;
         overlays.delete(key);
+        if (st.video && st.renderWhenVideoReady) {
+            ['loadedmetadata', 'loadeddata', 'canplay', 'playing', 'resize']
+                .forEach(eventName => st.video.removeEventListener(
+                    eventName, st.renderWhenVideoReady));
+        }
         st.svg.remove();
         updateMenuStatus();
     }

processor/web/static/js/player.js

@@ -1,5 +1,5 @@
 /* Plyr video player management */
-console.log('[player.js] build 202609030900-sync-barrier-central-clock');
+console.log('[player.js] build 202609091912-tactile-chunk-prefetch');
 
 const players = {};  // {camera_name: Plyr instance}
 let currentEpisodeId = null;
@@ -58,6 +58,8 @@ function _cancelEpisodeMediaLoad(clearCanvas = true) {
     currentImageTiles = [];
     currentDepthPreviewTiles = [];
     currentHand3dTiles = [];
+    currentSlamTiles = [];
+    currentTactileTiles = [];
     workspaceGrid = null;
     workspaceMainRow = null;
     workspaceHandFooter = null;
@@ -172,6 +174,15 @@ let hand3dFrameCacheBySource = {};
 let _hand3dTileEntry = null;    // 3D tile 引用,懒加载回调重绘用
 let currentHand3dTiles = [];    // 画布中的 3D 骨骼 tile {canvas, source, rotX, rotY, ...}
 let currentDepthPreviewTiles = []; // raw uint16 depth codes + frontend Canvas
+let currentTactileTiles = [];   // 左右力矩阵合并预览,按统一帧号刷新
+let slamData = null;             // /slam-trajectory response for current episode
+let slamFramesByIndex = {};
+let slamWindowInflight = null;
+let currentSlamTiles = [];        // 画布中的 SLAM 轨迹 tile
+let tactileMatrixData = null;    // /tactile-matrix-meta response
+const SLAM_DISPLAY_SMOOTH_ALPHA = 0.35;
+const SLAM_DISPLAY_JOIN_GAP_FRAMES = 3;
+const SLAM_DISPLAY_CAMERA_DISTANCE_SCALE = 1.55;
 const _depthLittleEndian = new Uint8Array(new Uint16Array([1]).buffer)[0] === 1;
 // Keep one recently-used complete raw-code buffer across episode clicks. The
 // decoded D435 stream is large, so bound this cache to one typical episode;
@@ -258,6 +269,74 @@ const DEPTH_FULL_PRELOAD = true;
 // the strict all-windows preload barrier instead.
 const DEPTH_FULL_PRELOAD_MAX_FRAMES = 2000;
 
+// Complete browser-side video blobs make arbitrary progress-bar seeks local
+// and keep the rendered depth preview on the same seek timeline as RGB.
+const _browserVideoAssetCache = new Map();
+const BROWSER_VIDEO_ASSET_CACHE_MAX = 4;
+
+function _browserVideoAssetUrl(source, fallbackUrl) {
+    const url = String(fallbackUrl || '');
+    if (!url) return '';
+    const revision = source && (
+        source.depth_cache_key || source.video_cache_key || source.cache_key);
+    if (!revision || /(?:^|[?&])v=/.test(url)) return url;
+    return `${url}${url.includes('?') ? '&' : '?'}v=${encodeURIComponent(revision)}`;
+}
+
+async function _preloadBrowserVideoAsset(source, fallbackUrl, sessionToken) {
+    const episodeAtRequest = currentEpisodeId;
+    const tokenAtRequest = sessionToken == null
+        ? _playbackSessionToken : sessionToken;
+    const isActive = () => isCurrentPlaybackSession(
+        episodeAtRequest, tokenAtRequest);
+    if (!isActive()) return null;
+    const url = _browserVideoAssetUrl(source, fallbackUrl);
+    if (!url) return null;
+    const key = `${episodeAtRequest}:${source?.kind || 'video'}:` +
+        `${source?.source_key || ''}:${url}`;
+    const existing = _browserVideoAssetCache.get(key);
+    if (existing?.url) return existing.url;
+    if (existing?.promise) return existing.promise;
+
+    const promise = (async () => {
+        try {
+            const response = await fetch(url, {
+                cache: 'force-cache',
+                signal: getMediaLoadSignal() || undefined,
+            });
+            if (!response.ok) throw new Error(`video preload failed: ${response.status}`);
+            const blob = await response.blob();
+            if (!isActive()) return null;
+            const objectUrl = URL.createObjectURL(blob);
+            _browserVideoAssetCache.set(key, {
+                url: objectUrl, bytes: blob.size, ready: true,
+            });
+            while (_browserVideoAssetCache.size > BROWSER_VIDEO_ASSET_CACHE_MAX) {
+                const oldestKey = _browserVideoAssetCache.keys().next().value;
+                const oldest = _browserVideoAssetCache.get(oldestKey);
+                if (oldest?.url) URL.revokeObjectURL(oldest.url);
+                _browserVideoAssetCache.delete(oldestKey);
+            }
+            return objectUrl;
+        } catch (error) {
+            if (isActive()) {
+                console.warn('[player] complete video preload failed; fallback to range stream', error);
+            }
+            return null;
+        } finally {
+            const state = _browserVideoAssetCache.get(key);
+            if (state?.promise) {
+                if (state.url) _browserVideoAssetCache.set(key, {
+                    url: state.url, bytes: state.bytes, ready: true,
+                });
+                else _browserVideoAssetCache.delete(key);
+            }
+        }
+    })();
+    _browserVideoAssetCache.set(key, { promise });
+    return promise;
+}
+
 let _depthPlaybackStall = null;
 
 function _depthFrameReady(frame) {
@@ -756,6 +835,11 @@ window.invalidateEpisodePlaybackCache = function (episodeId) {
     for (const key of _hand3dFullCache.keys()) {
         if (key.startsWith(prefix)) _hand3dFullCache.delete(key);
     }
+    if (currentEpisodeId === episodeId) {
+        slamData = null;
+        slamFramesByIndex = {};
+        slamWindowInflight = null;
+    }
     if (window.EgoMediaCache && episodeId) {
         window.EgoMediaCache.removeEpisode(episodeId).catch(() => {});
     }
@@ -817,55 +901,88 @@ function _hand3dCached(frame, sourceKey) {
     return fr ? { h0: fr.h0 || null, h1: fr.h1 || null } : null;
 }
 
-function _hand3dFullCacheKey(sourceKey) {
-    return `${currentEpisodeId || ''}:${sourceKey || 'default'}`;
+function _hand3dArtifactRevision(sourceKey) {
+    const source = sourceKey || 'default';
+    const data = hand3dDataBySource[source] || hand3dData;
+    return String(data && data.artifact_revision || 'unknown');
+}
+
+function _hand3dFullCacheKey(sourceKey, artifactRevision = null) {
+    const revision = artifactRevision == null
+        ? _hand3dArtifactRevision(sourceKey) : String(artifactRevision);
+    return `${currentEpisodeId || ''}:${sourceKey || 'default'}:${revision}`;
 }
 
-function _restoreHand3DFull(cache, sourceKey) {
-    const saved = _hand3dFullCache.get(_hand3dFullCacheKey(sourceKey));
-    if (!saved || !saved.frames) return false;
+function _restoreHand3DFull(cache, sourceKey, artifactRevision) {
+    const saved = _hand3dFullCache.get(
+        _hand3dFullCacheKey(sourceKey, artifactRevision));
+    if (!saved || !saved.frames
+            || String(saved.artifactRevision || 'unknown') !== String(artifactRevision)) {
+        return false;
+    }
     cache.frames = saved.frames;
     cache.start = 0;
     cache.end = Math.max(0, Number(saved.count || 0) - 1);
     cache.fullReady = true;
+    cache.fullArtifactRevision = String(artifactRevision);
     return true;
 }
 
-function _rememberHand3DFull(cache, sourceKey, count) {
-    const key = _hand3dFullCacheKey(sourceKey);
+function _rememberHand3DFull(cache, sourceKey, count, artifactRevision) {
+    const key = _hand3dFullCacheKey(sourceKey, artifactRevision);
     _hand3dFullCache.delete(key);
-    _hand3dFullCache.set(key, { frames: cache.frames, count });
+    _hand3dFullCache.set(key, {
+        frames: cache.frames, count,
+        artifactRevision: String(artifactRevision),
+    });
     while (_hand3dFullCache.size > HAND3D_FULL_CACHE_MAX_EPISODES) {
         _hand3dFullCache.delete(_hand3dFullCache.keys().next().value);
     }
 }
 
-async function fetchHand3DFull(sourceKey) {
+async function fetchHand3DFull(sourceKey, sessionToken = _playbackSessionToken) {
     const source = sourceKey || 'default';
+    const episodeAtRequest = currentEpisodeId;
+    const tokenAtRequest = sessionToken;
+    const isActive = () => isCurrentPlaybackSession(
+        episodeAtRequest, tokenAtRequest);
+    if (!isActive()) return false;
     const cache = _hand3dCacheFor(source);
-    if (cache.fullReady) return true;
-    if (_restoreHand3DFull(cache, source)) return true;
-    if (cache.fullInflight) return cache.fullInflight;
     const data = hand3dDataBySource[source] || hand3dData;
+    const artifactRevision = String(
+        data && data.artifact_revision || 'unknown');
+    if (cache.fullReady
+            && String(cache.fullArtifactRevision || 'unknown')
+                === artifactRevision) {
+        return true;
+    }
+    if (cache.fullReady) cache.fullReady = false;
+    if (_restoreHand3DFull(cache, source, artifactRevision)) return true;
+    if (cache.fullInflight) return cache.fullInflight;
     const count = Number(data && data.count || 0);
     if (!count || count > HAND3D_FULL_PRELOAD_MAX_FRAMES) return false;
-    const episodeAtRequest = currentEpisodeId;
     const signal = getMediaLoadSignal();
-    const persistentKey = `${episodeAtRequest}:hand3d:${source}:${count}`;
+    const persistentKey = `${episodeAtRequest}:hand3d:${source}:${count}:${artifactRevision}`;
     cache.fullInflight = (async () => {
         try {
             if (window.EgoMediaCache) {
                 const saved = await window.EgoMediaCache.get(persistentKey);
+                if (!isActive()) return false;
                 const value = saved && saved.value;
                 if (value && Array.isArray(value.frames)
-                        && Number(value.count || 0) === count) {
+                        && Number(value.count || 0) === count
+                        && String(value.artifact_revision || 'unknown')
+                            === artifactRevision) {
                     const frames = {};
                     value.frames.forEach(fr => { frames[fr.f] = fr; });
+                    if (!isActive()) return false;
                     cache.frames = frames;
                     cache.start = 0;
                     cache.end = Math.max(0, count - 1);
                     cache.fullReady = true;
-                    _rememberHand3DFull(cache, source, count);
+                    cache.fullArtifactRevision = artifactRevision;
+                    _rememberHand3DFull(
+                        cache, source, count, artifactRevision);
                     return true;
                 }
             }
@@ -873,19 +990,26 @@ async function fetchHand3DFull(sourceKey) {
                 `/api/v1/video/${episodeAtRequest}/hand-3d?source_key=`
                 + `${encodeURIComponent(source)}&start_frame=0&end_frame=${count - 1}`,
                 signal ? { signal } : {});
-            if (!res.ok || currentEpisodeId !== episodeAtRequest) return false;
+            if (!res.ok || !isActive()) return false;
             const payload = await res.json();
-            if (currentEpisodeId !== episodeAtRequest) return false;
+            if (!isActive()) return false;
+            if (String(payload && payload.artifact_revision || 'unknown')
+                    !== artifactRevision) return false;
             const frames = {};
             (payload.frames || []).forEach(fr => { frames[fr.f] = fr; });
+            if (!isActive()) return false;
             cache.frames = frames;
             cache.start = 0;
             cache.end = Math.max(0, count - 1);
             cache.fullReady = true;
-            _rememberHand3DFull(cache, source, count);
-            if (window.EgoMediaCache) {
+            cache.fullArtifactRevision = artifactRevision;
+            _rememberHand3DFull(
+                cache, source, count, artifactRevision);
+            if (window.EgoMediaCache && isActive()) {
                 window.EgoMediaCache.put(persistentKey, {
-                    frames: payload.frames || [], count,
+                    frames: payload.frames || [],
+                    count,
+                    artifact_revision: artifactRevision,
                 });
             }
             return true;
@@ -1048,12 +1172,16 @@ function groupedSourceLabel(source) {
     if (source.kind === 'skeleton') return `${source.label || source.source_key} · ${t('skeleton_suffix')}`;
     if (source.kind === 'glove') return source.label || `${source.source_key} · ${t('glove_suffix')}`;
     if (source.kind === 'depth') return source.label || `${source.source_key} · ${t('depth_suffix')}`;
+    if (source.kind === 'slam_trajectory') return source.label || 'SLAM';
+    if (source.kind === 'tactile_force_left') return 'Left';
+    if (source.kind === 'tactile_force_right') return 'Right';
     if (source.kind === 'stereo_group') return `${source.label} · ${t('stereo_pair')}`;
     return source.label || source.source_key || t('video_suffix');
 }
 
 function _isBottomSource(source) {
-    return ['hand', 'depth', 'glove'].includes(source.kind);
+    return ['hand', 'depth', 'glove', 'tactile_force_left',
+        'tactile_force_right'].includes(source.kind);
 }
 
 function groupedSource(kind, source_key, meta) {
@@ -1065,7 +1193,8 @@ function expandWorkspaceItems(source) {
     if (source.kind === 'stereo_group') {
         return (source.members || []).map(m => ({
             kind: 'video', source_key: m.source_key, label: m.label,
-            stream_url: m.stream_url, frame_count: m.frame_count, fps: m.fps,
+            stream_url: m.stream_url, video_cache_key: m.video_cache_key,
+            frame_count: m.frame_count, fps: m.fps,
         }));
     }
     return [{ ...source }];
@@ -1167,6 +1296,10 @@ function removeGroupedSource(source) {
         groupedSourceKey(entry.source) !== key);
     currentDepthPreviewTiles = currentDepthPreviewTiles.filter(entry =>
         groupedSourceKey(entry.source) !== key);
+    currentSlamTiles = currentSlamTiles.filter(entry =>
+        groupedSourceKey(entry.source) !== key);
+    currentTactileTiles = currentTactileTiles.filter(entry =>
+        groupedSourceKey(entry.source) !== key);
     workspaceSources = workspaceSources.filter(item => groupedSourceKey(item) !== key);
     renderSourceBar();
     renderPreviewVideoSources();
@@ -1374,6 +1507,7 @@ function _serializeSource(source) {
         depth_codes_url: source.depth_codes_url,
         raw_depth_url: source.raw_depth_url,
         depth_cache_key: source.depth_cache_key,
+        video_cache_key: source.video_cache_key,
         // Optional grayscale clock stream; never used as depth pixels.
         depth_video_url: source.depth_video_url,
         missing_frames: source.missing_frames,
@@ -1389,9 +1523,479 @@ function _frameUrl(urlTemplate, frameIndex) {
     return urlTemplate.replace('{frame}', Math.max(0, frameIndex));
 }
 
+function _tactileForceAt(frame, side) {
+    const map = tactileMatrixData?._forceByFrame;
+    const value = map && map[String(Math.max(0, Number(frame) || 0))]?.[side];
+    if (!Array.isArray(value) || value.length < 3
+            || !value.slice(0, 3).every(item => Number.isFinite(Number(item)))) {
+        return null;
+    }
+    const fx = Number(value[0]);
+    const fy = Number(value[1]);
+    const fz = Number(value[2]);
+    return { fx, fy, fz, magnitude: Math.hypot(fx, fy, fz) };
+}
+
+function _updateTactileForceTile(entry, frame) {
+    if (!entry) return;
+    const force = _tactileForceAt(frame, entry.source.side);
+    if (entry.forceValue) {
+        if (!force) {
+            entry.forceValue.textContent = 'Fx — · Fy — · Fz —';
+            entry.forceValue.title = 'Force data unavailable';
+        } else {
+            entry.forceValue.textContent =
+                `Fx ${Math.round(force.fx).toLocaleString()} · `
+                + `Fy ${Math.round(force.fy).toLocaleString()} · `
+                + `Fz ${Math.round(force.fz).toLocaleString()}`;
+            entry.forceValue.title =
+                `fx ${force.fx.toFixed(1)} · fy ${force.fy.toFixed(1)} · `
+                + `fz ${force.fz.toFixed(1)} mN`;
+        }
+    }
+    _renderTactileForceCurve(entry, frame);
+}
+
+// Fx/Fy/Fz history for one side across the whole episode, with a playhead at
+// the current frame. Colours follow the acquisition-side ForceCurveWidget.
+const TACTILE_FORCE_COLORS = ['#4fc3f7', '#aed581', '#ff8a65'];
+
+function _forceSeriesIndex(frame) {
+    const series = tactileMatrixData?.force_series;
+    if (!series || !Array.isArray(series.frames)) return null;
+    if (!tactileMatrixData._frameIndex) {
+        const map = new Map();
+        series.frames.forEach((value, index) => map.set(Number(value), index));
+        tactileMatrixData._frameIndex = map;
+    }
+    const index = tactileMatrixData._frameIndex.get(Math.round(Number(frame)));
+    return index === undefined ? null : index;
+}
+
+function _renderTactileForceCurve(entry, frame) {
+    const canvas = entry?.curveCanvas;
+    if (!canvas) return;
+    const rect = canvas.getBoundingClientRect();
+    const width = Math.max(1, rect.width), height = Math.max(1, rect.height);
+    if (rect.width < 2 || rect.height < 2) {
+        // The tile is built before it is attached to the workspace, so the
+        // first call can run before layout. Retry once the layout exists.
+        if (!entry._curveRetry) {
+            entry._curveRetry = true;
+            requestAnimationFrame(() => {
+                entry._curveRetry = false;
+                _renderTactileForceCurve(entry, frame);
+            });
+        }
+        return;
+    }
+    const dpr = window.devicePixelRatio || 1;
+    if (canvas.width !== Math.round(width * dpr)
+            || canvas.height !== Math.round(height * dpr)) {
+        canvas.width = Math.round(width * dpr);
+        canvas.height = Math.round(height * dpr);
+    }
+    const ctx = canvas.getContext('2d');
+    ctx.setTransform(dpr, 0, 0, dpr, 0, 0);
+    ctx.clearRect(0, 0, width, height);
+
+    const series = tactileMatrixData?.force_series?.[entry.source.side];
+    if (!Array.isArray(series) || !series.length) return;
+
+    const pad = { l: 4, r: 4, t: 8, b: 4 };
+    const innerW = width - pad.l - pad.r;
+    const innerH = height - pad.t - pad.b;
+    // Symmetric auto range: p99.5 of |value| rounded up to 500 mN, so the
+    // fixed +/-3000 mN range of the acquisition widget does not clip our data.
+    if (!entry._curveRange) {
+        const samples = [];
+        series.forEach(value => {
+            if (!value) return;
+            for (let axis = 0; axis < 3; axis++) {
+                const item = Math.abs(Number(value[axis]));
+                if (Number.isFinite(item)) samples.push(item);
+            }
+        });
+        samples.sort((a, b) => a - b);
+        const p995 = samples.length
+            ? samples[Math.min(samples.length - 1, Math.floor(samples.length * 0.995))]
+            : 0;
+        entry._curveRange = Math.max(500, Math.ceil(p995 / 500) * 500);
+    }
+    const range = entry._curveRange;
+    const mid = pad.t + innerH / 2;
+    const Y = value => mid - (value / range) * (innerH / 2) * 0.92;
+    const X = index => pad.l + (series.length <= 1
+        ? 0 : (index / (series.length - 1)) * innerW);
+
+    ctx.lineWidth = 1;
+    ctx.strokeStyle = 'rgba(148,163,184,0.16)';
+    [0.5, -0.5].forEach(frac => {
+        const y = Y(frac * range);
+        ctx.beginPath(); ctx.moveTo(pad.l, y); ctx.lineTo(width - pad.r, y); ctx.stroke();
+    });
+    ctx.strokeStyle = 'rgba(148,163,184,0.38)';
+    ctx.beginPath();
+    ctx.moveTo(pad.l, mid); ctx.lineTo(width - pad.r, mid);
+    ctx.stroke();
+
+    for (let axis = 0; axis < 3; axis++) {
+        ctx.strokeStyle = TACTILE_FORCE_COLORS[axis];
+        ctx.lineWidth = 1.2;
+        ctx.beginPath();
+        let started = false;
+        series.forEach((value, index) => {
+            const item = value ? Number(value[axis]) : NaN;
+            if (!Number.isFinite(item)) { started = false; return; }
+            const x = X(index), y = Y(item);
+            if (!started) { ctx.moveTo(x, y); started = true; }
+            else { ctx.lineTo(x, y); }
+        });
+        ctx.stroke();
+    }
+
+    const headIndex = _forceSeriesIndex(frame);
+    if (headIndex !== null) {
+        const head = X(headIndex);
+        ctx.strokeStyle = 'rgba(248,250,252,0.85)';
+        ctx.lineWidth = 1;
+        ctx.beginPath();
+        ctx.moveTo(head, pad.t - 3); ctx.lineTo(head, height - pad.b);
+        ctx.stroke();
+    }
+}
+
+function _createTactileWebGLRenderer(canvas) {
+    const gl = canvas.getContext('webgl2', {
+        alpha: false, antialias: false, premultipliedAlpha: false,
+    });
+    if (!gl) return null;
+    const vertexSource = `#version 300 es
+        in vec2 a_position;
+        out vec2 v_uv;
+        void main() {
+            v_uv = a_position * 0.5 + 0.5;
+            gl_Position = vec4(a_position, 0.0, 1.0);
+        }`;
+    const fragmentSource = `#version 300 es
+        precision highp float;
+        uniform sampler2D u_force_field;
+        uniform float u_zoom;
+        uniform vec2 u_pan;
+        in vec2 v_uv;
+        out vec4 out_color;
+        vec3 jet(float x) {
+            return clamp(vec3(
+                1.5 - abs(4.0 * x - 3.0),
+                1.5 - abs(4.0 * x - 2.0),
+                1.5 - abs(4.0 * x - 1.0)
+            ), 0.0, 1.0);
+        }
+        void main() {
+            // Zoom/pan happen in screen-uv space; the field itself is 250x250.
+            vec2 uv = (v_uv - 0.5) / u_zoom + 0.5 + u_pan;
+            if (uv.x < 0.0 || uv.x > 1.0 || uv.y < 0.0 || uv.y > 1.0) {
+                out_color = vec4(0.0039, 0.0039, 0.502, 1.0);
+                return;
+            }
+            // Matrix row 0 is the top of the sensor; WebGL texture v=0 is
+            // the bottom, so flip only the sampling coordinate. The field is
+            // uploaded already normalised to 0..1 (R8), so no rescaling here.
+            float value = texture(u_force_field, vec2(uv.x, 1.0 - uv.y)).r;
+            out_color = vec4(jet(clamp(value, 0.0, 1.0)), 1.0);
+        }`;
+    const compile = (type, source) => {
+        const shader = gl.createShader(type);
+        gl.shaderSource(shader, source);
+        gl.compileShader(shader);
+        if (!gl.getShaderParameter(shader, gl.COMPILE_STATUS)) {
+            console.warn('[player] tactile WebGL shader failed',
+                gl.getShaderInfoLog(shader));
+            gl.deleteShader(shader);
+            return null;
+        }
+        return shader;
+    };
+    const vertex = compile(gl.VERTEX_SHADER, vertexSource);
+    const fragment = compile(gl.FRAGMENT_SHADER, fragmentSource);
+    if (!vertex || !fragment) return null;
+    const program = gl.createProgram();
+    gl.attachShader(program, vertex);
+    gl.attachShader(program, fragment);
+    gl.linkProgram(program);
+    gl.deleteShader(vertex);
+    gl.deleteShader(fragment);
+    if (!gl.getProgramParameter(program, gl.LINK_STATUS)) {
+        console.warn('[player] tactile WebGL program failed',
+            gl.getProgramInfoLog(program));
+        gl.deleteProgram(program);
+        return null;
+    }
+    const position = gl.createBuffer();
+    gl.bindBuffer(gl.ARRAY_BUFFER, position);
+    gl.bufferData(gl.ARRAY_BUFFER, new Float32Array([
+        -1, -1, 1, -1, -1, 1, 1, 1,
+    ]), gl.STATIC_DRAW);
+    const texture = gl.createTexture();
+    gl.bindTexture(gl.TEXTURE_2D, texture);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
+    return {
+        gl, program, position, texture,
+        positionLocation: gl.getAttribLocation(program, 'a_position'),
+        fieldLocation: gl.getUniformLocation(program, 'u_force_field'),
+        zoomLocation: gl.getUniformLocation(program, 'u_zoom'),
+        panLocation: gl.getUniformLocation(program, 'u_pan'),
+        field: null,
+        zoom: 1, pan: [0, 0], filter: null,
+        render(field = null, min = 0, max = 1) {
+            if (field) {
+                // R32F float textures are not filterable without
+                // OES_texture_float_linear; without it every sample returns 0
+                // and the whole tile renders as JET(0) - a flat dark blue that
+                // is indistinguishable from the background. Normalising to
+                // 8-bit here keeps the texture in the always-filterable R8
+                // format, so LINEAR/NEAREST both work on every driver.
+                if (field instanceof Float32Array) {
+                    const lo = Number.isFinite(Number(min)) ? Number(min) : 0;
+                    const hi = Number.isFinite(Number(max)) ? Number(max) : 1;
+                    const span = Math.max(hi - lo, 1e-6);
+                    const bytes = new Uint8Array(field.length);
+                    for (let i = 0; i < field.length; i++) {
+                        const value = (field[i] - lo) / span;
+                        bytes[i] = value <= 0 ? 0
+                            : value >= 1 ? 255 : Math.round(value * 255);
+                    }
+                    this.field = bytes;
+                } else {
+                    this.field = field;
+                }
+            }
+            const rect = canvas.getBoundingClientRect();
+            const dpr = window.devicePixelRatio || 1;
+            const width = Math.max(1, Math.round(rect.width * dpr));
+            const height = Math.max(1, Math.round(rect.height * dpr));
+            if (canvas.width !== width || canvas.height !== height) {
+                canvas.width = width;
+                canvas.height = height;
+            }
+            gl.viewport(0, 0, width, height);
+            gl.clearColor(0.0039, 0.0039, 0.502, 1.0);
+            gl.clear(gl.COLOR_BUFFER_BIT);
+            if (!this.field) return;
+            gl.useProgram(program);
+            gl.bindBuffer(gl.ARRAY_BUFFER, position);
+            gl.enableVertexAttribArray(this.positionLocation);
+            gl.vertexAttribPointer(this.positionLocation, 2, gl.FLOAT, false, 0, 0);
+            gl.activeTexture(gl.TEXTURE0);
+            gl.bindTexture(gl.TEXTURE_2D, texture);
+            // One texel is one sensor cell. Sample NEAREST as soon as a cell
+            // covers at least one screen pixel (crisp cells, like the
+            // acquisition demo), and LINEAR only when shrinking - a NEAREST
+            // minification would drop isolated contact cells entirely.
+            const texelsPerPixel = (width / 250) * (this.zoom || 1);
+            const filter = texelsPerPixel >= 1 ? gl.NEAREST : gl.LINEAR;
+            if (this.filter !== filter) {
+                gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, filter);
+                gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, filter);
+                this.filter = filter;
+            }
+            gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, false);
+            gl.pixelStorei(gl.UNPACK_ALIGNMENT, 1);   // 250-wide R8 rows
+            gl.texImage2D(gl.TEXTURE_2D, 0, gl.R8, 250, 250, 0,
+                gl.RED, gl.UNSIGNED_BYTE, this.field);
+            gl.uniform1i(this.fieldLocation, 0);
+            gl.uniform1f(this.zoomLocation, this.zoom || 1);
+            gl.uniform2f(this.panLocation,
+                this.pan ? this.pan[0] : 0, this.pan ? this.pan[1] : 0);
+            gl.drawArrays(gl.TRIANGLE_STRIP, 0, 4);
+        },
+    };
+}
+
+// Wheel zoom / drag pan / double-click reset for one tactile matrix tile.
+// One texture texel is one sensor cell, so zooming in reveals the individual
+// contact cells that the whole-field view averages away (same interaction as
+// the acquisition-side demo viewer).
+function _tactileScreenUv(canvas, clientX, clientY) {
+    const rect = canvas.getBoundingClientRect();
+    return [
+        (clientX - rect.left) / Math.max(1, rect.width),
+        1 - (clientY - rect.top) / Math.max(1, rect.height),
+    ];
+}
+
+function _clampTactileView(renderer) {
+    const limit = Math.max(0, (1 - 1 / renderer.zoom) / 2);
+    renderer.pan[0] = Math.max(-limit, Math.min(limit, renderer.pan[0]));
+    renderer.pan[1] = Math.max(-limit, Math.min(limit, renderer.pan[1]));
+}
+
+function initTactileView(entry) {
+    const canvas = entry?.canvas;
+    const renderer = entry?.renderer;
+    if (!canvas || !renderer) return;
+    const maxZoom = 12;
+    canvas.addEventListener('wheel', event => {
+        event.preventDefault();
+        const [u, v] = _tactileScreenUv(canvas, event.clientX, event.clientY);
+        const before = 1 / renderer.zoom;
+        renderer.zoom = Math.max(1, Math.min(maxZoom,
+            renderer.zoom * (event.deltaY < 0 ? 1.2 : 1 / 1.2)));
+        const delta = before - 1 / renderer.zoom;
+        renderer.pan[0] += (u - 0.5) * delta;
+        renderer.pan[1] += (v - 0.5) * delta;
+        _clampTactileView(renderer);
+        canvas.style.cursor = renderer.zoom > 1 ? 'grab' : 'default';
+        renderer.render();
+    }, { passive: false });
+    canvas.addEventListener('pointerdown', event => {
+        if (event.button !== 0 || renderer.zoom <= 1) return;
+        entry._panDrag = { x: event.clientX, y: event.clientY };
+        canvas.style.cursor = 'grabbing';
+        if (canvas.setPointerCapture) canvas.setPointerCapture(event.pointerId);
+        event.preventDefault();
+    });
+    canvas.addEventListener('pointermove', event => {
+        if (!entry._panDrag) return;
+        const rect = canvas.getBoundingClientRect();
+        renderer.pan[0] -= (event.clientX - entry._panDrag.x)
+            / Math.max(1, rect.width) / renderer.zoom;
+        renderer.pan[1] += (event.clientY - entry._panDrag.y)
+            / Math.max(1, rect.height) / renderer.zoom;
+        entry._panDrag = { x: event.clientX, y: event.clientY };
+        _clampTactileView(renderer);
+        renderer.render();
+    });
+    const endPan = event => {
+        if (!entry._panDrag) return;
+        entry._panDrag = null;
+        canvas.style.cursor = renderer.zoom > 1 ? 'grab' : 'default';
+        if (event && canvas.hasPointerCapture
+                && canvas.hasPointerCapture(event.pointerId)) {
+            canvas.releasePointerCapture(event.pointerId);
+        }
+    };
+    canvas.addEventListener('pointerup', endPan);
+    canvas.addEventListener('pointercancel', endPan);
+    canvas.addEventListener('dblclick', () => {
+        renderer.zoom = 1;
+        renderer.pan = [0, 0];
+        canvas.style.cursor = 'default';
+        renderer.render();
+    });
+}
+
+// One chunk = 96 frames of 250x250 R8 = 6 MB per request. The old code issued
+// one 250 KB request per frame per side (15 MB/s during playback), which
+// saturated the browser's socket buffers (net::ERR_NO_BUFFER_SPACE). Chunks
+// are cached in memory, so playback and scrubbing need no network at all.
+const TACTILE_CHUNK_FRAMES = 96;
+const TACTILE_FIELD_STRIDE = 250 * 250;
+
+function _tactileChunkKey(frame) {
+    return Math.floor(Math.max(0, frame) / TACTILE_CHUNK_FRAMES)
+        * TACTILE_CHUNK_FRAMES;
+}
+
+function _tactileFrameField(entry, frame) {
+    const chunk = entry.chunks.get(_tactileChunkKey(frame));
+    if (!chunk) return null;
+    const index = Math.round(Number(frame)) - chunk.first;
+    if (index < 0 || index >= chunk.count) return null;
+    return chunk.bytes.subarray(
+        index * TACTILE_FIELD_STRIDE, (index + 1) * TACTILE_FIELD_STRIDE);
+}
+
+function _fetchTactileChunk(entry, chunkStart) {
+    if (!entry?.renderer || entry.chunks.has(chunkStart)
+            || entry.chunkInflight.has(chunkStart)) return;
+    entry.chunkInflight.add(chunkStart);
+    const episodeAtRequest = currentEpisodeId;
+    const tokenAtRequest = _playbackSessionToken;
+    const signal = getMediaLoadSignal();
+    const url = `/api/v1/video/${currentEpisodeId}/tactile-matrix-range`
+        + `?side=${entry.source.side}&start=${chunkStart}`
+        + `&limit=${TACTILE_CHUNK_FRAMES}&v=202609091912-tactile-chunk-prefetch`;
+    const options = { credentials: 'same-origin', cache: 'force-cache' };
+    if (signal) options.signal = signal;
+    fetch(url, options).then(response => {
+        if (!response.ok) throw new Error(`tactile range failed: ${response.status}`);
+        const first = Number(response.headers.get('X-Force-First'));
+        const count = Number(response.headers.get('X-Force-Frames'));
+        return response.arrayBuffer().then(buffer => ({ buffer, first, count }));
+    }).then(({ buffer, first, count }) => {
+        entry.chunkInflight.delete(chunkStart);
+        if (!isCurrentPlaybackSession(episodeAtRequest, tokenAtRequest)
+                || !entry.canvas.isConnected) return;
+        if (!Number.isFinite(first) || !Number.isFinite(count) || count <= 0
+                || buffer.byteLength < count * TACTILE_FIELD_STRIDE) return;
+        entry.chunks.set(chunkStart, {
+            first, count,
+            bytes: new Uint8Array(buffer, 0, count * TACTILE_FIELD_STRIDE),
+        });
+        // Paint the frame the player is showing if it just arrived.
+        if (entry.pendingFrame !== null && entry.pendingFrame !== undefined) {
+            const field = _tactileFrameField(entry, entry.pendingFrame);
+            if (field) {
+                entry.renderer.render(field);
+                entry.loadedFrame = entry.pendingFrame;
+            }
+        }
+        // Keep one chunk of look-ahead warm so playback never waits on the
+        // network; the server caches each chunk, so repeats are cheap.
+        const next = chunkStart + TACTILE_CHUNK_FRAMES;
+        if (!entry.frameCount || next < entry.frameCount) {
+            _fetchTactileChunk(entry, next);
+        }
+    }).catch(error => {
+        entry.chunkInflight.delete(chunkStart);
+        if (error?.name !== 'AbortError'
+                && isCurrentPlaybackSession(episodeAtRequest, tokenAtRequest)) {
+            console.warn('[player] tactile chunk unavailable', error);
+        }
+    });
+}
+
+function _loadTactileWebGLFrame(entry, frame) {
+    if (!entry?.canvas || !entry.renderer || !entry.source) return;
+    const targetFrame = Math.max(0, Math.round(Number(frame) || 0));
+    entry.pendingFrame = targetFrame;
+    const field = _tactileFrameField(entry, targetFrame);
+    if (field) {
+        entry.renderer.render(field);
+        entry.loadedFrame = targetFrame;
+        const next = _tactileChunkKey(targetFrame) + TACTILE_CHUNK_FRAMES;
+        if (!entry.frameCount || next < entry.frameCount) {
+            _fetchTactileChunk(entry, next);
+        }
+        return;
+    }
+    _fetchTactileChunk(entry, _tactileChunkKey(targetFrame));
+}
+
 async function mountGroupedSource(source, tile) {
     const episodeAtMount = currentEpisodeId;
+    const sessionTokenAtMount = _playbackSessionToken;
     if (!tile || currentEpisodeId !== episodeAtMount) return;
+    if (source.kind === 'slam_trajectory') {
+        const canvas = document.createElement('canvas');
+        canvas.className = 'w-full h-full block bg-black';
+        tile.appendChild(canvas);
+        const entry = {
+            canvas, source, rotY: 0, rotX: 0.35, zoom: 1,
+            pan: [0, 0, 0], dragging: false, dragMode: '',
+            lastX: 0, lastY: 0, fit: null, _lastCam: null,
+        };
+        currentSlamTiles.push(entry);
+        initSlamDrag(entry);
+        if (!isCurrentPlaybackSession(episodeAtMount, sessionTokenAtMount)
+                || !tile.isConnected) return;
+        renderSlamTile(entry, 0);
+        return;
+    }
     if (source.kind === 'hand3d_world') {
         // 3D 手部世界坐标交互窗口:canvas 渲染 /hand-3d 逐帧数据
         // (worker 只产 parquet,前端实时投影;拖拽旋转 + 滚轮缩放)
@@ -1407,21 +2011,82 @@ async function mountGroupedSource(source, tile) {
         // Do not reveal the spatial canvas before its initial frame window is
         // available. RGB/2D and 3D then enter the workspace together.
         await _ensureHand3DInitialWindow(source.source_key || 'default');
-        if (currentEpisodeId !== episodeAtMount || !tile.isConnected) return;
+        if (!isCurrentPlaybackSession(episodeAtMount, sessionTokenAtMount)
+                || !tile.isConnected) return;
         renderHand3DTile(entry, 0);
         return;
     }
+    if (source.kind === 'tactile_force_left'
+            || source.kind === 'tactile_force_right') {
+        // One tile per side: pressure field on top, its Fx/Fy/Fz history
+        // underneath. The acquisition-side GripperSideWidget stacks the same
+        // way (heatmap above, force curve below).
+        const holder = document.createElement('div');
+        holder.className = 'w-full h-full min-h-0 flex flex-col';
+        const matrixBox = document.createElement('div');
+        matrixBox.className = 'relative flex-1 min-h-0';
+        matrixBox.style.backgroundColor = 'rgb(1, 1, 128)';
+        const canvas = document.createElement('canvas');
+        canvas.className = 'w-full h-full block';
+        canvas.setAttribute('aria-label',
+            source.side === 'right' ? 'Right force matrix' : 'Left force matrix');
+        matrixBox.appendChild(canvas);
+        const forceValue = document.createElement('div');
+        forceValue.className = 'absolute z-10 rounded text-white pointer-events-none';
+        forceValue.style.cssText = 'top:6px;left:6px;padding:2px 6px;font-size:11px;'
+            + 'background:rgba(0,0,0,.6);font-variant-numeric:tabular-nums;';
+        forceValue.textContent = 'Fx — · Fy — · Fz —';
+        matrixBox.appendChild(forceValue);
+        const curveBox = document.createElement('div');
+        curveBox.className = 'relative shrink-0';
+        curveBox.style.cssText = 'height:92px;background:#0b1220;'
+            + 'border-top:1px solid rgba(51,65,85,.5);';
+        const curveCanvas = document.createElement('canvas');
+        curveCanvas.className = 'w-full h-full block';
+        curveBox.appendChild(curveCanvas);
+        const curveCaption = document.createElement('div');
+        curveCaption.className = 'absolute pointer-events-none';
+        curveCaption.style.cssText = 'top:2px;left:6px;font-size:10px;color:#64748b;';
+        curveCaption.textContent = '力 mN';
+        curveBox.appendChild(curveCaption);
+        holder.appendChild(matrixBox);
+        holder.appendChild(curveBox);
+        tile.appendChild(holder);
+        const renderer = _createTactileWebGLRenderer(canvas);
+        const entry = { canvas, renderer, source, lastFrame: -1, forceValue,
+            curveCanvas, loadedFrame: -1, pendingFrame: null,
+            chunks: new Map(), chunkInflight: new Set(),
+            frameCount: Number(tactileMatrixData?.frame_count) || 0 };
+        initTactileView(entry);
+        canvas.title = '滚轮缩放 / 拖拽平移 / 双击复位';
+        currentTactileTiles.push(entry);
+        const frame = typeof currentFrameTarget === 'number' ? currentFrameTarget : 0;
+        _updateTactileForceTile(entry, frame);
+        if (renderer) {
+            renderer.render();
+            _loadTactileWebGLFrame(entry, frame);
+        } else {
+            forceValue.textContent = 'WebGL2 unavailable';
+        }
+        return;
+    }
     if (source.kind === 'depth' && source.depth_video_url) {
         // Depth previews are browser-decodable 8-bit Turbo MP4s generated
         // once per source from the canonical 12-bit stream (identical
         // clamp/scale/colormap math as the former canvas renderer).  Play
         // them as native videos: instant open, native seek, and frame sync
         // through the same master-drift loop as every other camera.
+        const playbackUrl = await _preloadBrowserVideoAsset(
+            source, source.depth_video_url, sessionTokenAtMount);
+        if (!isCurrentPlaybackSession(episodeAtMount, sessionTokenAtMount)
+                || !tile.isConnected) return;
         const holder = document.createElement('div');
         holder.id = `player-container-${groupedSourceDomId(source)}`;
         holder.className = 'bg-black rounded overflow-hidden w-full h-full min-h-0 relative';
         tile.appendChild(holder);
-        const player = initPlayer(holder.id, source.depth_video_url);
+        const player = initPlayer(
+            holder.id, playbackUrl || _browserVideoAssetUrl(
+                source, source.depth_video_url));
         if (player) players[groupedSourceKey(source)] = player;
         return;
     }
@@ -1465,10 +2130,13 @@ async function mountGroupedSource(source, tile) {
     holder.id = `player-container-${groupedSourceDomId(source)}`;
     holder.className = 'bg-black rounded overflow-hidden w-full h-full min-h-0';
     tile.appendChild(holder);
-    const url = source.stream_url ||
+    const sourceUrl = source.stream_url ||
         await pickVideoUrl(episodeAtMount, source.source_key);
-    if (currentEpisodeId !== episodeAtMount || !tile.isConnected) return;
-    const player = initPlayer(holder.id, url);
+    const playbackUrl = await _preloadBrowserVideoAsset(
+        source, sourceUrl, sessionTokenAtMount);
+    if (!isCurrentPlaybackSession(episodeAtMount, sessionTokenAtMount)
+            || !tile.isConnected) return;
+    const player = initPlayer(holder.id, playbackUrl || sourceUrl);
     if (player) players[groupedSourceKey(source)] = player;
     // 手部骨骼 SVG 叠加层(只加在原始视频上;skeleton/渲染 tile 不加)
     // The first keypoint window is part of the shared initial-frame barrier.
@@ -1490,12 +2158,12 @@ function bindGloveSync(player) {
 
 let _lastImageTileFrame = -1;
 function _refreshImageTilesAt(frame) {
-    if (!currentImageTiles.length && !currentDepthPreviewTiles.length) return;
+    if (!currentImageTiles.length && !currentDepthPreviewTiles.length
+            && !currentTactileTiles.length) return;
     _refreshDepthTilesAt(frame);
-    if (!currentImageTiles.length) return;
-    if (frame === _lastImageTileFrame) return;
-    _lastImageTileFrame = frame;
-    currentImageTiles.forEach((entry) => {
+    if (currentImageTiles.length && frame !== _lastImageTileFrame) {
+        _lastImageTileFrame = frame;
+        currentImageTiles.forEach((entry) => {
         const { img, source } = entry;
         // Hand/glove tiles are driven by heatmap.js from the preloaded
         // frames-data payload; only template-based non-depth tiles are
@@ -1508,6 +2176,13 @@ function _refreshImageTilesAt(frame) {
             url = source.heatmap_url || source.depth_preview_url || source.depth_url;
         }
         if (url) img.src = _frameUrl(url, frame);
+        });
+    }
+    currentTactileTiles.forEach(entry => {
+        if (!entry.canvas || entry.lastFrame === frame) return;
+        entry.lastFrame = frame;
+        _updateTactileForceTile(entry, frame);
+        _loadTactileWebGLFrame(entry, frame);
     });
 }
 
@@ -1668,21 +2343,25 @@ function _createWorkspaceTile(source, movable, reorderContainer) {
         tile.style.alignSelf = 'center';
     }
 
-    const label = document.createElement('span');
-    label.className = 'absolute z-10 top-1 left-1 bg-black/70 text-gray-200 text-[10px] px-1.5 py-0.5 rounded';
-    label.textContent = groupedSourceLabel(source);
-    tile.appendChild(label);
+    if (!source.kind.startsWith('tactile_force_')) {
+        const label = document.createElement('span');
+        label.className = 'absolute z-10 top-1 left-1 bg-black/70 text-gray-200 text-[10px] px-1.5 py-0.5 rounded';
+        label.textContent = groupedSourceLabel(source);
+        tile.appendChild(label);
+    }
 
-    const remove = document.createElement('button');
-    remove.type = 'button';
-    remove.className = 'absolute z-10 top-1 right-1 bg-black/70 text-gray-300 hover:text-white text-xs w-5 h-5 rounded';
-    remove.textContent = '\u00d7';
-    remove.title = t('remove_source');
-    remove.onclick = event => {
-        event.stopPropagation();
-        removeGroupedSource(source);
-    };
-    tile.appendChild(remove);
+    if (!source.kind.startsWith('tactile_force_')) {
+        const remove = document.createElement('button');
+        remove.type = 'button';
+        remove.className = 'absolute z-10 top-1 right-1 bg-black/70 text-gray-300 hover:text-white text-xs w-5 h-5 rounded';
+        remove.textContent = '\u00d7';
+        remove.title = t('remove_source');
+        remove.onclick = event => {
+            event.stopPropagation();
+            removeGroupedSource(source);
+        };
+        tile.appendChild(remove);
+    }
 
     if (!movable) return tile;
 
@@ -2042,7 +2721,8 @@ function renderGroupedWorkspaceLegacy() {
     // Two fixed zones: a video area on top (free drag-to-reorder) and a
     // heatmap area below (left-hand on the left column, right-hand on the
     // right column — always, per requirement).
-    const isImageSource = s => ['glove', 'depth', 'hand'].includes(s.kind);
+    const isImageSource = s => ['glove', 'depth', 'hand',
+        'tactile_force_left', 'tactile_force_right'].includes(s.kind);
     const vids = workspaceSources.filter(s => !isImageSource(s));
     const imgs = workspaceSources.filter(s => isImageSource(s));
 
@@ -2086,17 +2766,21 @@ function renderGroupedWorkspaceLegacy() {
         tile.style.minWidth = '0';
         tile.style.width = '100%';
         tile.style.height = '100%';
-        const label = document.createElement('span');
-        label.className = 'absolute z-10 top-1 left-1 bg-black/70 text-gray-200 text-[10px] px-1.5 py-0.5 rounded';
-        label.textContent = groupedSourceLabel(source);
-        tile.appendChild(label);
-        const remove = document.createElement('button');
-        remove.type = 'button';
-        remove.className = 'absolute z-10 top-1 right-1 bg-black/70 text-gray-300 hover:text-white text-xs w-5 h-5 rounded';
-        remove.textContent = '×';
-        remove.title = t('remove_source');
-        remove.onclick = () => removeGroupedSource(source);
-        tile.appendChild(remove);
+        if (!source.kind.startsWith('tactile_force_')) {
+            const label = document.createElement('span');
+            label.className = 'absolute z-10 top-1 left-1 bg-black/70 text-gray-200 text-[10px] px-1.5 py-0.5 rounded';
+            label.textContent = groupedSourceLabel(source);
+            tile.appendChild(label);
+        }
+        if (!source.kind.startsWith('tactile_force_')) {
+            const remove = document.createElement('button');
+            remove.type = 'button';
+            remove.className = 'absolute z-10 top-1 right-1 bg-black/70 text-gray-300 hover:text-white text-xs w-5 h-5 rounded';
+            remove.textContent = '×';
+            remove.title = t('remove_source');
+            remove.onclick = () => removeGroupedSource(source);
+            tile.appendChild(remove);
+        }
         if (inVideoRow) {
             // Drag to reorder videos (DOM-level swap — playback keeps running)
             tile.draggable = true;
@@ -2197,7 +2881,9 @@ function _defaultWorkspaceFromGroups() {
     // 并已把 hand3d_world 加入 workspaceSources,整表重建不能冲掉
     // (否则开关显示开启、窗口实际不存在 —— 竞态脱节 bug)
     const keep = workspaceSources.filter(s =>
-        s.kind === 'hand3d_world' || s.kind === 'depth');
+        s.kind === 'hand3d_world' || s.kind === 'slam_trajectory'
+        || s.kind === 'depth' || s.kind === 'tactile_force_left'
+        || s.kind === 'tactile_force_right');
     // Depth is a first-class default preview source. It must be present in
     // workspaceSources before renderGroupedWorkspace takes its mount Promise
     // snapshot; adding it immediately after render creates a race where the
@@ -2213,7 +2899,8 @@ function _defaultWorkspaceFromGroups() {
     if (grp && (grp.members || []).length) {
         workspaceSources = grp.members.map(m => ({
             kind: 'video', source_key: m.source_key, label: m.label,
-            stream_url: m.stream_url, frame_count: m.frame_count, fps: m.fps,
+            stream_url: m.stream_url, video_cache_key: m.video_cache_key,
+            frame_count: m.frame_count, fps: m.fps,
         }));
         workspaceSources.push(...retained);
         return;
@@ -2222,7 +2909,8 @@ function _defaultWorkspaceFromGroups() {
     if (singles.length) {
         workspaceSources = singles.map(single => ({
             kind: 'video', source_key: single.source_key, label: single.label,
-            stream_url: single.stream_url, frame_count: single.frame_count, fps: single.fps,
+            stream_url: single.stream_url, video_cache_key: single.video_cache_key,
+            frame_count: single.frame_count, fps: single.fps,
         }));
     }
     workspaceSources.push(...retained);
@@ -2248,12 +2936,18 @@ async function loadGroupedEpisodeVideo(episodeId, cameras, options = {}) {
     currentImageTiles = [];
     currentDepthPreviewTiles = [];
     currentHand3dTiles = [];
+    currentSlamTiles = [];
+    currentTactileTiles = [];
     hand3dData = null;
     hand3dDataBySource = {};
     hand3dFrameCache = { frame: -1, data: null, inflight: -1 };
     hand3dFrameCacheBySource = {};
     hand3dWindow = { start: -1, end: -1, frames: {}, inflight: false };
     hand3dWindowBySource = {};
+    slamData = null;
+    slamFramesByIndex = {};
+    slamWindowInflight = null;
+    tactileMatrixData = null;
     _depthPlaybackStall = null;
     _hand3dViewAnchor = null;
     _h3dBaseDist = null;
@@ -2316,6 +3010,8 @@ async function loadGroupedEpisodeVideo(episodeId, cameras, options = {}) {
     // building the workspace. The 3D tile itself then awaits its first data
     // window together with each RGB overlay's first keypoint window.
     const hand3dReady = loadHand3D(episodeId, loadToken);
+    const slamReady = loadSlamTrajectory(episodeId, loadToken);
+    const tactileReady = loadTactileMatrixMeta(episodeId, loadToken);
 
     const grid = document.getElementById('video-grid');
     if (!grid) { hideVideoLoading(); return; }
@@ -2330,10 +3026,18 @@ async function loadGroupedEpisodeVideo(episodeId, cameras, options = {}) {
         if (!isCurrentPlaybackSession(episodeId, loadToken)) return;  // 丢弃过期响应
         if (res.ok) {
             currentMediaGroups = await res.json();
-            await hand3dReady;
+            await Promise.all([hand3dReady, slamReady, tactileReady]);
             if (!isCurrentPlaybackSession(episodeId, loadToken)) return;
             renderSourceBar();
             _defaultWorkspaceFromGroups();
+            // SLAM is a first-class spatial source. Add it before the initial
+            // workspace render so it enters the same mount barrier as RGB.
+            if (typeof window.ensureSlamTrajectoryTile === 'function') {
+                window.ensureSlamTrajectoryTile();
+            }
+            if (typeof window.ensureTactileMatrixTile === 'function') {
+                window.ensureTactileMatrixTile();
+            }
             // Add the selected spatial source before renderGroupedWorkspace
             // takes its Promise.all(mounted) snapshot.
             if (typeof ensureHand3dWorldTile === 'function'
@@ -2418,12 +3122,16 @@ function loadEpisodeVideo(episodeId, cameras, options = {}) {
     // can leave the global skeleton switch disabled for the next episode.
     if (typeof destroyAllHandOverlays === 'function') destroyAllHandOverlays();
     currentHand3dTiles = [];
+    currentSlamTiles = [];
     hand3dData = null;
     hand3dDataBySource = {};
     hand3dFrameCache = { frame: -1, data: null, inflight: -1 };
     hand3dFrameCacheBySource = {};
     hand3dWindow = { start: -1, end: -1, frames: {}, inflight: false };
     hand3dWindowBySource = {};
+    slamData = null;
+    slamFramesByIndex = {};
+    slamWindowInflight = null;
     _depthPlaybackStall = null;
     _hand3dViewAnchor = null;
     _h3dBaseDist = null;
@@ -3382,10 +4090,469 @@ const HAND3D_CONNECTIONS = [
     [0, 17],                                        // 掌根
 ];
 
+async function loadSlamTrajectory(episodeId, sessionToken = null) {
+    try {
+        const signal = getMediaLoadSignal();
+        const res = await fetch(
+            `/api/v1/video/${episodeId}/slam-trajectory?max_points=10000`,
+            signal ? { signal, cache: 'no-store' } : { cache: 'no-store' });
+        if (!isCurrentPlaybackSession(episodeId, sessionToken)) return null;
+        if (!res.ok) return null;
+        const data = await res.json();
+        if (!isCurrentPlaybackSession(episodeId, sessionToken)) return null;
+        if (!data || data.available !== true) return null;
+        slamData = data;
+        slamFramesByIndex = {};
+        (data.frames || data.trajectory || []).forEach(row => {
+            const frame = Number(row && row.f);
+            const pose = row && row.p;
+            const valid = Array.isArray(pose) && pose.length >= 7
+                && pose.slice(0, 7).every(value => Number.isFinite(Number(value)))
+                && Math.hypot(...pose.slice(3, 7).map(Number)) >= 0.5;
+            if (Number.isFinite(frame) && valid) slamFramesByIndex[frame] = row;
+        });
+        return data;
+    } catch (_) {
+        return null;
+    }
+}
+
+async function loadTactileMatrixMeta(episodeId, sessionToken = null) {
+    try {
+        const signal = getMediaLoadSignal();
+        const res = await fetch(
+            `/api/v1/video/${episodeId}/tactile-matrix-meta?v=202609091720-tactile-fetch-slam-axis`,
+            signal ? { signal, cache: 'no-store' } : { cache: 'no-store' });
+        if (!isCurrentPlaybackSession(episodeId, sessionToken)) return null;
+        if (!res.ok) return null;
+        const data = await res.json();
+        if (!isCurrentPlaybackSession(episodeId, sessionToken)) return null;
+        if (!data || data.available !== true) return null;
+        // Scalar fx/fy/fz values are small enough to preload once per
+        // episode.  Keep them indexed by frame so scrubbing does not issue a
+        // second parquet request for every tactile image.
+        const series = data.force_series;
+        const forceByFrame = Object.create(null);
+        if (series && Array.isArray(series.frames)) {
+            series.frames.forEach((frame, index) => {
+                const key = String(Number(frame));
+                forceByFrame[key] = {
+                    left: Array.isArray(series.left) ? series.left[index] : null,
+                    right: Array.isArray(series.right) ? series.right[index] : null,
+                };
+            });
+        }
+        data._forceByFrame = forceByFrame;
+        tactileMatrixData = data;
+        return data;
+    } catch (_) {
+        return null;
+    }
+}
+
+window.ensureSlamTrajectoryTile = function () {
+    if (!slamData || slamData.available !== true) return;
+    const source = {
+        kind: 'slam_trajectory',
+        source_key: 'slam_trajectory',
+        label: 'SLAM',
+    };
+    const key = groupedSourceKey(source);
+    if (workspaceSources.some(item => groupedSourceKey(item) === key)) return;
+    workspaceSources.push(source);
+};
+
+window.ensureTactileMatrixTile = function () {
+    if (!tactileMatrixData || tactileMatrixData.available !== true) return;
+    const sources = [
+        { kind: 'tactile_force_left', source_key: 'tactile_force_left',
+            side: 'left', label: 'Left' },
+        { kind: 'tactile_force_right', source_key: 'tactile_force_right',
+            side: 'right', label: 'Right' },
+    ];
+    sources.forEach(source => {
+        const key = groupedSourceKey(source);
+        if (!workspaceSources.some(item => groupedSourceKey(item) === key)) {
+            workspaceSources.push(source);
+        }
+    });
+};
+
+function _slamRows() {
+    if (!slamData) return [];
+    const rows = Array.isArray(slamData.trajectory) && slamData.trajectory.length
+        ? slamData.trajectory : slamData.frames;
+    return (rows || []).filter(row => row && Array.isArray(row.p)
+        && row.p.length >= 7
+        && row.p.slice(0, 3).every(value => Number.isFinite(Number(value))));
+}
+
+function _slamSmoothRows() {
+    if (!slamData) return [];
+    if (Array.isArray(slamData._displayRows)) return slamData._displayRows;
+    const rows = _slamRows();
+    let previous = null;
+    let previousFrame = null;
+    const smoothed = rows.map(row => {
+        const raw = row.p.slice(0, 3).map(Number);
+        const frame = Number(row.f);
+        const frameGap = previousFrame === null ? Infinity : frame - previousFrame;
+        const canSmooth = previous && frameGap <= SLAM_DISPLAY_JOIN_GAP_FRAMES;
+        const point = canSmooth
+            ? raw.map((value, axis) => previous[axis]
+                + SLAM_DISPLAY_SMOOTH_ALPHA * (value - previous[axis]))
+            : raw;
+        row._displayPosition = point;
+        previous = point;
+        previousFrame = frame;
+        return row;
+    });
+    slamData._displayRows = smoothed;
+    return smoothed;
+}
+
+// The acquisition side records the S80M camera pose in a gravity-aligned
+// world frame: +Z is up (measured on real data - a physical turn of the
+// gripper rotates about world +Z, and the gripper's own up axis sits within
+// ~12 deg of it for the whole episode). The browser camera uses a right-handed
+// frame with Y up, so display=[source X, source Z, -source Y] keeps the
+// stored values untouched and puts world up on screen up.
+function _slamDisplayPoint(sourcePoint) {
+    return [Number(sourcePoint[0]), Number(sourcePoint[2]), -Number(sourcePoint[1])];
+}
+
+function _slamSourcePoint(row) {
+    const point = Array.isArray(row && row._displayPosition)
+        ? row._displayPosition : row && row.p;
+    return point ? point.slice(0, 3).map(Number) : null;
+}
+
+function _slamCanJoinRows(previousRow, row) {
+    if (!previousRow || !row) return false;
+    const gap = Number(row.f) - Number(previousRow.f);
+    return Number.isFinite(gap) && gap <= SLAM_DISPLAY_JOIN_GAP_FRAMES;
+}
+
+function _slamNearestRow(frame) {
+    const target = Math.max(0, Math.round(Number(frame) || 0));
+    const rows = _slamSmoothRows();
+    if (!rows.length) return null;
+    // If the current video frame has no valid pose, keep the last pose that
+    // has already happened. Never select a future pose for the live marker.
+    let best = null;
+    rows.forEach(row => {
+        const rowFrame = Number(row.f);
+        if (rowFrame <= target && (!best || rowFrame > Number(best.f))) {
+            best = row;
+        }
+    });
+    return best;
+}
+
+function _slamFit(rows) {
+    const points = rows.map(row => _slamDisplayPoint(_slamSourcePoint(row)));
+    const min = [Infinity, Infinity, Infinity];
+    const max = [-Infinity, -Infinity, -Infinity];
+    points.forEach(point => point.forEach((value, axis) => {
+        min[axis] = Math.min(min[axis], value);
+        max[axis] = Math.max(max[axis], value);
+    }));
+    const span = Math.max(max[0] - min[0], max[1] - min[1], max[2] - min[2], 0.4);
+    const center = min.map((value, axis) => (value + max[axis]) / 2);
+    const gridStep = 0.2;
+    const gridY = Math.floor((min[1] - 0.08) / gridStep) * gridStep;
+    const half = Math.max(0.6, Math.ceil((span * 0.7) / gridStep) * gridStep);
+    const fov = 45 * Math.PI / 180;
+    const baseDist = Math.max(
+        1.2,
+        Math.min(
+            6,
+            span * 1.25 * SLAM_DISPLAY_CAMERA_DISTANCE_SCALE
+                / Math.tan(fov / 2),
+        ),
+    );
+    return { points, min, max, center, gridY, half, baseDist };
+}
+
+function _slamRotateVector(pose, vector) {
+    let qx = Number(pose[3]), qy = Number(pose[4]);
+    let qz = Number(pose[5]), qw = Number(pose[6]);
+    const norm = Math.hypot(qx, qy, qz, qw);
+    if (![qx, qy, qz, qw].every(Number.isFinite) || norm < 1e-6) return vector;
+    qx /= norm;
+    qy /= norm;
+    qz /= norm;
+    qw /= norm;
+    const tx = 2 * (qy * vector[2] - qz * vector[1]);
+    const ty = 2 * (qz * vector[0] - qx * vector[2]);
+    const tz = 2 * (qx * vector[1] - qy * vector[0]);
+    return [
+        vector[0] + qw * tx + qy * tz - qz * ty,
+        vector[1] + qw * ty + qz * tx - qx * tz,
+        vector[2] + qw * tz + qx * ty - qy * tx,
+    ];
+}
+
+function _slamGripperState(row) {
+    const values = row && Array.isArray(row.g) ? row.g : null;
+    if (!values || values.length < 1) return null;
+    const percent = Number(values[0]);
+    if (!Number.isFinite(percent)) return null;
+    return {
+        percent: Math.max(0, Math.min(100, percent)),
+        gripped: Number(values[1]) >= 0.5,
+    };
+}
+
+function renderSlamTile(entry, frameOverride) {
+    if (!entry || !entry.canvas) return;
+    const canvas = entry.canvas;
+    const rect = canvas.getBoundingClientRect();
+    const dpr = window.devicePixelRatio || 1;
+    const w = Math.max(1, rect.width), h = Math.max(1, rect.height);
+    if (canvas.width !== Math.round(w * dpr) || canvas.height !== Math.round(h * dpr)) {
+        canvas.width = Math.round(w * dpr);
+        canvas.height = Math.round(h * dpr);
+    }
+    const ctx = canvas.getContext('2d');
+    ctx.setTransform(dpr, 0, 0, dpr, 0, 0);
+    ctx.clearRect(0, 0, w, h);
+    ctx.fillStyle = 'rgba(3,7,18,0.95)';
+    ctx.fillRect(0, 0, w, h);
+
+    const rows = _slamSmoothRows();
+    if (!rows.length) return;
+    if (!entry.fit) entry.fit = _slamFit(rows);
+    const fit = entry.fit;
+    const frame = typeof frameOverride === 'number'
+        ? frameOverride : (typeof currentFrameTarget === 'number' ? currentFrameTarget : 0);
+    const cam = _hand3dCam(
+        fit.points, w, h, entry.rotY || 0, entry.rotX || 0.35,
+        entry.zoom || 1, fit.baseDist, entry.pan || [0, 0, 0]);
+    entry._lastCam = cam;
+    const project = point => _projectHand3D(point, cam);
+    const line = (a, b, color, width = 1) => {
+        const pa = project(a), pb = project(b);
+        if (!Number.isFinite(pa[0]) || !Number.isFinite(pa[1])
+                || !Number.isFinite(pb[0]) || !Number.isFinite(pb[1])) return;
+        ctx.strokeStyle = color;
+        ctx.lineWidth = width;
+        ctx.beginPath();
+        ctx.moveTo(pa[0], pa[1]);
+        ctx.lineTo(pb[0], pb[1]);
+        ctx.stroke();
+    };
+
+    // Ground grid: every square is exactly 0.2 m. Labels are intentionally
+    // kept to one small unit marker so the spatial view stays uncluttered.
+    const minX = fit.center[0] - fit.half;
+    const maxX = fit.center[0] + fit.half;
+    const minZ = fit.center[2] - fit.half;
+    const maxZ = fit.center[2] + fit.half;
+    for (let x = minX; x <= maxX + 0.001; x += 0.2) {
+        line([x, fit.gridY, minZ], [x, fit.gridY, maxZ], 'rgba(75,85,99,0.55)');
+    }
+    for (let z = minZ; z <= maxZ + 0.001; z += 0.2) {
+        line([minX, fit.gridY, z], [maxX, fit.gridY, z], 'rgba(75,85,99,0.55)');
+    }
+
+    // Small axis marker at the fitted area: the recorded world axes, drawn in
+    // the display frame that _slamDisplayPoint produces (world +Z is up).
+    const axisOrigin = [fit.center[0], fit.gridY, fit.center[2]];
+    const axisTips = [
+        // World axes: X and Y horizontal, Z up.
+        [[axisOrigin[0] + 0.2, axisOrigin[1], axisOrigin[2]], 'rgb(248,90,90)', 'X'],
+        [[axisOrigin[0], axisOrigin[1], axisOrigin[2] - 0.2], 'rgb(80,220,130)', 'Y'],
+        [[axisOrigin[0], axisOrigin[1] + 0.2, axisOrigin[2]], 'rgb(90,150,255)', 'Z'],
+    ];
+    axisTips.forEach(([tip, color, label]) => {
+        line(axisOrigin, tip, color, 1.5);
+        const projected = project(tip);
+        if (!Number.isFinite(projected[0]) || !Number.isFinite(projected[1])) return;
+        ctx.font = '10px sans-serif';
+        ctx.fillStyle = color;
+        ctx.fillText(label, projected[0] + 3, projected[1] - 3);
+    });
+    const axis = project(axisOrigin);
+    if (Number.isFinite(axis[0]) && Number.isFinite(axis[1])) {
+        ctx.font = '9px sans-serif';
+        ctx.fillStyle = 'rgba(148,163,184,0.8)';
+        ctx.fillText('0.2m', axis[0] + 5, axis[1] + 12);
+    }
+
+    const current = Number(frame);
+    let previous = null;
+    let previousRow = null;
+    rows.forEach(row => {
+        const rowFrame = Number(row.f);
+        if (rowFrame > current) return;
+        const sourcePoint = _slamSourcePoint(row);
+        const point = _slamDisplayPoint(sourcePoint);
+        if (previous && _slamCanJoinRows(previousRow, row)) {
+            line(previous, point, 'rgba(34,211,238,0.95)', 2);
+        }
+        previous = point;
+        previousRow = row;
+    });
+
+    const currentRow = _slamNearestRow(current);
+    if (currentRow) {
+        const pose = currentRow.p.map(Number);
+        const sourcePoint = _slamSourcePoint(currentRow);
+        const point = _slamDisplayPoint(sourcePoint);
+        const projected = project(point);
+        if (Number.isFinite(projected[0]) && Number.isFinite(projected[1])) {
+            ctx.fillStyle = '#f8fafc';
+            ctx.beginPath();
+            ctx.arc(projected[0], projected[1], 4, 0, Math.PI * 2);
+            ctx.fill();
+            ctx.strokeStyle = '#06b6d4';
+            ctx.lineWidth = 2;
+            ctx.stroke();
+        }
+        const axisLength = 0.08;
+        const colors = ['rgb(248,90,90)', 'rgb(80,220,130)', 'rgb(90,150,255)'];
+        [[1, 0, 0], [0, 1, 0], [0, 0, 1]].forEach((vector, index) => {
+            const rotated = _slamRotateVector(pose, vector);
+            const displayVector = _slamDisplayPoint(rotated);
+            line(point, [
+                point[0] + displayVector[0] * axisLength,
+                point[1] + displayVector[1] * axisLength,
+                point[2] + displayVector[2] * axisLength,
+            ], colors[index], 2);
+        });
+
+        // Simplified UMI gripper model. The recorded pose frame is the S80M
+        // camera frame; measured on real data the device axes sit at
+        // +X = camera right (~world +Y), +Y = gripper up (~world +Z, the
+        // camera is mounted inverted) and +Z = gripper forward (~world +X,
+        // the optical axis). So the body extends along local +Z, the two
+        // plates separate along local X, and each plate is 0.20m long
+        // (forward) by 0.05m tall (up) with a 0.12m maximum opening.
+        const grip = _slamGripperState(currentRow);
+        if (grip) {
+            const toDisplay = local => {
+                const rotated = _slamRotateVector(pose, local);
+                return _slamDisplayPoint([
+                    sourcePoint[0] + rotated[0],
+                    sourcePoint[1] + rotated[1],
+                    sourcePoint[2] + rotated[2],
+                ]);
+            };
+            const plateLength = 0.20;
+            const plateHeight = 0.05;
+            const maxHalfGap = 0.06;
+            const baseOffset = 0.10;
+            const halfGap = maxHalfGap * (1 - grip.percent / 100);
+            const jawColor = grip.gripped
+                ? 'rgba(248,90,90,0.95)' : 'rgba(88,168,232,0.95)';
+            const jawFill = grip.gripped
+                ? 'rgba(248,90,90,0.16)' : 'rgba(88,168,232,0.12)';
+            const relativeCorners = [
+                [0, -plateHeight / 2, -plateLength / 2],
+                [0, -plateHeight / 2, plateLength / 2],
+                [0, plateHeight / 2, plateLength / 2],
+                [0, plateHeight / 2, -plateLength / 2],
+            ];
+
+            for (const sign of [1, -1]) {
+                const centerX = sign * halfGap;
+                const corners = relativeCorners.map(corner => project(toDisplay([
+                    centerX + corner[0],
+                    corner[1],
+                    baseOffset + corner[2],
+                ])));
+                if (corners.every(item => Number.isFinite(item[0]) && Number.isFinite(item[1]))) {
+                    ctx.fillStyle = jawFill;
+                    ctx.strokeStyle = jawColor;
+                    ctx.lineWidth = 2;
+                    ctx.beginPath();
+                    ctx.moveTo(corners[0][0], corners[0][1]);
+                    corners.slice(1).forEach(item => ctx.lineTo(item[0], item[1]));
+                    ctx.closePath();
+                    ctx.fill();
+                    ctx.stroke();
+                }
+                line(
+                    toDisplay([centerX, 0, baseOffset - plateLength / 2]),
+                    toDisplay([centerX, 0, baseOffset + plateLength / 2]),
+                    jawColor, 1);
+            }
+
+            // Rear crossbar plus the two supports that tie each plate back to
+            // the body, so the opening stays readable when it is small.
+            line(toDisplay([-maxHalfGap, 0, baseOffset]),
+                toDisplay([maxHalfGap, 0, baseOffset]),
+                'rgba(148,163,184,0.8)', 1.5);
+            for (const sign of [1, -1]) {
+                for (const cornerZ of [-plateLength / 2, plateLength / 2]) {
+                    line(
+                        toDisplay([sign * halfGap, 0, baseOffset + cornerZ]),
+                        toDisplay([0, 0, baseOffset + cornerZ]),
+                        'rgba(148,163,184,0.8)', 1);
+                }
+            }
+        }
+    }
+}
+
+function initSlamDrag(entry) {
+    if (!entry || !entry.canvas) return;
+    const canvas = entry.canvas;
+    canvas.style.cursor = 'grab';
+    canvas.addEventListener('mousedown', event => {
+        if (event.button !== 0 && event.button !== 1) return;
+        entry.dragging = true;
+        entry.dragMode = event.button === 1 ? 'pan' : 'rotate';
+        entry.lastX = event.clientX;
+        entry.lastY = event.clientY;
+        canvas.style.cursor = entry.dragMode === 'pan' ? 'move' : 'grabbing';
+        event.preventDefault();
+    });
+    window.addEventListener('mousemove', event => {
+        if (!entry.dragging) return;
+        const dx = event.clientX - entry.lastX;
+        const dy = event.clientY - entry.lastY;
+        if (entry.dragMode === 'pan' && entry._lastCam) {
+            const distance = Math.max(0.2, Math.hypot(
+                entry._lastCam.eye[0] - entry._lastCam.centroid[0],
+                entry._lastCam.eye[1] - entry._lastCam.centroid[1],
+                entry._lastCam.eye[2] - entry._lastCam.centroid[2]));
+            const worldPerPixel = distance / Math.max(1, entry._lastCam.f);
+            const pan = entry.pan || (entry.pan = [0, 0, 0]);
+            for (let i = 0; i < 3; i++) {
+                pan[i] += (-dx * entry._lastCam.right[i]
+                    + dy * entry._lastCam.up[i]) * worldPerPixel;
+            }
+        } else {
+            entry.rotY += dx * 0.01;
+            entry.rotX = Math.max(-1.2, Math.min(1.2, entry.rotX + dy * 0.01));
+        }
+        entry.lastX = event.clientX;
+        entry.lastY = event.clientY;
+        renderSlamTile(entry);
+    });
+    window.addEventListener('mouseup', () => {
+        if (!entry.dragging) return;
+        entry.dragging = false;
+        entry.dragMode = '';
+        canvas.style.cursor = 'grab';
+    });
+    canvas.addEventListener('contextmenu', event => event.preventDefault());
+    canvas.addEventListener('wheel', event => {
+        event.preventDefault();
+        entry.zoom = Math.min(6, Math.max(0.3,
+            (entry.zoom || 1) * Math.exp(-event.deltaY * 0.0015)));
+        renderSlamTile(entry);
+    }, { passive: false });
+}
+
 async function loadHand3D(episodeId, sessionToken = null) {
     try {
         const signal = getMediaLoadSignal();
-        const res = await fetch(`/api/v1/video/${episodeId}/hand-3d`, signal ? { signal } : {});
+        const res = await fetch(
+            `/api/v1/video/${episodeId}/hand-3d`,
+            signal ? { signal, cache: 'no-store' } : { cache: 'no-store' });
         if (!isCurrentPlaybackSession(episodeId, sessionToken)) return;  // 丢弃过期响应
         if (!res.ok) return;
         const data = await res.json();
@@ -3805,11 +4972,21 @@ function _normalizeDepthWorldDisplayScale(slots, entry, w, h) {
         for (const slot of slots) {
             const valid = slot.valid || [];
             if (valid.length < 4) continue;
-            const xs = valid.map(p => p[0]), ys = valid.map(p => p[1]);
-            const zs = valid.map(p => p[2]);
-            spans.push(Math.max(Math.max(...xs) - Math.min(...xs),
-                                Math.max(...ys) - Math.min(...ys),
-                                Math.max(...zs) - Math.min(...zs)));
+            // Ignore isolated depth outliers when choosing the fixed preview
+            // scale. A single bad landmark in #3's first frame was metres
+            // away from the hand and permanently made later frames tiny.
+            const robustSpan = values => {
+                const sorted = values.filter(Number.isFinite).sort((a, b) => a - b);
+                if (!sorted.length) return 0;
+                const quantile = fraction => sorted[Math.floor(
+                    (sorted.length - 1) * fraction)];
+                return quantile(0.95) - quantile(0.05);
+            };
+            spans.push(Math.max(
+                robustSpan(valid.map(p => p[0])),
+                robustSpan(valid.map(p => p[1])),
+                robustSpan(valid.map(p => p[2])),
+            ));
         }
         const measured = spans.length
             ? spans.reduce((sum, value) => sum + value, 0) / spans.length : 0;
@@ -3841,6 +5018,41 @@ function _normalizeDepthWorldDisplayScale(slots, entry, w, h) {
     return scale;
 }
 
+// A few D435 frames contain landmark coordinates that jump metres away from
+// the wrist. Keep those points out of the 3D preview only. The parquet/API
+// values remain untouched, and a real hand landmark cannot be this far from
+// its wrist in the camera coordinate system.
+const HAND3D_WORLD_DISPLAY_MAX_HAND_RADIUS = 0.35;
+
+function _filterDepthWorldDisplayOutliers(slots) {
+    slots.forEach(slot => {
+        const points = slot.pts || [];
+        const wrist = points[0] || points.find(Boolean);
+        if (!wrist) return;
+
+        let validCount = 0;
+        let compactCount = 0;
+        const maxRadius = HAND3D_WORLD_DISPLAY_MAX_HAND_RADIUS;
+        const keep = points.map(point => {
+            if (!point) return false;
+            validCount += 1;
+            const dx = point[0] - wrist[0];
+            const dy = point[1] - wrist[1];
+            const dz = point[2] - wrist[2];
+            const isCompact = Math.hypot(dx, dy, dz) <= maxRadius;
+            if (isCompact) compactCount += 1;
+            return isCompact;
+        });
+
+        // Do not blank a sparse hand just because it has one questionable
+        // point. Only apply the filter when a usable compact skeleton remains.
+        if (compactCount < 4 || compactCount === validCount) return;
+        slot.pts = points.map((point, index) => point && keep[index] ? point : null);
+        slot.fin = slot.pts.map(Boolean);
+        slot.valid = slot.pts.filter(Boolean);
+    });
+}
+
 function _hand3dJointRadius(proj, index, tip = false, styleScale = 1) {
     if (!proj[index] || !Number.isFinite(proj[index][0])
             || !Number.isFinite(proj[index][1])) return 0;
@@ -4129,6 +5341,9 @@ function renderHand3DTile(entry, frameOverride) {
         slots.forEach(s => all.push(...s.valid));
     }
     if (sourceData && sourceData.worldMode) {
+        _filterDepthWorldDisplayOutliers(slots);
+        all.length = 0;
+        slots.forEach(s => all.push(...s.valid));
         _normalizeDepthWorldDisplayScale(slots, entry, w, h);
         all.length = 0;
         slots.forEach(s => all.push(...s.valid));
@@ -4332,6 +5547,7 @@ function initHand3dDrag(entry) {
    标注高亮共用;闭包在调用时遍历,脚本加载时 tile 列表为空无影响) */
 setOnFrameChange((f) => {
     for (const entry of currentHand3dTiles) renderHand3DTile(entry, f);
+    for (const entry of currentSlamTiles) renderSlamTile(entry, f);
 });
 
 /* 图像素材(深度图/手套热力图)的逐帧 rAF 刷新循环(见 _startImageTileRaf) */

processor/web/static/workflow-studio/.vite/manifest.json

@@ -1,6 +1,6 @@
 {
   "index.html": {
-    "file": "assets/index-KixdmCX9.js",
+    "file": "assets/index-CcWpS4e6.js",
     "name": "index",
     "src": "index.html",
     "isEntry": true,

processor/web/static/workflow-studio/index.html

@@ -6,7 +6,7 @@
     <title>Workflow Studio — EgoData</title>
     <script src="/static/iconify-preload.js"></script>
     <script src="/static/iconify-icon.min.js"></script>
-    <script type="module" crossorigin src="/static/workflow-studio/assets/index-KixdmCX9.js"></script>
+    <script type="module" crossorigin src="/static/workflow-studio/assets/index-CcWpS4e6.js"></script>
     <link rel="stylesheet" crossorigin href="/static/workflow-studio/assets/index-Byx6G-Zk.css">
   </head>
   <body class="bg-gray-950 text-gray-200">

processor/web/templates/index.html

@@ -564,8 +564,8 @@
 
 <script src="/static/js/media-cache.js?v=202609081530"></script>
 <script src="/static/js/depth-renderer.js?v=202609081530"></script>
-    <script src="/static/js/player.js?v=202609081530"></script>
-    <script src="/static/js/hand-overlay.js?v=202609081530"></script>
+    <script src="/static/js/player.js?v=202609091912-tactile-chunk-prefetch"></script>
+    <script src="/static/js/hand-overlay.js?v=202609081630"></script>
 <script src="/static/js/heatmap.js?v=202609081530"></script>
     <script src="/static/js/annotations.js?v=202609081530"></script>
 <script src="/static/js/slice-preview.js?v=202609081530"></script>

processor/web/workflow-studio/src/components/WorkflowCanvas/NodePalette.tsx

@@ -8,7 +8,7 @@ const LEGACY_INPUT_TYPES = ['rgb_camera', 'fisheye_camera'];
 // 新工作流始终从这组稳定的采集端分类开始。真实设备名称由工作流卡片
 // 内部的 source_key 控件从项目上传/心跳数据中选择,不作为调色板卡片。
 const FIXED_INPUT_TYPES = [
-  'glove_sensor', 'mono_camera', 'rgbd_camera', 'stereo_camera', 'stereo_rgbd_camera',
+  'gripper_device', 'glove_sensor', 'mono_camera', 'rgbd_camera', 'stereo_camera', 'stereo_rgbd_camera',
 ];
 // MediaPipe Hand is retained as a backend/old-workflow compatibility node;
 // the current hand modules are exposed through the canonical process cards.

processor/web/workflow-studio/src/components/WorkflowCanvas/WorkflowCanvas.tsx

@@ -40,7 +40,13 @@ export function WorkflowCanvas() {
     }
     const sourceKeys = deviceSource?.source_keys || [];
     const sourceConfig = deviceSource
-      ? (deviceSource.input_type === 'stereo_camera'
+      ? (deviceSource.input_type === 'gripper_device'
+        ? {
+            source_keys: sourceKeys.join(','),
+            source_key: deviceSource.source_key || sourceKeys[0] || '',
+            position: deviceSource.source_key || sourceKeys[0] || '',
+          }
+        : deviceSource.input_type === 'stereo_camera'
         || deviceSource.input_type === 'stereo_rgbd_camera')
         ? {
             source_keys: sourceKeys.join(','),

processor/web/workflow-studio/src/components/WorkflowCanvas/nodes/WorkflowNode.tsx

@@ -11,6 +11,7 @@ const CAMERA_TYPES = [
   'mono_camera', 'rgbd_camera', 'rgb_camera', 'fisheye_camera',
   'stereo_camera', 'stereo_rgbd_camera',
 ];
+const DEVICE_INPUT_TYPES = [...CAMERA_TYPES, 'gripper_device'];
 const DEPTH_PROCESS_TYPES = ['rgbd_to_3d_bare_hand', 'rgbd_to_3d_black_glove'];
 
 const DEVICE_CATEGORY_LABELS: Record<string, string> = {
@@ -19,6 +20,7 @@ const DEVICE_CATEGORY_LABELS: Record<string, string> = {
   mono_rgb: 'RGB Camera',
   stereo_rgb: 'Stereo RGB Camera',
   glove_sensor: 'Glove Sensor',
+  gripper_device: 'UMI Gripper',
 };
 
 function cameraCategoryLabel(data: WorkflowNodeData): string {
@@ -30,6 +32,7 @@ function cameraCategoryLabel(data: WorkflowNodeData): string {
   if (data.nodeType === 'rgbd_camera') return DEVICE_CATEGORY_LABELS.rgbd_camera;
   if (data.nodeType === 'mono_camera' || data.nodeType === 'rgb_camera'
       || data.nodeType === 'fisheye_camera') return DEVICE_CATEGORY_LABELS.mono_rgb;
+  if (data.nodeType === 'gripper_device') return DEVICE_CATEGORY_LABELS.gripper_device;
   const byType = data.device_type ? DEVICE_CATEGORY_LABELS[String(data.device_type)] : '';
   if (byType) return byType;
   const stored = String(data.device_display_name || '');
@@ -40,7 +43,7 @@ function cameraCategoryLabel(data: WorkflowNodeData): string {
 export const WorkflowNodeComponent = memo(function WorkflowNodeComponent({ data, selected, id }: NodeProps) {
   const d = data as unknown as WorkflowNodeData;
   const hdrColor = d.color || '#475569';
-  const isCamera = CAMERA_TYPES.includes(d.nodeType);
+  const isCamera = DEVICE_INPUT_TYPES.includes(d.nodeType);
   // 画布节点悬停说明:与侧边栏一致(功能 + 可连接性)
   const desc = getNodeType(d.nodeType)?.description;
   const topField = getTopConfigField(d);
@@ -145,7 +148,9 @@ export const WorkflowNodeComponent = memo(function WorkflowNodeComponent({ data,
       config.position = value;
       if (selectedSource) {
         config.device_name = selectedSource.name;
-        if (selectedSource.input_type === 'stereo_camera'
+        if (selectedSource.input_type === 'gripper_device') {
+          config.source_keys = selectedSource.source_keys.join(',');
+        } else if (selectedSource.input_type === 'stereo_camera'
             || selectedSource.input_type === 'stereo_rgbd_camera') {
           config.source_keys = selectedSource.source_keys.join(',');
         } else {
@@ -316,6 +321,7 @@ function sourceMatchesCameraType(
   if (nodeType === 'rgbd_camera') return category === 'rgbd_camera';
   if (nodeType === 'stereo_camera') return category === 'stereo_rgb';
   if (nodeType === 'glove_sensor') return category === 'glove_sensor';
+  if (nodeType === 'gripper_device') return category === 'gripper_device';
   if (storedDeviceType && String(storedDeviceType) === 'rgbd_camera') {
     return category === 'rgbd_camera';
   }
@@ -326,7 +332,7 @@ function sourceMatchesCameraType(
 
 function getTopConfigField(data: WorkflowNodeData): ConfigField | null {
   const schema = data.configSchema || [];
-  if (CAMERA_TYPES.includes(data.nodeType)) {
+  if (DEVICE_INPUT_TYPES.includes(data.nodeType)) {
     return schema.find((field) => field.name === 'source_key') || {
       name: 'source_key', type: 'string', label: 'Source key',
       default: data.config?.source_key || data.config?.position || '',

processor/web/workflow-studio/src/components/WorkflowCanvas/nodes/registry.ts

@@ -51,6 +51,14 @@ const CANONICAL_PORTS: Record<string, Pick<NodeTypeDescriptor, 'inputs' | 'outpu
   glove_sensor: {
     inputs: [], outputs: [{ key: 'sensor_data', label: 'Glove Sensor Data' }],
   },
+  gripper_device: {
+    inputs: [], outputs: [
+      { key: 'rgb_video', label: 'RGB Video' },
+      { key: 'gripper_state', label: 'ESP Gripper State' },
+      { key: 'slam_trajectory', label: 'SLAM Trajectory' },
+      { key: 'tactile_force_matrices', label: 'Left and Right Force Matrices' },
+    ],
+  },
   mediapipe_hand: {
     inputs: [{ key: 'video', label: 'RGB Video' }],
     outputs: [{ key: 'hand_keypoints', label: 'Hand 2D' }],
@@ -251,6 +259,19 @@ const BUILTIN: NodeTypeDescriptor[] = [
     outputs: [{ key: 'sensor_data', label: 'Glove Sensor Data' }],
     defaultConfig: { source_key: '', device: 'SenseGlove', hand: 'both', fps: 60 },
   },
+  {
+    type: 'gripper_device', category: 'input', label: 'UMI Gripper',
+    icon: 'ant-design:robot-outlined', color: MODULE_COLORS.input,
+    description: 'Composite acquisition source. Publishes one gripper RGB video, ESP32 grip state, SLAM trajectory, and paired left/right 250×250×3 force matrices to downstream workflow nodes.',
+    inputs: [],
+    outputs: [
+      { key: 'rgb_video', label: 'RGB Video' },
+      { key: 'gripper_state', label: 'ESP Gripper State' },
+      { key: 'slam_trajectory', label: 'SLAM Trajectory' },
+      { key: 'tactile_force_matrices', label: 'Left and Right Force Matrices' },
+    ],
+    defaultConfig: { source_key: '', fps: 30 },
+  },
   // ── Process ──
   {
     type: 'mediapipe_hand', category: 'process', label: 'MediaPipe Hand',

processor/web/workflow-studio/src/store/workflowStore.ts

@@ -110,11 +110,12 @@ const DEVICE_CATEGORY_LABELS: Record<string, string> = {
   mono_rgb: 'RGB Camera',
   stereo_rgb: 'Stereo RGB Camera',
   glove_sensor: 'Glove Sensor',
+  gripper_device: 'UMI Gripper',
 };
 
 const CAMERA_INPUT_TYPES = new Set([
   'mono_camera', 'rgbd_camera', 'rgb_camera', 'fisheye_camera',
-  'stereo_camera', 'stereo_rgbd_camera',
+  'stereo_camera', 'stereo_rgbd_camera', 'gripper_device',
 ]);
 
 function cameraSourceKeys(node: Node<WorkflowNodeData>): string[] {
@@ -236,6 +237,14 @@ function _migrateWorkflowGraph(graph: { nodes?: Node<WorkflowNodeData>[]; edges?
         { key: 'video_right', label: 'Right RGB Video' },
         { key: 'depth', label: 'Depth' },
       ];
+    } else if (nodeType === 'gripper_device') {
+      data.inputs = [];
+      data.outputs = [
+        { key: 'rgb_video', label: 'RGB Video' },
+        { key: 'gripper_state', label: 'ESP Gripper State' },
+        { key: 'slam_trajectory', label: 'SLAM Trajectory' },
+        { key: 'tactile_force_matrices', label: 'Left and Right Force Matrices' },
+      ];
     } else if (nodeType === 'rgb_to_2d_bare_hand'
         || nodeType === 'rgb_to_2d_black_glove') {
       data.inputs = [{ key: 'video', label: 'RGB Video' }];
@@ -264,6 +273,9 @@ function _migrateWorkflowGraph(graph: { nodes?: Node<WorkflowNodeData>[]; edges?
         : '';
     if (resultOutput && sourceHandle === 'result') {
       nextHandle = resultOutput;
+    } else if (sourceType === 'gripper_device'
+        && ['tactile_left', 'tactile_right'].includes(sourceHandle)) {
+      nextHandle = 'tactile_force_matrices';
     } else if (['rgb_to_2d_bare_hand', 'rgb_to_2d_black_glove'].includes(sourceType)
         && sourceHandle.startsWith('hand_3d')) {
       nextHandle = sourceHandle.replace(/^hand_3d/, 'hand_keypoints');
@@ -281,12 +293,24 @@ function _migrateWorkflowGraph(graph: { nodes?: Node<WorkflowNodeData>[]; edges?
     };
   });
 
+  // If both historical tactile ports targeted the same input, their merged
+  // handle represents one connection and must not produce a duplicate edge.
+  const seenGripperEdges = new Set<string>();
+  const dedupedEdges = edges.filter((edge) => {
+    if (sourceTypes.get(edge.source) !== 'gripper_device'
+        || edge.sourceHandle !== 'tactile_force_matrices') return true;
+    const key = `${edge.source}|${edge.sourceHandle}|${edge.target}|${edge.targetHandle || ''}`;
+    if (seenGripperEdges.has(key)) return false;
+    seenGripperEdges.add(key);
+    return true;
+  });
+
   // Existing local drafts may be loaded without a round trip through the API.
   // Keep their RGB-D graph equivalent to the server migration: an RGB-D input
   // card feeds both typed inputs when the old graph already had the video edge.
-  const edgeKeys = new Set(edges.map((edge) =>
+  const edgeKeys = new Set(dedupedEdges.map((edge) =>
     `${edge.source}|${edge.target}|${edge.targetHandle || ''}`));
-  for (const edge of [...edges]) {
+  for (const edge of [...dedupedEdges]) {
     if (edge.targetHandle !== 'video'
         || !['rgbd_camera', 'stereo_rgbd_camera']
           .includes(sourceTypes.get(edge.source) || '')
@@ -296,7 +320,7 @@ function _migrateWorkflowGraph(graph: { nodes?: Node<WorkflowNodeData>[]; edges?
     }
     const key = `${edge.source}|${edge.target}|depth`;
     if (edgeKeys.has(key)) continue;
-    edges.push({
+    dedupedEdges.push({
       ...edge,
       id: `xy-edge__${edge.source}depth-${edge.target}depth`,
       sourceHandle: 'depth',
@@ -304,7 +328,7 @@ function _migrateWorkflowGraph(graph: { nodes?: Node<WorkflowNodeData>[]; edges?
     });
     edgeKeys.add(key);
   }
-  return { nodes, edges };
+  return { nodes, edges: dedupedEdges };
 }
 
 /** 节点数据补齐:用注册表描述符填充缺失的 label/icon/color/端口/configSchema。
@@ -320,10 +344,11 @@ function _hydrateNode(node: Node<WorkflowNodeData>): Node<WorkflowNodeData> {
     'rgbd_to_3d_bare_hand', 'rgb_to_2d_bare_hand',
     'rgbd_to_3d_black_glove', 'rgb_to_2d_black_glove', 'annotation', 'ai_annotation',
     'human_review', 'ai_quality_review', 'lerobot_export', 'hdf5_export',
+    'gripper_device',
   ]);
   const controlledPorts = new Set([
     'rgb_camera', 'mono_camera', 'fisheye_camera', 'rgbd_camera',
-    'stereo_camera', 'stereo_rgbd_camera', 'glove_sensor', 'mediapipe_hand', 'annotation',
+    'stereo_camera', 'stereo_rgbd_camera', 'glove_sensor', 'gripper_device', 'mediapipe_hand', 'annotation',
     'ai_annotation', 'human_review', 'ai_quality_review', 'lerobot_export',
     'hdf5_export',
     'rgbd_to_3d_bare_hand', 'rgb_to_2d_bare_hand',
@@ -414,7 +439,7 @@ export function isConnectionValid(
 
   // 视频类端口兼容:stereo_camera 输出 video_left/video_right,
   // mediapipe_hand 输入是 video —— 同属视频数据,应允许连接。
-  const videoKeys = ['video', 'video_left', 'video_right'];
+  const videoKeys = ['video', 'rgb_video', 'video_left', 'video_right'];
   if (videoKeys.includes(inp.key) && videoKeys.includes(out.key)) return true;
 
   return out.key === inp.key;                   // typed ports must match

processor/web/workflow-studio/src/types/workflow.ts

@@ -104,7 +104,7 @@ export interface DeviceInputSource {
   /** Standardized UI name; name remains the raw compatibility identifier. */
   display_name?: string;
   kind?: string;
-  device_type?: 'rgbd_camera' | 'stereo_rgbd_camera' | 'mono_rgb' | 'stereo_rgb' | 'glove_sensor' | string;
+  device_type?: 'rgbd_camera' | 'stereo_rgbd_camera' | 'mono_rgb' | 'stereo_rgb' | 'glove_sensor' | 'gripper_device' | string;
   lens?: string;
   label?: string;
   input_type: string;