collector: 更新采集工程至 v1.3.6（夹爪并入极简版「只录不显」，Linux 包把约 460MB 夹爪原生栈当必需资源下发并逐项自检、缺则报 [错误 B] 拒启，Windows 包有意不带、靠载荷缺失降级；三个分发壳从 lite_package/ 搬到仓库根；力矩阵编码搬到 core/gripper_codec.py 作为唯一数据契约；SLAM 轨迹点新增宿主时刻戳 observation.{prefix}slam_trajectory_ns，真机验收最近邻残差中位 6.9ms（原行号配对 83ms）；另回收 native 树 339MB 重复 .so。含版本注释瘦身）

collector/.gitignore

@@ -9,6 +9,11 @@ build/
 data/recordings/
 data/*.db
 *.log
+# 原生日志归档目录（运行期把 runtime 目录 rmtree 之前的 SLAM 原生日志留档到这里，
+# 保留最近 20 份），连同 tools/dedup_gripper_native.py 的 JSON 报告一起**整体不入库**：
+# 都是本机诊断产物，动辄几十 MB（实测 57MB/22 份）。`.log` 那行只挡住了日志本体，
+# 报告是 .json 会漏网。
+logs/
 .venv/
 venv/
 venv_lite/
@@ -60,7 +65,9 @@ online/
 # ORBvoc.txt 单文件 138MB 超 GitHub 100MB 限制，且为第三方二进制，不入库）
 # 触觉 Sightac SDK 例外：core/gripper/sightac_sdk/ 已 pyarmor 加密，随包入库
 core/gripper/native/
+# 极简版发布目录/本机部署目录，整体不入库。
+# 2026-09-16 起 start_lite.bat/.sh 与 使用说明_lite.md 三个分发壳住在**仓库根**
+# （与 main_lite.py 同级，使根目录直接可运行）；lite_package/ 里那三份是
+# scripts/pack_lite.py 收集时复制进去的产物，同样不入库——原先的 !负向规则
+# 已随之删除，否则每次重打包都会留下未跟踪副本。
 lite_package/*
-!lite_package/start_lite.bat
-!lite_package/start_lite.sh
-!lite_package/使用说明_lite.md

collector/README.md

@@ -1,6 +1,6 @@
 # collector — Multimodal Data Acquisition SDK · 多模态数据采集 SDK
 
-![Version](https://img.shields.io/badge/version-1.3.5-blue)
+![Version](https://img.shields.io/badge/version-1.3.6-blue)
 ![Python](https://img.shields.io/badge/python-3.12-blue)
 ![License](https://img.shields.io/badge/license-TBD-lightgrey)
 
@@ -104,6 +104,17 @@ start.bat help          open the operation guide and troubleshooting doc
 > procedure: [使用说明.md](使用说明.md) / [使用说明_EN.md](使用说明_EN.md)
 > (offline wheel bundles are produced by `python scripts/pack_wheels.py`).
 
+**Lite edition** (capture + upload only — no login / playback / task page /
+skeleton solving): double-click **`start_lite.bat`** (Windows) or run
+`./start_lite.sh` (Linux); it uses its own `venv_lite/` (~750 MB). Same device
+set as above, including the **UMI gripper on Linux** — there it is recorded
+without any visualization (RGB video + force/tactile/SLAM columns only), and
+the Linux package ships the ~460 MB gripper payload as a *required* resource
+(`start_lite.sh` verifies 7 items up front and refuses to start with
+`[错误 B]` if any is missing). The Windows package deliberately omits that
+payload, so the gripper group there is always empty. See
+[使用说明_lite.md](使用说明_lite.md).
+
 #### Launch the main program
 
 ```bash
@@ -143,6 +154,7 @@ venv/bin/python tools/hand_detection/demo_stereo_hands.py  # stereo + MediaPipe
 | Intel RealSense D435 / D405 | `pyrealsense2` | RGB + depth dual slots; depth recorded as 12-bit gray HEVC MP4 (log depth codes) + live JET heatmap; built-in stall/framerate watchdog with auto-reconnect; D405 has a dedicated near-range capture profile |
 | S80C / S80M stereo | FaysSense VI Kit SDK (bundled in-repo, incl. FT602 bridge driver) | No SDK install needed; camera profile `STEREO_CAM_FPS` (default 50 fps) decimated to 30 fps recording via wall-clock 1/30 s buckets (burst backfill + empty-bucket watchdog, ~3% empty-bucket rate on healthy recordings); callback frame capture (same as the official GUI); carries hardware nanosecond timestamps and IMU samples; since v1.0.11 the subprocess runs the SDK depth engine → third-tile live depth heatmap + 12-bit gray depth video recording |
 | BLE data gloves | `bleak` | one per hand; parquet column names bound (`right_glove` / `left_glove`) |
+| UMI gripper (Fays S80M) | in-repo native stack (`core/gripper/native/`, ~460 MB, not in git) | Linux only (the native stack is ELF x86-64); up to 2 grippers (second one gets the `gripper_2_*` column prefix); records left-lens RGB video + `observation.gripper_{left,right}_force` / `_force_matrix` (10×10×3 force matrix) + `observation.slam_trajectory` + gripper state, no stereo video / IMU; new grippers auto-generate their per-serial factory calibration on open |
 
 ### Data Formats
 
@@ -319,6 +331,8 @@ file inventory, data flow):
 - [docs/tools.md](docs/tools.md), [docs/demos.md](docs/demos.md) — 3D tools, delivery demos
 - [docs/stereo_s80m.md](docs/stereo_s80m.md), [docs/hand_detection.md](docs/hand_detection.md) — S80M, hand detection
 - [docs/file_format.md](docs/file_format.md) — data file interface contract (authoritative definition of the v1.1.x pooled layout)
+- [使用说明_lite.md](使用说明_lite.md) — Lite edition guide: devices (incl. the UMI gripper), recording, upload, acceptance checklist (Chinese)
+- [使用手册.md](使用手册.md) — full operation manual, Chinese + English
 
 ### Privacy & Local Config
 
@@ -361,6 +375,55 @@ are documented in [docs/index.md](docs/index.md#开发约定).
 
 ### Changelog
 
+- **v1.3.6** — the Lite edition records the UMI gripper, and every SLAM point now
+  carries the host timestamp of the frame it came from.
+  **Lite + gripper:** the Lite edition did not record the gripper at all; that
+  exclusion is now reversed. The whole gripper chain (force, 10×10×3 force
+  matrix, gripper state, SLAM trajectory) is recorded with **no gripper
+  information shown in the UI** — the gripper RGB becomes the main video source
+  directly. The payload is a hard constraint: the Linux package ships the
+  ~460 MB native stack as a *required* resource and `start_lite.sh` verifies 7
+  items up front, refusing to start with `[错误 B]` if any is missing, so an
+  upgrade on an older machine is stopped before it fails halfway; the Windows
+  package deliberately omits that payload (the native stack is ELF x86-64) and
+  its gripper group stays permanently empty. The three distribution shells
+  (`start_lite.bat`, `start_lite.sh`, `使用说明_lite.md`) moved from
+  `lite_package/` to the **repository root** next to `main_lite.py`, so the root
+  is directly runnable; `lite_package/*` is now untracked entirely. Force-matrix
+  encoding moved out of `ui/main_window.py` into the new `core/gripper_codec.py`
+  (re-exported by the UI) — it is a data contract and must not exist twice, and
+  the Lite import blacklist excludes `ui/main_window`, which pulls in the whole
+  main UI. That module may depend only on numpy / `config.settings` /
+  `config.i18n`, never `core.gripper`: `core/gripper/__init__.py` imports
+  `fays_runtime` (top-level `import fcntl`) at import time, and `fcntl` does not
+  exist on Windows.
+  **SLAM host stamps:** each trajectory point's `t` is the camera *sensor* clock
+  while a video row's `hardware_ns` is the *host monotonic* clock — different
+  timebases whose offset can only be fitted (three reverse estimates spread
+  ~104 ms, more than one 33.3 ms frame interval), so aligning SLAM points to
+  video frames 1:1 had been reduced to row-index pairing (median residual
+  83 ms). Native now takes `CLOCK_MONOTONIC` once at the `stereoCallback` entry
+  (before the deep copy — "the frame reached this process", not "processing
+  finished") and carries it through `RawImageFrame` → `PreparedFrame` →
+  `OutputFrame` (the prepared-frame slot is latest-wins, so timestamp and stamp
+  must travel together or they get paired with the wrong frame) out to the
+  `Host:(<ns>)` field on stdout. `protocol.py` parses it as an **optional**
+  group — deployed older binaries do not print it and still parse, with
+  `host_mono_ns = None` — the bridge adds a 5th **object** signal argument
+  (`pyqtSignal(int)` would silently truncate nanoseconds to qint32), and it
+  lands as `observation.{prefix}slam_trajectory_ns` (`list<int64>`, declared
+  `flat_parallel_to_slam_trajectory` / `host_monotonic_ns`), accumulated in
+  lockstep with the point list: one value per point, 0 = unknown, never skipped,
+  and no column at all when a whole segment is unstamped. Verified on real
+  hardware with episode-085/086 (the first two recorded after the deploy; the
+  earlier 128 carry no such column): points = stamps (353/353 and 344/344), zero
+  length mismatches, zero all-zero rows, strictly increasing, stamped range
+  inside the segment's `hardware_ns` range (same timebase) — nearest-neighbour
+  residual median 6.9 ms with **94.6 % / 97.4 % inside half a frame interval**,
+  against 83 ms for row-index pairing. Also adds
+  `tools/dedup_gripper_native.py`, which recovers 339 MB of `.so` files that a
+  ZIP / `cp -rL` transfer had dereferenced from symlinks into full copies (the
+  worst case being one libopenblas stored 7 times in orb48_env).
 - **v1.3.5** — the camera service heals itself, and gripper scan pairing moved
   from USB root ports to NVS serials.
   **Cameras:** the UVC cameras (DECXIN `1bcf:2d4f` plus two Sightac `0c45:636f`)
@@ -721,6 +784,14 @@ start.bat help          打开操作指引与异常排查文档
 > 完整操作指引、错误码对照与内网离线交付方式见 [使用说明.md](使用说明.md) /
 > [使用说明_EN.md](使用说明_EN.md)（离线安装包由 `python scripts/pack_wheels.py` 生成）。
 
+**极简版**（只做连接设备 → 采集 → 上传，无登录/回放/任务页/骨架解算）：
+Windows 双击 **`start_lite.bat`**、Linux 跑 `./start_lite.sh`，用独立环境
+`venv_lite/`（约 750MB）。设备范围同上，**含 UMI 夹爪（仅 Linux）**——夹爪
+**只录不显**（只落 RGB 视频 + 力/触觉/力矩阵/SLAM 轨迹列，界面上不显示），
+且 Linux 包把约 460MB 的夹爪原生载荷当**必需资源**下发（`start_lite.sh`
+启动前逐项校验 7 项，缺了直接报 `[错误 B]` 拒启）；Windows 包有意不带该载荷，
+那边的「UMI 夹爪」组框还在、里面永远是空的。详见 [使用说明_lite.md](使用说明_lite.md)。
+
 #### 启动主程序
 
 ```bash
@@ -758,6 +829,7 @@ venv/bin/python tools/hand_detection/demo_stereo_hands.py  # 双目 + MediaPipe
 | Intel RealSense D435 / D405 | `pyrealsense2` | RGB + depth 双路槽位；深度以 12-bit 灰度 HEVC MP4 录制（对数深度码）+ 实时 JET 热力图；内置停滞/帧率看门狗自动重连；D405 有独立近距采集配置 |
 | S80C / S80M 双目 | FaysSense VI Kit SDK（仓库自带，含 FT602 桥驱动） | 无需安装 SDK；相机档 `STEREO_CAM_FPS`（默认 50fps）按 wall 时钟 1/30s 桶抽帧录制 30fps（突发补录 + 空桶看门狗，健康录制空桶率 ~3%），回调取帧（官方 GUI 同款）；携带硬件纳秒时间戳与 IMU 样本；v1.0.11 起子进程内置 SDK 深度引擎 → 第三格实时深度热力图 + 12-bit 灰度深度视频录制 |
 | BLE 数据手套 | `bleak` | 左右手各一只，parquet 列名绑定（`right_glove` / `left_glove`） |
+| UMI 夹爪（Fays S80M） | 仓库自带原生栈（`core/gripper/native/`，约 460MB，不入库） | 仅 Linux（原生栈是 ELF x86-64）；最多 2 台（第二台的数据列自动加 `gripper_2_*` 前缀）；录左目 RGB 视频 + `observation.gripper_{left,right}_force` / `_force_matrix`（10×10×3 力矩阵）+ `observation.slam_trajectory` + 夹爪状态，不存双目视频/IMU；新夹爪开启时自动生成逐台出厂标定 |
 
 ### 数据格式
 
@@ -922,6 +994,8 @@ venv/bin/python tools/tests/test_device_detector.py
 - [docs/tools.md](docs/tools.md)、[docs/demos.md](docs/demos.md) — 3D 工具、交付 demo
 - [docs/stereo_s80m.md](docs/stereo_s80m.md)、[docs/hand_detection.md](docs/hand_detection.md) — S80M、手部检测
 - [docs/file_format.md](docs/file_format.md) — 数据文件接口契约（v1.1.x 任务池化布局权威定义）
+- [使用说明_lite.md](使用说明_lite.md) — 极简版使用说明：设备（含 UMI 夹爪）、录制、上传、验收清单
+- [使用手册.md](使用手册.md) — 完整操作手册（中文 + English）
 
 ### 隐私与本地配置
 
@@ -955,6 +1029,40 @@ i18n 文案经 `tr()` 翻译、PyQt5 信号参数用 `object` 封送大整数、
 
 ### 更新记录
 
+- **v1.3.6** — 极简版能录 UMI 夹爪了；每个 SLAM 点带上了它那张取样帧的宿主时刻。
+  **极简版 + 夹爪**：极简版此前完全不录夹爪，本次推翻该排除。夹爪整条链（力 /
+  10×10×3 力矩阵 / 夹爪状态 / SLAM 轨迹）全部落盘，但界面**不显示**任何夹爪
+  信息——夹爪 RGB 直接当主视频源用。载荷是硬约束：Linux 包把约 460MB 的原生
+  栈当**必需资源**下发，`start_lite.sh` 启动前逐项校验 7 项，缺任一项报
+  `[错误 B]` 拒启，老机器升级会在跑炸之前就被拦住；Windows 包**有意不带**该
+  载荷（原生栈是 ELF x86-64），那边的夹爪组框永远是空的。三个分发壳
+  （`start_lite.bat`/`start_lite.sh`/`使用说明_lite.md`）从 `lite_package/`
+  搬到**仓库根**、与 `main_lite.py` 同级，根目录直接可运行；`lite_package/*`
+  随之整体不入库。力矩阵编码从 `ui/main_window.py` 搬到新模块
+  `core/gripper_codec.py`（UI 侧 re-export）——它是数据契约，不能在两份界面
+  代码里各存一份，而极简版的导入黑名单不含 `ui/main_window`（它拖进主程序
+  全部 UI）。该模块只许依赖 numpy / `config.settings` / `config.i18n`，绝不
+  可 import `core.gripper`：`core/gripper/__init__.py` 导入期就拉
+  `fays_runtime`（顶层 `import fcntl`），而 fcntl 在 Windows 上不存在。
+  **SLAM 宿主戳**：轨迹每点的 `t` 是**相机传感器钟**，视频行的 `hardware_ns`
+  是**宿主单调钟**，两者不同源、只差一个只能拟合的偏移（三个反推估计散布
+  ~104ms，已超一个 33.3ms 帧间隔），于是把它们 1:1 对齐此前只能退化成按行号
+  配（中位残差 83ms）。现在 native 在 `stereoCallback` 入口取一次
+  `CLOCK_MONOTONIC`（在深拷贝之前——代表「帧到达本进程」而非「处理完」），
+  随帧走完 `RawImageFrame` → `PreparedFrame` → `OutputFrame`（预处理槽是
+  「最新覆盖」，所以时间戳与宿主戳必须同进同出，否则会配错帧），与位姿一起
+  打在 stdout 的 `Host:(<ns>)` 上。`protocol.py` 按**可选**组解析——现场已
+  部署的旧二进制不打印这段、照旧可读，`host_mono_ns = None`；桥接加第 5 个
+  **object** 信号参（`pyqtSignal(int)` 会把纳秒按 qint32 静默截断）；最终落成
+  `observation.{prefix}slam_trajectory_ns`（`list<int64>`，声明
+  `flat_parallel_to_slam_trajectory` / `host_monotonic_ns`），**与点列表锁步**
+  累加：每点恒定一个值、无戳补 0、绝不跳过，整段全无戳则不建列。真机验收
+  （部署后录的 episode-085/086，正是头两段带该列的；此前 128 段都没有）：
+  点数=戳数（353/353、344/344）、零长度不等、零全 0 行、严格递增、戳区间落在
+  该段 `hardware_ns` 区间内（同一时基）——最近邻残差中位 6.9ms、**≤半帧占比
+  94.6% / 97.4%**，而行号配对是中位 83ms。另新增
+  `tools/dedup_gripper_native.py`，回收 339MB 被 ZIP / `cp -rL` 从软链解引用
+  成实体副本的 `.so`（最夸张的是 orb48_env 里同一个 libopenblas 存了 7 份）。
 - **v1.3.5** — 相机服务能自愈了；夹爪扫描配对从 USB 根端口改走 NVS 序列号。
   **相机侧**：UVC 相机（DECXIN `1bcf:2d4f` 与两个 Sightac `0c45:636f`）会**静默
   卡死、且不需要任何进程碰它**——2026-09-15 实证右目 Sightac 是自己夜里坏的

collector/config/__init__.py

@@ -3,4 +3,24 @@
 版本号集中定义于此：settings.APP_VERSION 及其他模块均从这里取值。
 """
 
-__version__ = "1.3.5" # 夹爪扫描配对改走 ESP32 NVS 序列号 + camera-service 自愈（两个都是「不恢复」的毛病，不是「会坏」的毛病）。相机侧：UVC 相机（DECXIN 1bcf:2d4f + 两个 Sightac 0c45:636f）会**静默卡死且不需要任何进程碰它**，用户看到的「RGB 只剩第一帧」「camera-service 未在限定时间取得全部相机的有效 MJPG 帧」根子是**服务不会自愈**——实证 2026-09-15 右目 Sightac 是自己夜里坏的（21:53 还在正常推流，09:24 启动就坏，中间没有任何进程打开过它、内核无 usbfs/uvcvideo 消息，机器整夜没睡、14.9 万条内核日志里查不到肇事者）→ 别再去查「谁把它弄脏的」，服务必须能自愈。两种卡死要分开治：**停摆**（开着流突然不出帧、`received` 冻住、内核一条消息都没有，6~82 秒随机、与负载正相关）**重建 libusb 上下文就够**（实测 6/6、5/5 全恢复，USB 复位是白付的代价）；**开不起来**（`uvc_start_streaming failed: I/O error` / `UVC format/interface negotiation failed: Invalid mode` / `negotiated_payload` 在 3072↔0 之间跳）**重建上下文救不回来**（实测连试 9 次全败，设备固件侧卡死了），只有 USB 复位/重枚举能洗。改动：新增 3 秒停滞看门狗（`STREAM_STALL_TIMEOUT_SECONDS`，首帧 4 秒）——此前整路静默报废没有任何人管；停摆（`rc>0`）走 `uvc_exit`+`uvc_init` 重建上下文；开不起来（`rc<0`）计入 `hard_failures`，**连续 2 次**升级成 USB 复位（`USB_RESET_LIMIT` 3 次封顶——设备真坏了时不设上限会变成每 2 秒复位一次、把同 Hub 的另外两路一直按在地上），而停摆会**清零**该计数，免得几次停摆凑数误触发复位去打扰邻居；**复位要抢在 `uvc_stop_streaming` 之前**（`teardown_failed_open`）——卡死设备上 `uvc_stop_streaming` 会一直等它那批永远回不来的等时传输，实测能把客户端那 2 秒宽限耗光而被 SIGKILL，进程死在这中间、设备就停在激活的 alt setting 上，下一轮启动照样起不来（用户 09:24 的日志正是断在 startup failed 与 usb reset 之间）；所有阈值由客户端窗口倒推（`SERVICE_START_TIMEOUT_S = 10.0`：每次失败约 0.3 秒 + 1 秒间隔，第 2 次失败在 t≈2 秒触发复位、重枚举加重开约 1 秒、t≈3 秒就能出帧，10 秒够用；旧的「重开 20 秒零帧才复位」在真实启动场景**永远够不到**——20 > 10，且只挂在零帧分支上，实测到的 `I/O error` 根本不走那条）；复位语义实测——打在**健康**设备上是原地端口复位（内核 `reset high-speed USB device number N`，**devnum 不变**），打在**卡死**设备上是掉线再重枚举（`USB disconnect` + `new high-speed USB device`，**devnum 变了**）**这才会好**，而 libusb 在掉线重枚举的窗口里返回 `rc=-4 (No such device)` 是**报错但事办了**、别被它误导；`libusb_reset_device` 用 `dlsym(RTLD_DEFAULT, …)` 取，不新增 NEEDED、不需要 root（设备节点 udev MODE=0666）；顺带修每秒 fps 上报基线（`previous_received` 从 0 起算，重开后把进程启动至今的全部帧数当成本窗口增量，算出 164/207/251 的假速率——纯日志问题，但会把人带偏）。真机验证：确定性升级测试（第 1 次失败不复位、第 2 次 `usb reset: rc=0 (Success)`、打满 3 次后停手）、三路 90 秒回归 0 停摆 0 误复位（2694/2683/2684 帧 ≈29.9fps）、SIGTERM 退出 1.16 秒（旧 1.13 秒）不超客户端 2 秒宽限。**源码位置**：`online/` 在 .gitignore:56 里、不入库；本次把这两个程序的源码连同构建配方搬进了 `core/gripper/camera_service_src/`（`./build.sh` 是唯一构建入口——它替我们处理 libusb 的 pkg-config shim、`-DCMAKE_POLICY_VERSION_MINIMUM=3.5`、以及链接后去掉 RUNPATH 里那个空条目，手工 cmake 会在这些地方卡住；产物装到 `core/gripper/native/camera_service/build/`，旧件按 `.pre_rebuild_<时间戳>` 备份），以后不必再从 libusb 头文件、pkg-config、RUNPATH 那一整串摸起。交付副本 `programs/camera_service/src/camera_service.c` 未动、与 `程序清单.txt` 第 18 行一致。**RGB 断联的根因（2026-09-15 查明，本条是用户「还是会断联」的正面回答）：服务自愈之后相机仍会断，断的原因是 DECXIN 跑在高带宽等时档 alt7 上时每 68~116 秒静默停摆一次，两块控制器（AMD `1022:43fc`/PCI `0000:0a:00.0` 与 `1022:15b7`/`0000:74:00.4`）上都一样。机制**未查明**：停摆当时实际吞吐只有 1.66 MB/s（峰值 2.63），离 alt7 预留的 10.24 MB/s 差得远，「带宽不够」解释不通——**别把机制写死**。alt6 同样三路下长跑不停，而两档出帧率一模一样（都 30.00 fps），alt7 多出来的每帧余量（327680 对 241664 字节��换不到任何看得见的好处。此前两个结论已推翻、别再引用：「bus 1 上 alt7 是好的」——那条所谓干净腿根本没跑在 alt7 上，旧二进制里 ini 的 `forced_*` 是死的、服务只把 ini 的值原样打进日志，读到的 `alt=7 payload=1280` 是它在**复读**，**判断一条腿真实档位只认 `[LIBUVC-QUIRK] ... alt=N payload=M ... xfers=` 那一行**；以及同源的「停摆是控制器特异的」。改动：libuvc 新增运行时接口 `uvc_set_altsetting_override()`（声明在 `include/libuvc/libuvc.h`、实现在 `src/device.c`，`uvc_device_handle_t` 是 calloc 出来的、新字段自动零初始化），`forced_altsetting`/`forced_payload` 从此**真正生效**——此前这两个 ini 字段只用于校验和打印，改 ini 完全不改变行为，极容易误判；起始档位由 app 决定、取**档位表里最保守的一档**（`uvc_camera_service.py` 的 `_starting_mode` 优先级：上一轮学到的 > 最后一档 > 扫描程序报的首选档），**不按机器/控制器写死**（机架插在哪条总线不固定，用户明说不是永久的），曾经那张「敌意控制器」表已删；降档梯子 `maybe_downgrade_altsetting`：当前档位连着停摆 2 次、或连着开不起来 3 次（后者覆盖 STREAMON 阶段就排不下带宽、流根本起不来的情形，停摆那条路永远等不到）就退一档并把结论**落盘**（键 = `vid:pid × 控制器 PCI 路径 × 相机序列号`，一个键一个文件，放 `native/gripper_version1/camera_modes/`——**不能放服务的 runtime 目录，那里每次租约释放整个删掉**），稳定跑满 `CLEAN_RUN_SECONDS=300` 清零停摆计数；**降档必须同时清掉两个计数**——门槛是拿 `==` 比的，只清一个的话另一条路降完一档就永远不再命中，表里剩下的档位形同不存在（DECXIN 只有两档，正好把这个缺陷盖住了）；两条路的日志都在调用**之前**抓计数，否则清零后只能打出「0 停摆」，正好把最该看的那次降档说成没有依据；`tools/discover_uvc_config.c` 如实报**相机描述符里的首选档**（alt7），app 拿它跟服务端档位表对一遍、确认这一对是梯子上的任意一档，对不上就报「扫描程序与服务端档位表已经脱节」（那说明两个程序分开编了，必须一起重编）；`./build.sh --test` 从点名跑 `test-frame-integrity` 改成走 `ctest`——`tests/test_altsetting_ladder.c` 虽然在 `CMakeLists.txt` 里注册了 `add_test`，此前却一次也没被执行过，上面那个「降一档就卡死」正好落在它本该覆盖的范围内。真机验证：ini 强制 alt7 → 78 秒停摆 → 116 秒再停 → 服务打出 `2 stalls at alt=7; dropping to alt=6 payload=944` → 重开在 alt6 → 169 秒 30fps 零停摆，整条降档+恢复路径走通；装 app 自己生成的 ini（alt6 默认）跑 **600 秒三路：0 停摆 / 0 重建 / 0 启动失败 / 0 复位**，17513/17496/17487 帧（30.00/30.00/29.80 fps），日志里 `[LIBUVC-QUIRK] … alt=6 payload=944 endpoint=944 xfers=32 (altsetting override)` 证明确实跑在 alt6 上、ini 真的生效了；装机后再做一次 300 秒回归同样全零停摆；装机产物与源码构建逐个 md5 相同、RUNPATH 仍只有 `$ORIGIN/third_party/libuvc`。离线侧新增 `tools/tests/test_camera_altsetting_mode.py`（19 条，覆盖最保守档/学到值优先/表外值忽略/扫描程序与服务端脱节必须先报错，并钉死与 C 测试共用的落盘键串），`test_altsetting_ladder.c` 补上「两个计数都要清零」的断言并**反向验证过不是空跑的**（把清零那行注释掉，该测试当场断言中止）。装机后需重启主程序才能同时拿到新的 `uvc_camera_service.py` 与新服务，否则两边档位要求对不上会像 2026-09-15 09:24 那样整个起不来。扫描侧：移植交付包「设备扫描逻辑与程序_20260914」，夹爪与 UVC/ESP32 的配对从 **USB 根端口/控制器**改走 **NVS 序列号**——旧规则（`_bus_root`/`_root_port`，外加「同一 USB2 总线出现双 rig 就拒扫」）的前提就是错的：Fays 是 USB3/FT602 挂在配套的 5000M 总线上，跟 UVC/ESP32 本来就不共根，只能靠猜。新链路：UVC 组 → 唯一 ESP32（`bus-outer.` 开头）→ 串口发 `QF` 读它 NVS 里绑定的 Fays 序列号 → 与官方 SDK 枚举出的 `device.serial` 比对（`_resolve_fays_group` 三步，任一步不唯一就明确拒绝；`_match_esp` 拒收空序列号，不再按端口或枚举顺序猜）。SDK 探测前先 `validate_fays_superspeed` 预检，再以 `serial_only_fast=True` 快速枚举序列号（`fays_serial_probe.py` 加 `--serial-only-fast`；超时不再只报一句 timeout，解码 stdout/stderr 并附最后 20 行），`_probe_serial` 交叉核对 SDK serial 与 NVS 绑定；双 rig 新增「在用时跳过」——`fays_device_guard(port, timeout=0.0)` 探到另一 rig 正持有该设备就跳过而不是占用。串口侧：`CONNECT_BOOT_DELAY = 2.0` 死等改成 `CONNECT_BOOT_TIMEOUT = 2.0` 轮询 `?` 握手（实际尝试次数按真实值上报，不再报上限），打开加 `exclusive=True`，新增 `query_fays_serial()`/`set_fays_serial()`（`QF` 查询 / `WF:<serial>` 写入，值校验 `[A-Za-z0-9._-]{1,64}`）；顺带修 `GripperSerial.send()` 只拿首字符去查命令表（`[:1]`）——`"QF"` 因此永远匹配不上自己的期望表，改成先查全命令再退回首字符。UVC 发现程序侧：`_native_env(binary)` 改成优先用二进制自带的 `third_party/libuvc`（不再指望环境里恰好有），`_run_discovery` 加互斥的 `--topology-only`/`--identity-only`/`--skip-flash` 三种扫描深度。**前置条件：ESP32 固件必须认识 `QF`/`WF:`，当前 `online/esp32_proc` 的固件还不认识，会失败关闭并报「查询 Fays 序列号失败: ERR」，需先烧固件。** 新增离线自检 `tools/tests/test_gripper_fays_pairing.py`（假串口 + 假桥接 + 假探针，覆盖 QF/WF 往返、ESP 匹配、按序列号解析、整套 acquire、UVC 关联，并核对部署的原生程序确实内嵌了新参数）。s80c 上色工具修隔帧重复（`tools/s80c_arm_convert/convert_arm_dataset.py`，v1.3.4 之后单独提交的补丁）：`pooled_episodes_v1` 这版录制**每帧写两行**（`frame_index` = 0,0,1,1,…，同一帧两行的 `timestamp`/`hardware_ns` 逐值相同）而视频只有一帧，工具把行数当帧数（`n = tbl.num_rows`）、主流程再按视频帧号 1:1 取 `hw_ns[i]`，于是每个时间戳被连送两遍——离线 ISP 对重复时间戳复用上一帧的输出，输出视频就隔帧重复。实测 rec001 无损版 833 帧里 394 帧与前一帧逐字节相同、且 394 个全落在奇数位（每对时间戳的第二个），源视频 0 重复；同一根因还让 IMU 侧车**少一半**（修复前 `hw_ns[:n_frames]` 只够到第 417 个时间戳，其后的 IMU 样本全被「晚于末帧 hw」规则丢掉，输出只剩 416 行 / 13.8 秒，修复后 832 行 / 27.7 秒，与视频时长 27.8 秒对上）。现按 `frame_index` 折叠冗余行，但**只在同一 `frame_index` 名下所有行的 `timestamp` 与 `hardware_ns` 逐值相同时才折**，否则打告警原样不动——全库 142 个带 `frame_index` 的 parquet 里 129 个本就每帧一行（空操作）、1 个真冗余（rec001，1666 行 → 833 帧）、12 个行间时间戳互不相同（折叠会丢时间戳，一律只告警）。上色链路一行未动，同一份 config、同一个离线 ISP、`--sdk-wb-auto` 照旧，灰世界增益与修复前逐位相同。承接 v1.3.4 的新夹爪接入即自动生成运行标定并连接（Fays S80M）：此前接入一只新夹爪要人工两步——先在夹爪上位机点 `device_setup`、再在采集机跑 `tools/import_gripper_calibration.py` 导入，漏掉任一步主程序直接拒绝启动（「当前 Fays 缺少运行标定文件…请先在夹爪上位机中运行 device_setup」）；现在 `SingleFaysLease.acquire()` 发现 per-serial YAML 缺失时，就在设备锁内调厂商导出程序从**这只夹爪自身**读出厂标定、生成 SDK YAML 与 ORB YAML（鱼眼 `stereoRectify` 求 P1/R1 + IMU 外参 `T_b_c1` + 探针读五项噪声/频率），复核落盘路径后直接连上，已有标定走 `isfile` 快路径（启动零额外开销、不碰设备）——这两个文件是**逐设备**出厂标定不可跨设备复用（实测 098/099 三组全不同），只能现场读；设备面板夹爪条目右键加「重新读取出厂标定」（录制中禁用，标定前自动关该夹爪、完成后开回），`tools/import_gripper_calibration.py` 加 `--generate`（旧文件先备份 `.bak_<时间戳>`）供命令行强制重生成；顺带修掉生成产物第 3 行的出处注释——厂商模板写死指向 `3500000261870088`，照抄会让每只新夹爪的 IMU 外参都被记成「取自另一台设备」，现改写成本机序列号（历史产物不动）。承接 v1.3.3 的力矩阵/触觉力与 RGB 视频的时间戳对齐：**力侧此前完全没有时间戳**——同一行里的 RGB 帧和力样本不是同时刻采集的，RGB 走外部帧源队列取队头最旧帧、力/矩阵走 latest-wins 单槽取当下最新，于是「行号相同」≠「时刻相同」，力恒领先 RGB 且领先量随录制时长增长（RGB 源 30.84fps vs 写线程 30fps，实测约 1 帧/秒，下游观测到的滞后 3 帧就是这么来的），力矩阵走独立泵线程还与 3 向量力各记各的时刻。修法是让每行自描述：`tactile_ready` 加第 5 个载荷 `capture_ns`（在 SDK 回调入口取），`pipeline.write_tactile_force/_force_matrix` 落成独立的 `observation.gripper_{side}_force_ns` / `_force_matrix_ns` 稀疏 int64 列（与 `hardware_ns` 同宿主单调钟时基，features 里声明 `encoding: host_monotonic_ns`），下游按时间取最近邻即可还原真实配对，精度上界=半个力样本间隔；顺带修 `rgb_frame_ready`/`stereo_frame_ready` 的 `pyqtSignal(int)` 把 `time.monotonic_ns()` 按 C++ qint32 静默截断成负数（每 2.147s 翻符号），改 `object` 封送——这也解释了此前用 `hardware_ns` 解回卷时凭空造出上百帧假漂移、把"中位 5.8 帧 / 最大 ±80 帧"报成对齐误差（真值是 ~3 帧，正确规则是**无符号**：单调钟 + FIFO 消费 ⇒ 真步长恒非负）；新增 `scripts/align_modalities.py` 处理端最近邻对齐工具，对 v1.3.3 之前录的 episode 明确报「无法对齐（只能重录）」而不用增长率去猜。承接 v1.3.2 的 SLAM 陈旧帧入库前拦截与轨迹显示深拷贝修复。：桥接按「连续回退次数」判定——单帧脏读丢弃、连丢 30 帧才判定时钟真跳变并换基准放行（此前每一帧回退都会让核心库清空 IMU 队并重建地图、位姿停发 0.2–1.34 s，静止时更久），新增 `[TIME_DROP]`/`[TIME_REBASE]` 现场行并**无条件**打进 GUI 日志（此前落进未匹配行被 50 条上限吃掉——实测原生日志 4 次回退、GUI 日志 0 条，真出事时反而看不见），且带 `seq`/`prev_seq` 对比结论以区分「SDK 乱序投递 / 重复投递同一帧 / 帧配了旧时间戳」三种成因（时间戳上三者长得一模一样，对策完全不同）；逐秒遥测 `[FPS_DATA]` 改「只在异常时出声」（健康静默、进入异常与恢复各一行、持续异常每 30 s 重复，全量逐秒流仍在原生日志里），并修 `wait_sdk_ready` 就绪门被**粘滞** `state.error` 锁死——任何信息性输出（如 ld.so 的 `cannot be preloaded ... ignored.`）都会让标定明明已完成的这一次返回 False、报出误导的「未等到 [FAYS-CALIB] 标记」（2026-09-10 18:32 假超时事故，文案白名单 + 去掉粘滞判断双管修）；原生日志在 runtime 目录 `rmtree` 之前留档到 `logs/slam_native/`（保留最近 20 份），修「一次干净退出的会话其原生日志不可恢复」——排查 SLAM 崩溃时唯一的证据曾随目录一起被删；轨迹显示去掉 Qt 主线程上的整条深拷贝（正是这次拷贝让 `_rendered_trajectory is traj` 判等恒为假、每个位姿都在主线程复制随会话线性增长的点列，即「画一段时间后帧率变低」的直接原因），显示上限 400→6000，并以向量化投影 + 一次 `drawPolyline` 绘制，修「十几秒后轨迹显出折角」（降采样按 stride 翻倍使顶点数恒落 [上限/2, 上限]，上限 400 时每段跨 67 ms 且随 stride 每翻一倍继续变粗，观感像 SLAM 出点变慢而数据一直满 30 Hz，是绘制侧丢的）；RGB 外部队列在录制开始/结束/中止三个边界排空，修「上一段残留 + 本段启动窗口累积被写成新视频开头」（实测每段开头约 28 帧与上一段 episode 末帧逐帧匹配，队列满时还占 ~110 MB/槽）；任务进度只上报后端当前任务列表里存在的任务（本地自建任务平台没这个项目，上报必被拒 400），且后端该项目口径为 `"sessions"`（从没收到过任何上报）时首次送本机**全量**当基线——只送增量会把后端计数从 session 数砸成增量本身（现场：3/3/3 的项目再录一条变 1）。承接 v1.3.1 的力矩阵 5 档落盘与 SLAM 停落 slam_pose 列。
+__version__ = "1.3.6"
+
+# v1.3.6 —— 夹爪并入极简版（只录不显）+ SLAM 轨迹点带上取样帧的宿主时刻戳。
+#   1) 极简版新增夹爪：力 / 10×10×3 力矩阵 / 夹爪状态 / SLAM 轨迹照常落盘，界面
+#      不显示任何夹爪信息，夹爪 RGB 直接当主视频源。载荷是硬约束——Linux 包把
+#      ~460MB 原生栈当必需资源下发，start_lite.sh 逐项校验、缺则报 [错误 B] 拒启
+#      （老机器升级会被拦住而不是跑一半才炸）；Windows 包有意不带、靠载荷缺失降级。
+#      力矩阵编码搬到 core/gripper_codec.py（数据契约只此一份，UI 侧 re-export）。
+#   2) SLAM 点新增 observation.{prefix}slam_trajectory_ns：native 在 stereoCallback
+#      入口取一次 CLOCK_MONOTONIC，随帧走到 stdout 的 Host:(<ns>)，与点列表锁步落盘。
+#      真机验收（episode-085/086）：点数=戳数、零全 0 行、最近邻残差中位 6.9ms
+#      （按行号配对为 83ms）。旧 native 二进制不打印该字段，照旧可读。
+#   另回收 native 树 339MB 被解引用成实体副本的 .so（tools/dedup_gripper_native.py）。
+#
+# 历史版本一行一条，完整说明见 README 的「更新记录」：
+#   v1.3.5  相机服务静默卡死自愈；夹爪扫描配对改走 ESP32 NVS 序列号
+#   v1.3.4  新夹爪接入即自动生成运行标定并连接，不再需要人工两步
+#   v1.3.3  力矩阵 / 触觉力与 RGB 视频的时间戳对齐（补 capture_ns 稀疏列）
+#   v1.3.2  SLAM 陈旧帧入库前拦截；轨迹显示去掉主线程深拷贝
+#   v1.3.1  力矩阵落盘规格改 5 档可选，倍率记在每段一份的 meta 行
+#   v1.3.0  UMI 夹爪全链接入（Fays S80M 双目 SLAM 位姿/轨迹 + 触觉力 + RGB）

collector/core/egodata_writer.py

@@ -730,7 +730,13 @@ class EgoDataWriter(QObject):
         for key, value in (gripper or {}).items():
             if value is None:
                 continue
-            if key.endswith("_ns"):
+            if key.endswith("slam_trajectory_ns"):
+                # 与 slam_trajectory 逐点同序并行的宿主时刻（变长 int64
+                # 纳秒）。**必须排在通用 `_ns` 之前**：后者按"每行一个
+                # 标量 int64"落盘，而一行内可以有多达 10 个轨迹点，
+                # 落成标量就只剩一个时刻、与点列表再也对不上。
+                row[f"observation.{key}"] = [int(v) for v in value]
+            elif key.endswith("_ns"):
                 # 采集时刻列（int64 宿主单调钟纳秒，与 hardware_ns 同时基）。
                 # 后缀判定必须排在 _force_matrix/_force 之前：`_force_matrix_ns`
                 # 不以 `_force_matrix` 结尾只是巧合，靠顺序防止以后改后缀踩雷。
@@ -919,7 +925,12 @@ class EgoDataWriter(QObject):
         # 后者类型按本 episode 实际规格：int16 行差分 / float32 原值）
         for key in sorted(self._present_gripper):
             name = f"observation.{key}"
-            if key.endswith("_ns"):
+            if key.endswith("slam_trajectory_ns"):
+                # 逐点宿主时刻，与 slam_trajectory **同序等长**；某帧无
+                # 轨迹点则空列表（与 slam_trajectory 的空列表同步）。
+                cols[name] = pa.array(
+                    [r.get(name, []) for r in rows], pa.list_(pa.int64()))
+            elif key.endswith("_ns"):
                 # 采集时刻（缺失帧填 0 = 未知，与 hardware_ns 的 0 约定一致）
                 cols[name] = pa.array(
                     [int(r.get(name, 0)) for r in rows], pa.int64())
@@ -1055,7 +1066,15 @@ class EgoDataWriter(QObject):
         # 这里不重写一遍以免两处漂移）
         matrix_features = self._force_matrix_features()
         for key in sorted(self._present_gripper):
-            if key.endswith("_ns"):
+            if key.endswith("slam_trajectory_ns"):
+                # 逐点宿主时刻（int64 ns），与 slam_trajectory 同序等长：
+                # shape [1] 指"每个轨迹点 1 个值"，对齐前者的 [8]。
+                # 下游按它与 hardware_ns 直接比较即可配 slam 点↔视频帧。
+                features[f"observation.{key}"] = {
+                    "dtype": "int64", "shape": [1],
+                    "encoding": "flat_parallel_to_slam_trajectory",
+                    "clock": "host_monotonic_ns"}
+            elif key.endswith("_ns"):
                 # 采集时刻：宿主单调钟纳秒，与 hardware_ns 同一时基。
                 # 下游按此把力样本重采样到 RGB 帧时刻（见 docs/data.md）。
                 features[f"observation.{key}"] = {

collector/core/gripper/bridge.py

@@ -183,7 +183,7 @@ class GripperBridge(QObject):
     #   符号，下游拿它做不了任何对齐（且解回卷在 ±2.147s 歧义边界上
     #   猜错会凭空造出上百帧的假漂移）。与 main_window 的
     #   stereo_frame_ready 用 object 同理。
-    pose_ready = pyqtSignal(object, object, object, object)
+    pose_ready = pyqtSignal(object, object, object, object, object)
     # pos(x,y,z), quat(qx,qy,qz,qw), trajectory(位置点不可变元组，新点追加才重建),
     # timestamp(SLAM 秒，与轨迹 txt 第一列同源——轨迹并入 episode parquet 后
     # 每点 8 值 [t,x,y,z,qx,qy,qz,qw] 需要它)
@@ -625,7 +625,12 @@ class GripperBridge(QObject):
                 self._trajectory_points[-TRAJECTORY_POINT_CAP:])
         self._trajectory_cache = tuple(self._trajectory_points)
         self._post("pose", tuple(pose.position), tuple(pose.rotation),
-                   self._trajectory_cache, pose.timestamp)
+                   self._trajectory_cache, pose.timestamp,
+                   # 取样帧的宿主单调钟纳秒（与 hardware_ns 同时基）；旧
+                   # native 二进制不打印 Host 字段 → None，下游按未知处理。
+                   # getattr 而非直接取属性：测试夹具/外部实现可能只有
+                   # pos/quat/ts 三个字段，缺戳不应让整条位姿断流。
+                   getattr(pose, "host_mono_ns", None))
 
     def _on_stereo_packet(
         self, payload, sensor_ts_ns, host_mono_ns, sequence,

collector/core/gripper/slam/protocol.py

@@ -78,6 +78,9 @@ POSE_MAX_ANGULAR_SPEED_RAD_S = math.radians(1080.0)
 _POSE_RE = re.compile(
     r"\[([\d.]+)\]\s*XYZ:\(([-\d.e+]+),([-\d.e+]+),([-\d.e+]+)\)\s*"
     r"Quat:\(w=([-\d.e+]+),x=([-\d.e+]+),y=([-\d.e+]+),z=([-\d.e+]+)\)"
+    # 取样帧的宿主单调钟纳秒（native 打印的 Host:(<ns)>）。**可选**：
+    # 现场已部署的旧 native 二进制不打印这段，缺省即 None，老数据照旧可读。
+    r"(?:\s+Host:\((\d+)\))?"
 )
 _FPS_RE = re.compile(
     r"^\[FPS_DATA\]\s+image=([\d.]+)\s+imu=([\d.]+)\s+"
@@ -115,6 +118,13 @@ class PoseSample:
     sequence: int = 0
     arrival_monotonic: object = None
     arrival_wall_time: object = None
+    # 该取样帧进入 native 进程时的宿主单调钟纳秒（CLOCK_MONOTONIC），与
+    # 主程序侧 `hardware_ns` / `time.monotonic_ns()` **同一时基**。
+    # `timestamp` 是相机传感器钟，与宿主钟不同源：两者只差一个近似常量
+    # 但带抖动的偏移，只能拟合不能换算（实测 offset 反推值散布 ~104ms，
+    # 已超一个帧间隔）。有本字段才能把 slam 点与视频帧按时间直接对齐。
+    # None = 无戳（旧 native 二进制），下游按"未知"处理、退回行号配对。
+    host_mono_ns: object = None
 
     @property
     def valid(self):
@@ -125,6 +135,7 @@ class PoseSample:
         arrival_values = (
             self.arrival_monotonic,
             self.arrival_wall_time,
+            self.host_mono_ns,
         )
         return (
             math.isfinite(self.timestamp)
@@ -354,12 +365,16 @@ def _parse_pose(line):
         qw, qx, qy, qz = (
             float(match.group(index)) for index in range(5, 9)
         )
+        # 组 9 = Host:(<ns>)，旧二进制的位姿行没这段 → None
+        host_group = match.group(9)
+        host_mono_ns = int(host_group) if host_group is not None else None
     except (TypeError, ValueError, OverflowError):
         return None
     return PoseSample(
         position=(x, y, z),
         rotation=(qx, qy, qz, qw),
         timestamp=timestamp,
+        host_mono_ns=host_mono_ns,
     )
 
 
@@ -390,6 +405,9 @@ def rotate_pose_z90(pose):
         rotation=(c * (qx - qy), c * (qy + qx), c * (qz + qw),
                   c * (qw - qz)),
         timestamp=pose.timestamp,
+        # 纯世界重标，不动时基：宿主戳原样透传（丢了它位姿就退回
+        # "只能按行号/相机钟对齐"的状态，落盘侧拿不到真实取样时刻）
+        host_mono_ns=pose.host_mono_ns,
     )
 
 

collector/core/gripper_codec.py

@@ -0,0 +1,91 @@
+"""夹爪触觉力矩阵编码 —— 落盘契约的中立家。
+
+从 ui/main_window.py 搬来（2026-09-16），原因：极简版（lite）也要录夹爪，
+但 lite 的导入黑名单不含 ui/main_window（它拖进主程序全部 UI 与重依赖），
+而力矩阵编码是**数据契约**，绝不能在两份界面代码里各存一份。
+
+命名镜像既有的 core/depth_codec.py（同为「算法在家、UI 只管显示」的分工）。
+
+★ 本模块**只能**依赖 numpy / config.settings / config.i18n。
+  绝不可 import core.gripper —— core/gripper/__init__.py 在导入期就会拉
+  fays_runtime（顶层 `import fcntl`），而 fcntl 在 Windows 上不存在，
+  一旦引入，主程序 `import ui.main_window` 会在 Windows 上直接崩
+  （ui/main_window.py 从这里 re-export 这两个函数）。
+"""
+
+from __future__ import annotations
+
+import numpy as np
+
+from config import settings
+from config.i18n import tr
+
+
+def encode_gripper_force_matrix(m: np.ndarray, spec: str = "int16") -> list:
+    """触觉力矩阵编码（P4 泵线程，返回扁平数值列表）。
+
+    spec 取 settings.GRIPPER_FORCE_MATRIX_SPECS 之一。
+
+    **注意**：省略 spec 时走的是函数签名默认 "int16"（兼容历史调用的冻结
+    契约），**不跟随工具栏的默认档**；生产路径（P4 泵）一律显式传入录制
+    开始时锁定的 spec，绝不省略。
+
+    "int16"（既有契约）：不缩放，与
+      online/recording/lerobot_v3.quantize_force_matrix 一致的有符号补码行
+      差分（mod 2^16 可逆），扩展到 (250,250,3) 三力平面：每行 250×3 个
+      元素横向差分；超出 ±32767 mN 饱和截断。**逐点 astype(int16) 是向零
+      截断，小数部分全部丢失**——实测真实录制里逐点值只剩 -3…8 的整数电平，
+      亚毫牛梯度（接触形状）不可恢复。保留向零截断是为了与历史录制逐位一致。
+
+    "int16xN"（N=10/100/1000，定标量化）：先 ×N 再四舍五入到整数存 int16，
+      解码端除以 N 还原，分辨率 1/N mN。饱和上限相应变为 ±32767/N mN
+      （×1000 即 ±32.767 mN）。定标档用 rint 而非截断：没有历史包袱，且
+      四舍五入把最大误差减半、不留系统性偏零。行差分与 int16 档完全相同，
+      所以仍然压得很小（×10 实测 0.122 字节/点，float32 的 1/6.5）。
+
+    "float32"（原值直存）：不做任何量化，把 (250,250,3) 按行展平成 250×750
+      的 float32 列表。无截断、无饱和，误差为 float32 本身的 ~1e-7 相对精度。
+      体积换精度：实测 0.797 字节/点（本段数据约为 int16 档的 119 倍）。
+
+    反解：整数档 reshape(-1,750) → cumsum(axis=1) → reshape(250,250,3)
+          （cumsum 走 int32 再截断回 int16 恢复 mod 2^16 回绕），
+          再按倍率 ÷N；float32 档 reshape(-1,750) → (250,250,3)。
+
+    ★ 返回的 Python 元素类型只区分「家族」：int = int16 系（**倍率无法从
+      元素类型看出**，×10 和 ×1000 都是 int），float = float32。
+      倍率必须由 info.json features.scale 携带，writer 与 demo 都按
+      scale + 列类型共同判别，不要只看元素类型。
+    """
+    if spec not in settings.GRIPPER_FORCE_MATRIX_SPECS:
+        raise ValueError(f"未知力矩阵规格 {spec!r}")
+    arr = np.asarray(m, dtype=np.float32)
+    if spec == "float32":
+        # 与整数档同为「扁平 250×750 列表」，只有元素类型不同：
+        # 读取端统一 reshape(-1,750) 后再按 dtype 决定是否 cumsum
+        return arr.reshape(-1).tolist()
+    scale = settings.GRIPPER_FORCE_MATRIX_SCALES[spec]
+    rows = int(arr.shape[0])
+    flat = arr.reshape(rows, -1)
+    if scale == 1:
+        q = np.clip(flat, -32767.0, 32767.0).astype(np.int16)
+    else:
+        # rint 后已是整数值，astype 的向零截断不再丢任何东西
+        q = np.clip(np.rint(flat * np.float32(scale)),
+                    -32767.0, 32767.0).astype(np.int16)
+    d = np.empty_like(q)
+    d[:, 0] = q[:, 0]
+    d[:, 1:] = q[:, 1:] - q[:, :-1]   # int16 mod 2^16 回绕
+    return np.frombuffer(d.tobytes(), dtype=np.int16).tolist()
+
+
+def describe_gripper_matrix_spec(spec: str) -> str:
+    """规格 → 人话（工具栏提示与日志共用，别在两处各写一份）。"""
+    if spec not in settings.GRIPPER_FORCE_MATRIX_SPECS:
+        return tr("未知规格 {}", spec)
+    scale = settings.GRIPPER_FORCE_MATRIX_SCALES.get(spec)
+    if scale is None:
+        return tr("float32 原值直存（无截断无饱和，体积最大）")
+    if scale == 1:
+        return tr("int16 行差分量化（1 mN 台阶、向零截断，体积最小）")
+    return tr("int16 定标 ×{}（分辨率 {} mN，饱和上限 ±{} mN）",
+              scale, 1.0 / scale, 32767.0 / scale)

collector/core/pipeline.py

@@ -166,6 +166,11 @@ class CameraPipeline(QObject):
         # SLAM 轨迹点按帧窗口累积（每点 8 值 [t,x,y,z,qx,qy,qz,qw] 扁平），
         # 行写入时并入 snapshot——轨迹 txt 侧车由此废弃（并入 episode parquet）
         self._gripper_traj: Dict[str, list] = {}
+        # 与 _gripper_traj 逐点同序并行的宿主时刻（int64 纳秒）。**必须与
+        # 点列表锁步**：每点恒定追加一个值，无戳时补 0（= 未知，与
+        # hardware_ns / *_force_ns 的 0 约定一致），这样两列长度恒相等、
+        # 下标即配对。缺戳的点若跳过不追加，两列就会错位且无法察觉。
+        self._gripper_traj_ns: Dict[str, list] = {}
         # 夹爪非视频槽设备 ID（pose/force 槽不走 register_external_source，
         # 单独进 status 列）
         self._gripper_device_ids: set = set()
@@ -589,6 +594,7 @@ class CameraPipeline(QObject):
         with self._gripper_snapshots_lock:
             self._gripper_snapshots.clear()
             self._gripper_traj.clear()
+            self._gripper_traj_ns.clear()
 
         # B+ 方案: 启动独立写入线程（精确 30fps，完全不受主线程 UI 影响）
         self._write_thread = threading.Thread(
@@ -836,7 +842,8 @@ class CameraPipeline(QObject):
         with self._gripper_snapshots_lock:
             self._gripper_snapshots[key] = value
 
-    def write_slam_trajectory(self, pose7, prefix: str = "", timestamp=None):
+    def write_slam_trajectory(self, pose7, prefix: str = "", timestamp=None,
+                              host_ns=None):
         """SLAM 轨迹点 [t,x,y,z,qx,qy,qz,qw] 累积（P3；桥接 pose_ready 回调）。
 
         prefix 为双夹爪命名空间：rig1 空串（旧键 slam_trajectory 不变），
@@ -847,6 +854,13 @@ class CameraPipeline(QObject):
         缺位姿的行会被填成 [0]*7 被下游当真实位姿读；轨迹点带真实时间戳、
         信息严格更多，是 SLAM 位姿的唯一落盘形态。轨迹不再单独落 txt
         侧车，全部信息都在一条 episode parquet 里。
+
+        host_ns：该取样帧的宿主单调钟纳秒（native 侧 CLOCK_MONOTONIC，
+        与 `hardware_ns` 同时基），逐点并行落成
+        `{prefix}slam_trajectory_ns`。**t 与 host_ns 不同源**：t 是相机
+        传感器钟，换算到宿主钟要一个只能拟合的偏移（实测三个反推估计
+        散布 287607.586/.637/.690，跨度 ~104ms，已超一个帧间隔），所以
+        没有 host_ns 就只能靠行号配 slam 点与视频帧。0/None = 无戳。
         """
         if pose7 is None:
             return
@@ -860,11 +874,21 @@ class CameraPipeline(QObject):
                 return
             if not np.isfinite(t):
                 return
+            try:
+                host_value = int(host_ns) if host_ns is not None else 0
+            except (TypeError, ValueError, OverflowError):
+                host_value = 0
+            if host_value < 0:
+                host_value = 0
             with self._gripper_snapshots_lock:
                 if self._writer is None or not self._recording:
                     return
-                self._gripper_traj.setdefault(
-                    f"{prefix}slam_trajectory", []).extend([t, *values])
+                key = f"{prefix}slam_trajectory"
+                self._gripper_traj.setdefault(key, []).extend([t, *values])
+                # 与点列表**锁步**：每点恒定追加一个值（无戳补 0），
+                # 两列长度恒等、下标即配对。缺戳就跳过不追加会让两列
+                # 错位且下游无从察觉。
+                self._gripper_traj_ns.setdefault(key, []).append(host_value)
 
     def write_gripper_state(self, state3, prefix: str = ""):
         """夹爪状态快照 [open_pct, gripped, fz_mn]（P4；GripState 输出）。"""
@@ -934,7 +958,8 @@ class CameraPipeline(QObject):
         """取走并清空本帧窗口内的夹爪快照（写入线程调用）。
 
         轨迹点在此并入：{prefix}slam_trajectory = 本窗口内全部点的
-        扁平 8 值列表（无点则不写键）。
+        扁平 8 值列表（无点则不写键）；其宿主时刻同序并行落
+        {prefix}slam_trajectory_ns（int64 纳秒，逐点对齐）。
         """
         with self._gripper_snapshots_lock:
             snapshot = dict(self._gripper_snapshots)
@@ -942,7 +967,15 @@ class CameraPipeline(QObject):
             for key, points in self._gripper_traj.items():
                 if points:
                     snapshot[key] = points
+                    stamps = self._gripper_traj_ns.get(key) or []
+                    # 长度必须是点数（点=8 值）。全 0 表示本段所有点都
+                    # 没戳（旧 native 二进制不打印 Host 字段）——此时
+                    # 不建列，免得下游拿到一列「看着有、其实全未知」的
+                    # 时刻而误以为可对齐。
+                    if len(stamps) == len(points) // 8 and any(stamps):
+                        snapshot[f"{key}_ns"] = stamps
             self._gripper_traj.clear()
+            self._gripper_traj_ns.clear()
         return snapshot
 
     def _pop_glove_keypoints(self) -> Dict[str, np.ndarray]:

collector/docs/data.md

@@ -302,6 +302,7 @@ data/recordings/                          # 录制根目录（settings.RECORDING
 | `observation.gripper_{left,right}_force_matrix` | list<int16> / list<float32> | 250×250×3 力矩阵（档位见下） |
 | `observation.gripper_{left,right}_force_matrix_ns` | int64 | 该力矩阵样本的采集时刻 |
 | `observation.slam_trajectory` | list<double> | 轨迹点 `[t,x,y,z,qx,qy,qz,qw]`×N，变长 |
+| `observation.slam_trajectory_ns` | list<int64> | 每个轨迹点对应取样帧的**宿主时刻**，与 `slam_trajectory` 同序等长 |
 | `observation.gripper_state` | list<float32, 3> | `[open_pct, gripped, fz_mn]` |
 
 力矩阵档位记在**每段一份**的 `meta/episodes` 行（`force_matrix_specs` 列），
@@ -337,6 +338,42 @@ mapping, residual_ns = align_episode("episode-000.parquet", side="left")
   的 `hardware_ns` 还被 `pyqtSignal(int)` 截成 32 位（每 2.147 s 翻符号）。
   脚本对这类 episode 明确报「无法对齐」而不是拿行号或增长率去猜。
 
+### 4.5.2 SLAM 点与视频帧的时间对齐
+
+`slam_trajectory` 每点的第 0 个字段 `t` 是**相机传感器钟**上的时间（native
+侧 `img->timestamp`，相对按下 ENTER 设原点那一刻）。它与 RGB 帧的
+`hardware_ns`（宿主单调钟）**不同源**，两者之间只差一个近似常量但带抖动的
+偏移——只能从数据反推、不能换算。实测同一段数据反推出的偏移有三个估计值
+（`arrival_monotonic − t` 中位、行桶中位、逐点拟合最优），散布约 **104 ms**，
+已超一个帧间隔（33.3 ms）。
+
+因此 v1.3.6 起 native 在每个取样帧进进程时取一次 `CLOCK_MONOTONIC`
+（`RawImageFrame.host_mono_ns`），随帧走完预处理/跟踪/排队全程，最终与位姿
+一起打在 stdout 的 `Host:(<ns>)` 字段上，落成
+`observation.{prefix}slam_trajectory_ns`。
+
+> **改这段 native 代码要认准文件**：构建源是
+> `online/ORB-SLAM/Examples/fays/fayssense_orb_slam.cc`（由
+> `online/dist/fays_opencv48/CMakeLists.txt` 的 `FAYS_BRIDGE_SOURCE` 硬指向）。
+> `core/gripper/native/ORB-SLAM/Examples/fays/` 下那份是**陈旧副本，不是构建源**，
+> 改它不会进二进制——且它缺少 2026-09-11 部署的崩溃修复。两棵树都被
+> `.gitignore`（`online/` 第 58 行、`core/gripper/native/` 第 62 行），桥接源码
+> 没有版本控制兜底，改完必须重编二进制才会生效。
+
+- **与 `slam_trajectory` 同序等长**，下标即配对，所以某帧有 N 个轨迹点就有 N
+  个时刻。这要求时刻列表**锁步**累积：某个点没有戳时补 `0`（= 未知，与
+  `*_force_ns` 的约定一致）而**不是跳过**，跳过会让后续点全部错位且无从察觉。
+- 有了它，配 slam 点↔视频帧退化成一次 `searchsorted`：按 `hardware_ns` 找
+  最近的 `slam_trajectory_ns`。**不需要拟合偏移，更不需要插值**——从实测点里
+  取最近邻是合法的 1:1，不是造假数据。
+- **全段无戳时不建该列**（例如 Python 侧已升级但 native 二进制未重编）。
+  下游按列是否存在判断「本段能否按时间对齐」；列存在但个别值为 0 表示那
+  一个点缺戳。
+- **行数不等于点数。** 写线程在落后超过一帧时会重置时钟并**跳过**那些 tick
+  （`core/pipeline.py` 的 `_write_loop`），实测一段 11.4 s 的录制因此少写
+  11 行；slam 点侧则约丢 0.22%。所以「slam 点数 == 视频帧数」不成立，
+  按时间戳配对后剩下未配对的点/帧是正常现象，不是数据损坏。
+
 ### 4.6 `meta/info.json` 字段概览（LeRobot v3 兼容，上传服务器严格依赖）
 
 | 键 | 含义 |

collector/scripts/pack_lite.py

@@ -1,28 +1,42 @@
 """极简采集版发布包收集脚本 —— 把 lite 运行时闭包收集到一个目录。
 
-只收集 start_lite.bat 真正需要的最小集合（约 1.5 MB 代码），
-不拷贝 venv/venv_lite/data/wheels（--with-wheels 除外）、tools 下的
-demo/其它测试、stouch_glove_toolkit-*/ 等与 lite 无关的内容。
+只收集 start_lite.bat 真正需要的最小集合（约 1.6 MB 代码）与夹爪原生
+载荷（Linux 包，约 440 MB），不拷贝 venv/venv_lite/data/wheels
+（--with-wheels 除外）、tools 下的 demo/其它测试、
+stouch_glove_toolkit-*/ 等与 lite 无关的内容。
 
-代码文件以仓库根为源；start_lite.bat/.sh 与 使用说明_lite.md 是分发壳，
-只住在 lite_package/（主目录不放），收集时从那里原样复制。
+代码文件以仓库根为源；start_lite.bat/.sh 与 使用说明_lite.md 是分发壳。
+2026-09-16 起三个分发壳全部住在**仓库根**（与 main_lite.py、
+requirements-lite.txt 同级 —— 这几个齐了根目录本身就是可直接运行的 lite
+部署目录，根上已有 venv_lite/），由 _dist_shell_source 优先从那里取，
+复制进包目录。
 
 --force 只重建代码部分（main_lite/requirements-lite/config/core/ui/tools），
-venv_lite/、wheels/、data/ 与分发壳原样保留 —— lite_package 可同时当
-"发布模板"和"本机测试部署目录"用（在包内跑过 start_lite.sh 装的环境
-不会被冲掉）。
+venv_lite/、wheels/、data/、分发壳与 core/gripper/native（470MB 载荷）
+原样保留 —— lite_package 可同时当"发布模板"和"本机测试部署目录"用
+（在包内跑过 start_lite.sh 装的环境不会被冲掉）。
 
-收集完成后自动做导入自检：在目标目录内 `import main_lite`，
-缺任何被闭包引用的模块都会当场报错（与 start_lite.bat 的错误 E 同口径）。
+收集完成后自动做导入自检：在目标目录内 `import main_lite`，缺任何被闭包
+引用的模块都会当场报错（与 start_lite.bat 的错误 E 同口径）；Linux 包再
+断言夹爪闭包（`core.gripper.bridge`）与 `gripper_resources_available()`。
+
+两个目标平台收的**夹爪 Python 代码是同一份**（core/gripper/**、core/
+gripper_codec.py、core/s80m_manager.py），差别只在平台绑定件：Windows 包
+不收 core/gripper/native/（ELF 原生栈）与 core/gripper/sightac_sdk/（pyarmor
+.so 与 libSonixCamera.so 也是 ELF），并硬断言包内零 ELF。缺这些时
+gripper_resources_available() 为假 → 扫描不到夹爪（设备组框还在、里面是
+空的，属预期降级）。于是
+「Windows 包」≡「Linux 包去掉载荷」，后者在 Linux 开发机上可直接造出来验证。
 
 闭包清单与 tools/tests/lite_import_guard_test.py 的 WHITELIST 一致，
 外加 egodata_writer/d435_camera 实际 import 的 core.calibration。
 
 用法:
-    python scripts/pack_lite.py                收集到 lite_package/
+    python scripts/pack_lite.py                收集到 lite_package/（本机平台）
+    python scripts/pack_lite.py --target windows   收集 Windows 包（代码同源，不含平台绑定件）
     python scripts/pack_lite.py --out D:/lite  指定目录
     python scripts/pack_lite.py --with-wheels  连同 wheels/ 离线依赖包一起
-    python scripts/pack_lite.py --force        重建代码部分（保留环境）
+    python scripts/pack_lite.py --force        重建代码部分（保留环境与载荷）
 """
 import argparse
 import os
@@ -32,7 +46,7 @@ import sys
 
 ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
 
-# 分发壳的常驻目录（start_lite.bat/.sh、使用说明_lite.md 只住在这里）
+# 分发壳的兜底目录（三个壳 2026-09-16 都搬到仓库根了，这里只作回落）
 DIST_SOURCE = os.path.join(ROOT, "lite_package")
 
 # 代码文件（仓库根为源，收集时拷入包目录）
@@ -41,17 +55,82 @@ CODE_FILES = [
     "requirements-lite.txt",
 ]
 
-# 分发壳文件（从 DIST_SOURCE 原样复制，主目录不放）
+# 分发壳文件（仓库根优先，找不到再回落 lite_package/；均原样复制）
 DIST_FILES = [
     "start_lite.bat",
     "start_lite.sh",
     "使用说明_lite.md",
 ]
 
-# 整目录拷贝（core.glove_usb 是包，内部有 __init__.py 与互引模块）
-WHOLE_DIRS = [
-    "core/glove_usb",
-]
+
+def _dist_shell_source(rel: str):
+    """分发壳的源路径：仓库根优先，其次 lite_package/；都没有返回 None。
+
+    三个壳 2026-09-16 都搬到了仓库根（与 main_lite.py 同级，使根目录直接
+    可运行）；lite_package/ 只作回落，服务老布局的目录。
+    """
+    for base in (ROOT, DIST_SOURCE):
+        path = os.path.join(base, rel)
+        if os.path.isfile(path):
+            return path
+    return None
+
+
+# 夹爪载荷：Linux 包整目录收集，Windows 包只收代码（见 _PLATFORM_BOUND）。
+GRIPPER_REL = "core/gripper"
+GRIPPER_PAYLOAD_REL = "core/gripper/native"      # --force 时原��保留
+
+# 与平台绑定的原生件：Windows 包一律不收。
+#   native/       —— 整套 ELF x86-64 原生栈（460MB）
+#   sightac_sdk/  —— pyarmor 运行时 .so 与 libSonixCamera.so 同样是 ELF
+# 缺它们时 paths.gripper_resources_available() 为假 → 扫描不到夹爪（设备组
+# 框照建、里面空着），
+# 且 core/gripper/*.py 在 Windows 上因顶层 `import fcntl` 本就导入不了
+# （双重保险）。**Python 代码两个包都收**：一份源码两个包，差异只在载荷，
+# 于是「Windows 包」= 「Linux 包去掉载荷」，这种形态在 Linux 开发机上可以
+# 直接造出来验证（mv 走 native/ 即可），不必真去 Windows 上撞。
+_PLATFORM_BOUND_NAMES = ("native", "sightac_sdk")
+
+# 载荷里可以剪掉的（≈33MB）：备份二进制、静态库、缓存。
+# ★ 绝不能粗剪：native/ORB-SLAM 必须留着 —— 桥接二进制的 RUNPATH 里有
+#   $ORIGIN/../../../ORB-SLAM/Thirdparty/{DBoW2,g2o}/lib（实测 readelf），
+#   剪掉会让 libDBoW2/libg2o 在客户机上找不到；ORBvoc.txt（139MB）与
+#   FaysSense_VI_Kit_Release/ 同理全是运行时资产。
+_PAYLOAD_SKIP_SUFFIX = (".pyc", ".a")
+_PAYLOAD_SKIP_INFIX = (".pre_", ".bak_")     # 现场备份：xxx.pre_rebuild_2026...
+_PAYLOAD_SKIP_NAMES = ("__pycache__", "camera_service_src")
+
+
+def _gripper_ignore_factory(src_root: str, windows: bool,
+                            keep_existing_native: bool):
+    """core/gripper 整目录收集的排除表（见上方注释）。
+
+    windows: 连平台绑定件一起排（Windows 包）
+    keep_existing_native: 目标包已有 native/（--force 重打包）时整棵跳过 ——
+        copytree 遇到已存在的同名软链会直接抛 File exists（symlinks=True 下
+        的 os.symlink 不覆盖），实测第二次打包必炸。
+    """
+    def _ignore(dir_path: str, names: list):
+        ignored = set()
+        for name in names:
+            if name in _PAYLOAD_SKIP_NAMES:
+                ignored.add(name)
+            elif name.endswith(_PAYLOAD_SKIP_SUFFIX) or any(
+                    s in name for s in _PAYLOAD_SKIP_INFIX):
+                ignored.add(name)
+        if os.path.abspath(dir_path) == os.path.abspath(src_root):
+            if windows:
+                ignored.update(_PLATFORM_BOUND_NAMES)
+            if keep_existing_native and not windows:
+                ignored.add("native")
+        return ignored
+    return _ignore
+
+
+# 整目录拷贝（core.glove_usb 是包，内部有 __init__.py 与互引模块）。
+# core.gripper 的排除表按目标平台现算（见 _gripper_ignore_factory），
+# 且必须 symlinks=True —— 载荷里有 76 个相对软链，展开会让体积 468MB→800MB。
+WHOLE_DIRS = ["core/glove_usb", GRIPPER_REL]
 
 # 单文件拷贝：目录 → 文件列表（只收 lite 闭包，主程序 UI/重依赖模块不带）
 MODULE_FILES = {
@@ -66,6 +145,11 @@ MODULE_FILES = {
         "api_client.py", "database.py", "helpers.py",
         # egodata_writer.py:41 / d435_camera.py:447 实际 import
         "calibration.py",
+        # 夹爪闭包（2026-09-16 并入 lite）：力矩阵编码的家（主程序
+        # ui.main_window 只是 re-export —— 契约不能存两份）
+        "gripper_codec.py",
+        # core/gripper/bridge.py:39 顶层 import 它的双目丢帧窗口常量
+        "s80m_manager.py",
     ],
 }
 
@@ -73,26 +157,228 @@ MODULE_FILES = {
 SELFTEST_FILES = [
     "tools/tests/lite_import_guard_test.py",
     "tools/tests/lite_smoke_test.py",
+    "tools/tests/lite_gripper_smoke_test.py",
 ]
 
+# 随包工具：只有 Linux 包带 —— 它要驱动 native/ 里的厂商二进制，
+# 在 Windows 上无处落脚。夹爪的「重新读取出厂标定」在 lite 里**不做 UI**，
+# 命令行就是唯一入口，所以这个工具必须在包里，否则那条路在纯 lite 机器上
+# 走不通（它顶层只 import stdlib + core.gripper.*，venv_lite 的依赖足够）。
+TOOL_FILES_LINUX = [
+    "tools/import_gripper_calibration.py",
+]
 
-def collect(out_dir: str, with_wheels: bool, force: bool) -> None:
+
+def _force_remove(path: str, keep: str) -> None:
+    """删除 path；但 keep 那棵树（连同其本身）一个字节都不动。"""
+    path, keep = os.path.abspath(path), os.path.abspath(keep)
+    if path == keep:
+        return                       # 保留整棵树（夹爪载荷）
+    if keep.startswith(path + os.sep):
+        if os.path.isdir(path):      # path 是 keep 的祖先：只删其它子项
+            for name in os.listdir(path):
+                _force_remove(os.path.join(path, name), keep)
+        return
+    if os.path.isdir(path):
+        shutil.rmtree(path, ignore_errors=True)
+    elif os.path.isfile(path):
+        os.remove(path)
+
+
+def _tree_size(path: str) -> int:
+    """目录的字节数（不跟随软链 —— 与分发后的实际落盘一致）。"""
+    total = 0
+    for dir_path, _, files in os.walk(path):
+        for name in files:
+            full = os.path.join(dir_path, name)
+            if not os.path.islink(full):
+                try:
+                    total += os.path.getsize(full)
+                except OSError:
+                    pass
+    return total
+
+
+def _count_symlinks(path: str) -> int:
+    count = 0
+    for dir_path, _, files in os.walk(path):
+        for name in files:
+            if os.path.islink(os.path.join(dir_path, name)):
+                count += 1
+    return count
+
+
+def _count_py(path: str) -> int:
+    """**.py 个数（不跟随软链、不计 __pycache__）—— Windows 包「同一份源码」
+    的量化证据：与 Linux 包只差 sightac_sdk/ 里那 7 个包壳文件。"""
+    count = 0
+    for dir_path, dirs, files in os.walk(path):
+        dirs[:] = [d for d in dirs if d != "__pycache__"]
+        count += sum(1 for n in files
+                     if n.endswith(".py")
+                     and not os.path.islink(os.path.join(dir_path, n)))
+    return count
+
+
+def _find_elf(root: str) -> list:
+    """root 下所有 ELF 文件（前 4 字节 \\x7fELF）的相对路径。
+
+    Windows 包的硬不变量就是「一个 ELF 都没有」—— native/ 与 sightac_sdk/
+    里的 .so 都是 Linux 二进制，带上去了在客户机上只会以各种奇怪方式失败。
+    """
+    found = []
+    for dir_path, _, files in os.walk(root):
+        for name in files:
+            full = os.path.join(dir_path, name)
+            if os.path.islink(full):
+                continue
+            try:
+                with open(full, "rb") as fh:
+                    if fh.read(4) == b"\x7fELF":
+                        found.append(os.path.relpath(full, root))
+            except OSError:
+                continue
+    return sorted(found)
+
+
+def _load_paths_module():
+    """独立加载 core/gripper/paths.py —— 故意**不经** core.gripper/__init__。
+
+    两个原因：① Windows 上 `import core.gripper` 会因顶层 `import fcntl`
+       直接失败，而打 Windows 包时本脚本仍要用它核对资源清单；
+    ② __init__ 有导入期猴补丁，不必让打包进程沾上。
+    paths.py 顶层只 import os，独立加载是安全的。
+    """
+    import importlib.util
+    path = os.path.join(ROOT, "core", "gripper", "paths.py")
+    spec = importlib.util.spec_from_file_location("_pack_lite_paths", path)
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    return module
+
+
+def _assert_shell_matches_paths() -> None:
+    """start_lite.sh 的 [错误 B] 资源清单必须与 paths.required_resources() 一致。
+
+    部署脚本那时还没装 venv、不能 import，只能把 7 条路径抄成 shell 字面量；
+    这个断言把「改了 paths.py 却忘了改脚本」（→ 客户机上缺资源却照常启动、
+    夹爪静默不可见）变成**打包当场失败**。
+    """
+    shell_path = _dist_shell_source("start_lite.sh")
+    if shell_path is None:
+        print("[警告] 找不到 start_lite.sh，跳过 [错误 B] 清单核对")
+        return
+    text = open(shell_path, encoding="utf-8").read()
+    # 脚本里路径写的是变量（$GRIPPER_NATIVE 等，为的是认 KSQ_* 环境变量）；
+    # 未设环境变量时它们就取默认值，先把默认值代回去再比字面量
+    normalized = (text
+                  .replace("$GRIPPER_NATIVE", "core/gripper/native")
+                  .replace("$GRIPPER_SIGHTAC", "core/gripper/sightac_sdk"))
+    required = _load_paths_module().required_resources()
+    missing = [os.path.relpath(p, ROOT).replace(os.sep, "/")
+               for p, _ in required.values()
+               if os.path.relpath(p, ROOT).replace(os.sep, "/") not in normalized]
+    n_checks = text.count("    check_res ")
+    if missing or n_checks != len(required):
+        print(f"[失败] {os.path.basename(shell_path)} 的 [错误 B] 清单与 "
+              f"core/gripper/paths.py:required_resources() 不一致：")
+        for rel in missing:
+            print(f"  脚本里没有: {rel}")
+        print(f"  check_res 条数 {n_checks} ≠ 资源项数 {len(required)}")
+        sys.exit(1)
+    print(f"[核对] start_lite.sh 的 [错误 B] 清单与 paths.py 一致（{n_checks} 项）")
+
+
+def _verify_payload(out_dir: str, target: str) -> None:
+    """载荷完整性硬断言。
+
+    Linux 包：软链没被展开（R3）+ 7 项必需资源逐项就位。
+    Windows 包：代码照收、平台绑定件一个不留（含「零 ELF」这条硬不变量）——
+        于是「Windows 包」在语义上就是「Linux 包去掉载荷」，而这种形态在
+        Linux 开发机上可以直接造出来验证（mv 走 native/ 即可），不必真去
+        Windows 上撞。
+    """
+    _assert_shell_matches_paths()
+    gr = os.path.join(out_dir, GRIPPER_REL)
+    if target != "linux":
+        for name in _PLATFORM_BOUND_NAMES:
+            if os.path.exists(os.path.join(gr, name)):
+                print(f"[失败] Windows 包不该含 {GRIPPER_REL}/{name}/")
+                sys.exit(1)
+        elf = _find_elf(gr)
+        if elf:
+            print(f"[失败] Windows 包含 ELF 文件 {len(elf)} 个：{elf[:5]}")
+            sys.exit(1)
+        absent = [f"core/gripper/{f}"
+                  for f in ("__init__.py", "bridge.py", "paths.py",
+                            "fays_runtime.py", "fays_single.py")
+                  if not os.path.isfile(os.path.join(gr, f))]
+        if not os.path.isfile(os.path.join(out_dir, "core",
+                                           "gripper_codec.py")):
+            absent.append("core/gripper_codec.py")
+        if not os.path.isfile(os.path.join(out_dir, "core",
+                                           "s80m_manager.py")):
+            absent.append("core/s80m_manager.py")
+        if absent:
+            print(f"[失败] Windows 包缺夹爪代码（两个包都收 .py）: {absent}")
+            sys.exit(1)
+        print(f"[载荷] Windows 包：夹爪代码 {_count_py(gr)} 个 .py、零 ELF、"
+              f"无 {' / '.join(_PLATFORM_BOUND_NAMES)} —— "
+              f"那边的夹爪组框在、里面空着，属预期降级")
+        return
+    src = os.path.join(ROOT, GRIPPER_PAYLOAD_REL)
+    dst = os.path.join(out_dir, GRIPPER_PAYLOAD_REL)
+    if not os.path.isdir(dst):
+        print(f"[失败] Linux 包缺夹爪载荷 {GRIPPER_PAYLOAD_REL}/")
+        sys.exit(1)
+    n_src, n_dst = _count_symlinks(src), _count_symlinks(dst)
+    if n_src != n_dst:
+        print(f"[失败] 载荷软链被展开：源 {n_src} 个 → 包内 {n_dst} 个"
+              f"（copytree 必须传 symlinks=True）")
+        sys.exit(1)
+    size_mb = _tree_size(dst) / 1e6
+    size_src_mb = _tree_size(src) / 1e6
+    if size_mb > size_src_mb + 20:
+        print(f"[失败] 载荷体积异常：源 {size_src_mb:.0f}MB → 包内 {size_mb:.0f}MB")
+        sys.exit(1)
+    env = dict(os.environ, PYTHONPATH=out_dir, QT_QPA_PLATFORM="offscreen")
+    probe = ("import core.gripper.bridge, core.s80m_manager\n"
+             "from core.gripper import paths\n"
+             "missing = [k for k, (p, x) in paths.required_resources().items()\n"
+             "           if not os.path.exists(p)\n"
+             "           or (x and not os.access(p, os.X_OK))]\n"
+             "assert not missing, missing\n"
+             "assert paths.gripper_resources_available()\n"
+             "print('OK')")
+    proc = subprocess.run(
+        [sys.executable, "-c", "import os\n" + probe], cwd=out_dir, env=env,
+        stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+    if proc.returncode != 0:
+        print("[失败] 包内夹爪资源自检未通过：")
+        print(proc.stderr.decode("utf-8", "replace"))
+        sys.exit(1)
+    print(f"[载荷] {GRIPPER_PAYLOAD_REL}/ {size_mb:.0f}MB、"
+          f"软链 {n_dst} 个原样保留、7 项必需资源全部可执行")
+
+
+def collect(out_dir: str, with_wheels: bool, force: bool,
+            target: str) -> None:
     out_dir = os.path.abspath(out_dir)
     if force:
-        # 只重建代码路径；venv_lite/wheels/data 与分发壳原样保留
+        # 只重建代码路径；venv_lite/wheels/data 与分发壳原样保留；
+        # core/gripper/native（470MB）也不动 —— 它不由本脚本生成，
+        # 白删白拷一轮纯浪费（Windows 包目录里本来就没有它）
+        keep = os.path.join(out_dir, GRIPPER_PAYLOAD_REL)
         for rel in (CODE_FILES + ["config", "core", "ui", "tools"]):
-            p = os.path.join(out_dir, rel)
-            if os.path.isdir(p):
-                shutil.rmtree(p, ignore_errors=True)
-            elif os.path.isfile(p):
-                os.remove(p)
+            _force_remove(os.path.join(out_dir, rel), keep)
     elif os.path.isfile(os.path.join(out_dir, "main_lite.py")):
         print(f"[跳过] 目标目录已存在: {out_dir}")
-        print("  --force 只重建代码部分，venv_lite/wheels/data 会保留")
+        print("  --force 只重建代码部分，venv_lite/wheels/data 与载荷会保留")
         sys.exit(0)
 
     copied = []
-    for rel in CODE_FILES + SELFTEST_FILES:
+    for rel in CODE_FILES + SELFTEST_FILES + (
+            TOOL_FILES_LINUX if target == "linux" else []):
         src = os.path.join(ROOT, rel)
         if not os.path.isfile(src):
             print(f"[警告] 缺文件: {rel}")
@@ -103,13 +389,13 @@ def collect(out_dir: str, with_wheels: bool, force: bool) -> None:
         copied.append(rel)
 
     for rel in DIST_FILES:
-        src = os.path.join(DIST_SOURCE, rel)
+        src = _dist_shell_source(rel)
+        if src is None:
+            print(f"[警告] 缺分发文件: {rel}（应在仓库根或 lite_package/ 下）")
+            continue
         dst = os.path.join(out_dir, rel)
         if os.path.abspath(src) == os.path.abspath(dst):
-            copied.append(rel)   # 源即目标（lite_package 自身）
-            continue
-        if not os.path.isfile(src):
-            print(f"[警告] 缺分发文件: {rel}（应在 lite_package/ 下）")
+            copied.append(rel)   # 源���目标（在 lite_package/ 内收集）
             continue
         shutil.copy2(src, dst)
         copied.append(rel)
@@ -117,7 +403,18 @@ def collect(out_dir: str, with_wheels: bool, force: bool) -> None:
     for rel in WHOLE_DIRS:
         src = os.path.join(ROOT, rel)
         dst = os.path.join(out_dir, rel)
-        shutil.copytree(src, dst, ignore=shutil.ignore_patterns("__pycache__"))
+        if rel == GRIPPER_REL:
+            ignore = _gripper_ignore_factory(
+                src, windows=(target != "linux"),
+                # 目标包已有载荷（--force 重打包）：native/ 整棵跳过，
+                # 只刷新 Python 代码 —— 也避开已存在软链的 File exists
+                keep_existing_native=os.path.isdir(
+                    os.path.join(dst, "native")))
+        else:
+            ignore = shutil.ignore_patterns("__pycache__")
+        # symlinks=True 是硬要求（载荷里 76 个相对软链，展开 +330MB）
+        shutil.copytree(src, dst, symlinks=True, ignore=ignore,
+                        dirs_exist_ok=True)
         copied.append(rel + "/")
 
     for sub, files in MODULE_FILES.items():
@@ -151,25 +448,40 @@ def collect(out_dir: str, with_wheels: bool, force: bool) -> None:
         print("[失败] 目标目录内 import main_lite 自检未通过：")
         print(proc.stderr.decode("utf-8", "replace"))
         sys.exit(1)
+    _verify_payload(out_dir, target)
 
     total = sum(os.path.getsize(os.path.join(out_dir, r))
                 for r in copied if os.path.isfile(os.path.join(out_dir, r)))
+    if target == "linux":
+        payload = _tree_size(os.path.join(out_dir, GRIPPER_REL)) / 1e6
+        hint = (f"  客户机落盘 = 本目录 + 夹爪载荷 {payload:.0f}MB"
+                f" + venv_lite(自动安装, ~750MB) ≈ {payload / 1000 + 0.75:.2f}GB"
+                + (" + wheels/" if with_wheels else ""))
+    else:
+        hint = ("  客户机落盘 = 本目录 + venv_lite(自动安装, ~750MB) ≈ 0.75GB"
+                "（Windows 包不含夹爪载荷 native/ 与 sightac_sdk/，"
+                "那边的夹爪组框在、里面空着）"
+                + (" + wheels/" if with_wheels else ""))
     print(f"[完成] 收集 {len(copied)} 个文件到 {out_dir}/，"
-          f"代码共 {total / 1024:.0f} KB，import main_lite 自检通过")
-    print("  客户机落盘 = 本目录 + venv_lite(自动安装, ~750MB)"
-          + (" + wheels/" if with_wheels else ""))
+          f"代码共 {total / 1024:.0f} KB，import main_lite 自检通过（{target}）")
+    print(hint)
 
 
 def main() -> None:
     parser = argparse.ArgumentParser(description="收集极简采集版发布包")
     parser.add_argument("--out", default=os.path.join(ROOT, "lite_package"),
                         help="输出目录（默认仓库根 lite_package/）")
+    parser.add_argument("--target", default=None,
+                        choices=("linux", "windows"),
+                        help="目标平台（默认本机）。windows 包不含平台绑定件"
+                             "（native/sightac_sdk），夹爪代码两个包同源")
     parser.add_argument("--with-wheels", action="store_true",
                         help="连同 wheels/ 离线依赖包一起收集")
     parser.add_argument("--force", action="store_true",
-                        help="重建代码部分（保留 venv_lite/wheels/data）")
+                        help="重建代码部分（保留 venv_lite/wheels/data/载荷）")
     args = parser.parse_args()
-    collect(os.path.abspath(args.out), args.with_wheels, args.force)
+    target = args.target or ("windows" if os.name == "nt" else "linux")
+    collect(os.path.abspath(args.out), args.with_wheels, args.force, target)
 
 
 if __name__ == "__main__":

collector/{lite_package/start_lite.bat → start_lite.bat}

@@ -16,6 +16,15 @@ rem  ֻ
 rem  �������� venv/ ����Ӱ�죩��wheels/ �� data/ ���汾���á�
 rem  ������װ˳��: wheels\ ���߰� �� �����ƾ��� �� �廪���� �� �ٷ�Դ
 rem  ������ A-G ��Ӧ ʹ��˵��_lite.md���쳣�����½ڣ�
+rem
+rem  ����צΪʲô���ﲻ�顿Windows ��**���ⲻ��** UMI/Fays ��צ��ԭ����Դ
+rem  ��core/gripper/native��Լ 460MB���봥�� SDK��core/gripper/sightac_sdk��
+rem  ������ pyarmor ����ʱ�� .so �� libSonixCamera.so������ ��Щȫ�� ELF��
+rem  �� Windows �������ܲ��ˡ���צ�� Python ������������������ƽ̨�󶨣���
+rem  ȱ�غ�ʱ core/gripper/paths.py �� gripper_resources_available() ���ؼ�
+rem  �� �豸�б���ġ�UMI ��צ������ڣ��������ǿյģ��㡸��������ʾ���б���û���豸��������**Ԥ�ڽ���**�����ǹ��ϡ�
+rem  Linux �����غɣ��DZ� start_lite.sh �� [���� B] ����У�飻���߿���
+rem  ���Գƣ��������ﲹһ������Դȱʧ���ļ�飨����ݰ�������Զ��ͨ������
 rem ============================================================
 setlocal enabledelayedexpansion
 cd /d "%~dp0"
@@ -113,7 +122,7 @@ echo  [5/6]
 echo.
 echo  ������ָ����
 echo    �� �豸: �����Լ 2 ���Զ��������б���ѡ�к�� ����
-echo    �� ¼��: �ȿ� D435���ٵ� ��ʼ/ֹͣ������ֹͣ=���棬X ����=���ϣ�
+echo    �� ¼��: �ȿ� D435 / UVC ����ͷ / ��צ������һ����ƵԴ�����ٵ� ��ʼ/ֹͣ������ֹͣ=���棬X ����=���ϣ�
 echo    �� �ϴ�: ¼����ɺ��Զ��ϴ��������·��б��ֶ��ϴ�
 echo    �� ˵��: ˫�� start_lite.bat help �� ʹ��˵��_lite.md
 echo.

collector/{lite_package/start_lite.sh → start_lite.sh}

@@ -10,6 +10,9 @@
 #  只安装 requirements-lite.txt 白名单依赖（独立 venv_lite/，
 #  与主程序 venv/ 互不影响）；wheels/ 与 data/ 两版本共用。
 #  依赖安装顺序: 离线 wheels/ 包 → 阿里云镜像 → 清华镜像 → 官方源
+#
+#  夹爪(UMI/Fays S80M): 原生资源 core/gripper/native（约 460MB）随本包
+#  下发，[B] 会逐项校验，缺失报 [错误 B] 并拒启；Windows 包不带该资源。
 # ============================================================
 set -euo pipefail
 cd "$(dirname "$0")"
@@ -32,6 +35,48 @@ if [ ! -f main_lite.py ] || [ ! -f requirements-lite.txt ]; then
     exit 1
 fi
 
+# ── [B] 夹爪原生资源自检（Linux 包独有，缺失即拒启）──
+# 夹爪（UMI / Fays S80M）的原生栈约 460MB，作为**必需资源**随 Linux 分发包
+# 下发；Windows 包不带（原生栈是 ELF x86-64，物理上跑不了，那边靠载荷缺失
+# 自然降级为纯手套版，见 start_lite.bat 的注释）。
+# 清单与 core/gripper/paths.py 的 required_resources() 一一对应：这里只查
+# 存在性与可执行位（不 import —— 那要等 venv 装好，见 [E]）；打包脚本
+# scripts/pack_lite.py 会在收集时逐项核对这份清单，改了 paths.py 忘了改这里
+# 会**在打包当场报错**，所以两处不会悄悄漂移。
+# 逃生舱 KSQ_GRIPPER_SKIP_CHECK=1：决策上载荷是必需资源，但硬停启动的代价
+# 是整机不可用，留一个显式开关（跳过则夹爪组为空，D435/UVC/手套照常）。
+GRIPPER_NATIVE="${KSQ_GRIPPER_NATIVE_ROOT:-core/gripper/native}"
+GRIPPER_SIGHTAC="${KSQ_SIGHTAC_ROOT:-core/gripper/sightac_sdk}"
+if [ "${KSQ_GRIPPER_SKIP_CHECK:-0}" = "1" ]; then
+    echo "[B] KSQ_GRIPPER_SKIP_CHECK=1 —— 跳过夹爪资源自检，夹爪将不可用"
+else
+    MISSING=""
+    check_res() {   # $1=标签 $2=路径 $3=1 表示需要可执行位
+        if [ ! -e "$2" ]; then
+            MISSING="${MISSING}  · $1 —— 缺 $2\n"
+        elif [ "$3" = "1" ] && [ ! -x "$2" ]; then
+            MISSING="${MISSING}  · $1 —— $2 没有可执行位（chmod +x 修复）\n"
+        fi
+    }
+    check_res "Fays ORB 桥接" "$GRIPPER_NATIVE/dist/fays_opencv48/bin/fayssense_orb_slam_sn219_opencv48_mark_only" 1
+    check_res "Fays 标定探测" "$GRIPPER_NATIVE/dist/fays_aikit/bin/fays_vikit_calibration_probe" 1
+    check_res "ORB-SLAM3 核心库" "$GRIPPER_NATIVE/dist/orb_mark_only/lib/libORB_SLAM3.so" 0
+    check_res "ORB 词典" "$GRIPPER_NATIVE/ORBvoc.txt" 0
+    check_res "libuvc 相机服务" "$GRIPPER_NATIVE/camera_service/build/ksq-camera-service" 1
+    check_res "Sightac SDK" "$GRIPPER_SIGHTAC/api_new" 0
+    check_res "Fays SDK lib" "$GRIPPER_NATIVE/FaysSense_VI_Kit_Release/lib" 0
+    if [ -n "$MISSING" ]; then
+        echo "[错误 B] 夹爪原生资源缺失 —— 本分发包不完整："
+        printf '%b' "$MISSING"
+        echo "  原因通常是解压少了一层目录、拷贝中断，或覆盖升级时漏了 core/gripper/native/。"
+        echo "  修复: ① 重新完整解压分发包；② 从原始包补齐 core/gripper/native/（约 460MB）；"
+        echo "        ③ 仅想先用 D435/UVC/手套: KSQ_GRIPPER_SKIP_CHECK=1 ./start_lite.sh"
+        echo "  自定义安装位置时可用 KSQ_GRIPPER_NATIVE_ROOT=<native 目录> 指路。"
+        exit 1
+    fi
+    echo "[B] 夹爪资源自检通过（7 项）"
+fi
+
 # ── [1/6] 定位 Python（>= 3.10，推荐 3.12）──
 PY=""
 find_python() {
@@ -111,7 +156,7 @@ echo "[5/6] 启动极简采集 ..."
 echo
 echo "【操作指引】"
 echo "  · 设备: 插入后约 2 秒自动出现在列表，选中后点 开启"
-echo "  · 录制: 先开 D435，再点 开始/停止（正常停止=保存，⛔ 丢弃=作废）"
+echo "  · 录制: 先开 D435 / UVC 摄像头 / 夹爪（至少一个视频源），再点 开始/停止（正常停止=保存，⛔ 丢弃=作废）"
 echo "  · 上传: 录制完成后自动上传，或在下方列表手动上传"
 echo "  · 说明: ./start_lite.sh help 打开 使用说明_lite.md"
 echo

collector/tools/dedup_gripper_native.py

@@ -0,0 +1,205 @@
+"""回收 core/gripper/native 里被展开成实体文件的软链副本（只动布局，不动内容）。
+
+背景：厂商交付的 kit 在传输途中走过 ZIP/Windows 或 `cp -rL`，标准 `.so`
+布局被解引用成实体副本。实测整棵树有 339 MB 是同一内容的重复存放，最夸张
+的是 orb48_env 里同一个 libopenblas 存了 7 份（7 × 39.6 MB，md5 全一致），
+而正常布局是「一个 libopenblasp-r0.3.34.so + 6 个软链」。
+
+判定规则（保守，三条同时满足才动）：
+  1. 同一个目录内（跨目录的重复一律不碰——不同目录可能是各自独立的变体，
+     例如 dist/orb_mark_only/lib 与 lib_system_boost 各有一份 libORB_SLAM3.so）
+  2. 内容逐字节相同（md5）
+  3. 文件名是共享库名（`.so` / `.so.3` / `.so.4.2.0` 这种）
+
+保留哪一份：名字最长的那个（`libopencv_core.so.4.2.0` 胜过 `.so.4.2` 与
+`.so`；`libopenblasp-r0.3.34.so` 胜过 `libblas.so.3`）——这与 conda/系统
+打包时「实体文件用最长版本名、其余做软链」的实际布局一致。字节既然相同，
+即便选错也只是软链朝向问题，不影响任何加载行为。
+
+不动的（只列出来给人看）：
+  - 备份文件（`.pre_*_backup` 这类名字，不匹配共享库名）
+  - 跨目录重复
+  - 可执行文件（bin/ 下的产物没有 .so 后缀）
+
+软链一律用**相对路径**，这样整棵树 `cp -a` 搬走后依然解析。
+
+每次 --apply 都会落一份清单（默认 logs/gripper_native_dedup_<时间戳>.json），
+记录每个被替换文件的路径、md5、体积与软链目标，凭它可以原样还原：
+  ln -sf 的反操作 = 删软链 + 从 target 复制回来。
+
+用法:
+    python tools/dedup_gripper_native.py                # dry-run，只打印清单
+    python tools/dedup_gripper_native.py --apply        # 实际执行
+    python tools/dedup_gripper_native.py --root <目录>  # 指定其它树
+"""
+from __future__ import annotations
+
+import argparse
+import collections
+import hashlib
+import json
+import os
+import re
+import sys
+import time
+
+ROOT_DEFAULT = os.path.join(
+    os.path.dirname(os.path.dirname(os.path.abspath(__file__))),
+    "core", "gripper", "native",
+)
+
+# 共享库名：xxx.so / xxx.so.3 / xxx.so.4.2.0（可带 -r0.3.34 这类内部版本）
+_SHARED_LIB_RE = re.compile(r"^.+\.so(\.[0-9]+)*$")
+
+MIN_SIZE = 300 * 1024   # 小于 300KB 的不值得动（软链本身也要占 inode）
+
+
+def _md5(path: str) -> str:
+    h = hashlib.md5()
+    with open(path, "rb") as fh:
+        for chunk in iter(lambda: fh.read(1 << 20), b""):
+            h.update(chunk)
+    return h.hexdigest()
+
+
+def scan(root: str):
+    """返回 (可回收组, 需人工判断的重复组)。"""
+    by_key = collections.defaultdict(list)
+    for dirpath, dirnames, filenames in os.walk(root):
+        dirnames[:] = [d for d in dirnames if d != "__pycache__"]
+        for name in filenames:
+            path = os.path.join(dirpath, name)
+            try:
+                if os.path.islink(path) or os.path.getsize(path) < MIN_SIZE:
+                    continue
+                by_key[(dirpath, _md5(path))].append((name, path))
+            except OSError:
+                continue
+
+    reclaimable, review = [], []
+    for (dirpath, digest), items in by_key.items():
+        if len(items) < 2:
+            continue
+        size = os.path.getsize(items[0][1])
+        group = {
+            "dir": dirpath,
+            "md5": digest,
+            "size": size,
+            "names": sorted(n for n, _ in items),
+            "paths": sorted(p for _, p in items),
+        }
+        if all(_SHARED_LIB_RE.match(n) for n, _ in items):
+            reclaimable.append(group)
+        else:
+            review.append(group)
+
+    # 跨目录的重复单独提出来（不进可回收组）
+    by_digest = collections.defaultdict(list)
+    for (dirpath, digest), items in by_key.items():
+        for name, path in items:
+            by_digest[digest].append(path)
+    cross = []
+    for digest, paths in by_digest.items():
+        dirs = {os.path.dirname(p) for p in paths}
+        if len(dirs) > 1:
+            cross.append({
+                "md5": digest,
+                "size": os.path.getsize(paths[0]),
+                "paths": sorted(paths),
+            })
+    cross.sort(key=lambda g: -g["size"])
+    return reclaimable, review, cross
+
+
+def plan_for(group):
+    """选最长名字那份当实体，其余转软链（相对路径）。"""
+    paths = sorted(group["paths"], key=lambda p: (-len(os.path.basename(p)),
+                                                  os.path.basename(p)))
+    target = paths[0]
+    return target, paths[1:]
+
+
+def main() -> None:
+    ap = argparse.ArgumentParser(description=__doc__,
+                                 formatter_class=argparse.RawDescriptionHelpFormatter)
+    ap.add_argument("--root", default=ROOT_DEFAULT)
+    ap.add_argument("--apply", action="store_true", help="实际执行��默认 dry-run）")
+    ap.add_argument("--manifest", default="",
+                    help="清单输出路径（默认 logs/gripper_native_dedup_<时间戳>.json）")
+    args = ap.parse_args()
+
+    root = os.path.abspath(args.root)
+    if not os.path.isdir(root):
+        sys.exit(f"目录不存在: {root}")
+
+    reclaimable, review, cross = scan(root)
+
+    total = sum(g["size"] * (len(g["paths"]) - 1) for g in reclaimable)
+    print(f"扫描: {root}")
+    print(f"可回收组: {len(reclaimable)} 组，合计 {total / 1048576:.0f} MB\n")
+
+    entries = []
+    for group in sorted(reclaimable, key=lambda g: -g["size"] * len(g["paths"])):
+        target, aliases = plan_for(group)
+        rel_target = os.path.relpath(target, group["dir"])
+        print(f"  {group['size'] * len(aliases) / 1048576:6.1f} MB  "
+              f"{os.path.relpath(group['dir'], root)}/")
+        print(f"        实体 → {os.path.basename(target)}")
+        for alias in aliases:
+            print(f"        软链 ← {os.path.basename(alias)}")
+            entries.append({
+                "path": alias, "action": "symlink",
+                "target": rel_target, "size": group["size"],
+                "md5": group["md5"],
+            })
+        print()
+
+    if review:
+        wasted = sum(g["size"] * (len(g["paths"]) - 1) for g in review)
+        print(f"需人工判断（名字非共享库名，未动）: {len(review)} 组 / {wasted / 1048576:.0f} MB")
+        for group in sorted(review, key=lambda g: -g["size"])[:10]:
+            print(f"  {group['size'] / 1048576:5.1f} MB × {len(group['paths'])}  "
+                  f"— {', '.join(os.path.basename(n) for n in group['names'][:4])}")
+        print()
+
+    if cross:
+        wasted = sum(g["size"] * (len(g["paths"]) - 1) for g in cross)
+        print(f"跨目录重复（可能是各自独立的变体，未动）: {len(cross)} 组 / {wasted / 1048576:.0f} MB")
+        for group in cross[:6]:
+            print(f"  {group['size'] / 1048576:5.1f} MB —")
+            for p in group["paths"]:
+                print(f"        {os.path.relpath(p, root)}")
+        print()
+
+    if not args.apply:
+        print("dry-run 结束，未做任何修改。加 --apply 执行。")
+        return
+
+    manifest = args.manifest or os.path.join(
+        os.path.dirname(os.path.dirname(os.path.abspath(__file__))),
+        "logs", f"gripper_native_dedup_{time.strftime('%Y%m%d_%H%M%S')}.json")
+    os.makedirs(os.path.dirname(manifest), exist_ok=True)
+
+    done = 0
+    for entry in entries:
+        alias = entry["path"]
+        link_dir = os.path.dirname(alias)
+        os.remove(alias)                       # 删副本（内容在 target 里还在）
+        os.symlink(entry["target"], alias)     # 相对软链
+        done += 1
+        assert os.path.realpath(alias) == os.path.realpath(
+            os.path.join(link_dir, entry["target"])), alias
+
+    with open(manifest, "w", encoding="utf-8") as fh:
+        json.dump({"root": root, "applied_at": time.time(),
+                   "reclaimed_bytes": total, "entries": entries},
+                  fh, ensure_ascii=False, indent=2)
+
+    saved = sum(os.path.getsize(p) for p in [] ) or total
+    print(f"[完成] {done} 个副本转成软链，回收 {total / 1048576:.0f} MB")
+    print(f"  清单: {manifest}")
+    print("  还原: 删软链 + 从 target 复制回原文件（清单里有 md5 可校验）")
+
+
+if __name__ == "__main__":
+    main()

collector/tools/tests/lite_gripper_smoke_test.py

@@ -0,0 +1,415 @@
+"""极简版 UMI 夹爪冒烟测试（无硬件，离屏 Qt，三条路径）。
+
+路径 D（UI + 假桥注入）:
+    LiteWindow(gripper_bridge_cls=FakeGripperBridge) → 只开夹爪（无 D435/UVC）
+    → 夹爪 RGB 作主视频源 → 录制 3s → 停 → 校验 gripper_rgb 视频 /
+    parquet 的力/力矩阵/夹爪状态/SLAM 轨迹列 / info.json 的 devices 与
+    features.scale。顺带断言「只录不显」契约（预览区没有被夹爪污染）。
+
+路径 E（纯管线，无 UI）:
+    rig2 前缀（gripper_2_*）的完整落盘链：力 / 力矩阵 / 状态 / 轨迹 +
+    set_force_matrix_spec → 校验双夹爪命名空间与倍率登记。
+
+路径 F（编码器搬家回归）:
+    core.gripper_codec.encode_gripper_force_matrix 必须**就是**
+    ui.main_window 里那个函数对象（re-export 而非复制第二份）。
+    venv_lite 装不下 ui.main_window 的重依赖，那里跳过。
+
+用法:
+    QT_QPA_PLATFORM=offscreen venv/bin/python tools/tests/lite_gripper_smoke_test.py
+    （包内副本用 lite_package/venv_lite/bin/python 跑，验证闭包完整性）
+"""
+import json
+import os
+import shutil
+import sys
+import threading
+import time
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.dirname(
+    os.path.abspath(__file__)))))
+os.environ.setdefault("QT_QPA_PLATFORM", "offscreen")
+
+import numpy as np
+import pyarrow.parquet as pq
+from PyQt5.QtCore import QObject, QTimer, pyqtSignal
+from PyQt5.QtWidgets import QApplication, QMessageBox
+
+from config import settings
+from core.device_detector import DeviceInfo
+from core.gripper_codec import encode_gripper_force_matrix
+from core.helpers import (episode_video_files, pooled_data_parquet_path,
+                          pooled_info_path)
+from core.pipeline import CameraPipeline
+from ui.lite_window import LiteUploadManager, LiteWindow
+
+OUT_ROOT_D = "/tmp/lite_gripper_smoke_ui"
+OUT_ROOT_E = "/tmp/lite_gripper_smoke_pipe"
+DURATION_D = 3.0
+DURATION_E = 3.0
+
+# 力矩阵列名（rig1 无前缀；rig2 加 "gripper_2_"）
+MATRIX_LEN = settings.GRIPPER_FORCE_MATRIX_DIM ** 2 * 3
+
+
+def wait(app, ms):
+    t_end = time.time() + ms / 1000.0
+    while time.time() < t_end:
+        app.processEvents()
+        time.sleep(0.01)
+
+
+class FakeGripperBridge(QObject):
+    """GripperBridge 替身（鸭子类型，信号口径与 core/gripper/bridge.py 一致）。
+
+    ★ 刻意**不提供 stereo_frame_ready** —— lite 只录不显，不接双目信号；
+    哪天有人给 lite 接上它，这里会直接 AttributeError 暴露。
+    力矩阵走与真桥相同的 latest-wins 单槽 + 序号口径（泵线程按 seq 判新）。
+    """
+
+    rgb_frame_ready = pyqtSignal(object, object)
+    tactile_ready = pyqtSignal(str, object, object, object, object)
+    pose_ready = pyqtSignal(object, object, object, object, object)
+    gripper_state_ready = pyqtSignal(object)
+    opened = pyqtSignal()
+    log = pyqtSignal(str)
+    error = pyqtSignal(str)
+    closed = pyqtSignal()
+
+    TICK_MS = 33
+    MATRIX_EVERY = 5      # 力矩阵降频：30Hz 全量（每帧 187500 个数）太占地
+
+    def __init__(self, parent=None, stereo_slot="gripper_stereo_left",
+                 rig_index=1):
+        super().__init__(parent)
+        self.stereo_slot = stereo_slot
+        self.rig_index = int(rig_index)
+        self.serial = ""
+        self.closed_count = 0
+        self._lock = threading.Lock()
+        self._seq = {"left": 0, "right": 0}
+        self._matrix = {}          # side → (capture_ns, ndarray)
+        self._tick = 0
+        self._dropped = 0
+        self._elapsed = 0
+        self._timer = QTimer(self)
+        self._timer.timeout.connect(self._emit)
+
+    # ── 生命周期（UI 调）──
+
+    def open(self, esp_serial):
+        self.serial = esp_serial
+        self._timer.start(self.TICK_MS)
+        self.opened.emit()
+
+    def close(self):
+        self._timer.stop()
+        self.closed_count += 1
+        self.closed.emit()
+
+    # ── 力矩阵泵线程读的口（真桥为加锁单槽 latest-wins）──
+
+    def matrix_seq(self, side):
+        with self._lock:
+            return self._seq.get(side, 0)
+
+    def latest_matrix_stamped(self, side):
+        with self._lock:
+            entry = self._matrix.get(side)
+        return None if entry is None else (int(entry[0]), entry[1])
+
+    def stereo_drop_snapshot(self):
+        return (self._dropped, self._elapsed)
+
+    def reset_stereo_drop_watch(self):
+        self._dropped = 0
+        self._elapsed = 0
+
+    def clear_trajectory(self):
+        pass
+
+    # ── 样本生产（模拟 30Hz 的相机/触觉/串口三条流）──
+
+    @staticmethod
+    def make_matrix(seed):
+        m = np.zeros((settings.GRIPPER_FORCE_MATRIX_DIM,
+                      settings.GRIPPER_FORCE_MATRIX_DIM, 3), dtype=np.float32)
+        i = 100 + (seed % 20)
+        m[i:i + 10, i:i + 10, 0] = 5.0 + (seed % 7)
+        return m
+
+    def _emit(self):
+        self._tick += 1
+        now_ns = time.monotonic_ns()
+        self._elapsed += 1
+        if self._tick % 9 == 0:        # 模拟偶发双目空桶（走汇总日志分支）
+            self._dropped += 1
+        frame = np.zeros((480, 640, 3), dtype=np.uint8)
+        frame[..., 2] = (self._tick * 5) & 255
+        self.rgb_frame_ready.emit(frame, now_ns)
+        for side in ("left", "right"):
+            force = [float(100 + self._tick), 2.0, 3.0]
+            matrix = None
+            if self._tick % self.MATRIX_EVERY == 0:
+                matrix = self.make_matrix(self._tick)
+                with self._lock:
+                    self._seq[side] += 1
+                    self._matrix[side] = (now_ns, matrix)
+            self.tactile_ready.emit(
+                side, np.zeros((240, 320, 3), dtype=np.uint8), force,
+                matrix, now_ns)
+        pos = (0.001 * self._tick, 0.002 * self._tick, 0.0)
+        self.pose_ready.emit(pos, (0.0, 0.0, 0.0, 1.0), (pos,),
+                             float(self._tick) * 0.033,
+                             287607700000000 + self._tick * 33333333)
+        self.gripper_state_ready.emit(
+            {"pct": 40.0 + self._tick % 10, "gripped": True, "fz": 1200.0})
+
+
+# ── 路径 D: UI + 假夹爪桥（只开夹爪，无 D435/UVC）──
+
+def path_d():
+    shutil.rmtree(OUT_ROOT_D, ignore_errors=True)
+    app = QApplication(sys.argv)
+    settings.UPLOAD_AUTO_SYNC = False
+    settings.ENCODER_PROBE_ENABLED = False   # lite 口径：直接 x264，测试提速
+
+    pipe = CameraPipeline(output_dir=OUT_ROOT_D)
+    finished = []
+    pipe.recording_aborted.connect(lambda sid: finished.append("ABORTED"))
+    pipe.recording_finished.connect(lambda sid, path: finished.append(path))
+    win = LiteWindow(
+        pipeline=pipe,
+        upload_manager=LiteUploadManager("http://127.0.0.1:9"),
+        gripper_bridge_cls=FakeGripperBridge)
+    # 守卫若拦下会弹模态框 —— 离屏下没人点确定，测试会永久挂住；
+    # 换成收集器，让「被拦」表现为可读的断言失败
+    guard_msgs = []
+    QMessageBox.warning = staticmethod(
+        lambda *a, **k: guard_msgs.append(a[2] if len(a) > 2 else ""))
+    win.show()
+    wait(app, 200)
+
+    dev = DeviceInfo(key="gripper:FAKE01", kind="gripper",
+                     display_name="UMI 夹爪", serial="FAKE01",
+                     address="/dev/ttyACM0")
+    assert win._open_gripper(dev), "假夹爪开启失败"
+    bridge = win._workers[dev.key]["bridge"]
+    assert isinstance(bridge, FakeGripperBridge)
+    assert bridge.serial == "FAKE01", f"open() 未拿到序列号: {bridge.serial}"
+    wait(app, 800)
+
+    entry = win._workers[dev.key]
+    assert entry["slot_map"]["rgb"] in entry["_video_registered"], \
+        "夹爪 RGB 槽未惰性注册（首帧没到？）"
+    # 只录不显契约：预览区/预览源完全没有夹爪
+    assert win._src_combo.count() == 3, f"预览源被改动: {win._src_combo.count()}"
+    assert not [s for s in win._ring if "gripper" in s], \
+        f"预览 ring 收到夹爪帧: {list(win._ring)}"
+    assert "pose_view" not in entry and "side_widgets" not in entry, \
+        "lite 条目不该有显示控件"
+    meta = win._device_meta()          # 显式分支：不许 KeyError
+    gmeta = [m for m in meta if m["kind"] == "gripper"]
+    assert len(gmeta) == 1 and len(gmeta[0]["slots"]) == 5, f"meta 异常: {meta}"
+    print(f"  D: 夹爪已开启（{bridge.stereo_slot} / rig{bridge.rig_index}），"
+          f"RGB 槽 {entry['slot_map']['rgb']} 已注册，预览区未受影响")
+
+    # 只开夹爪时录制守卫必须放行（夹爪 RGB 作主视频源）
+    assert win._master_video_slot() == "gripper_rgb", \
+        f"主视频源选择错误: {win._master_video_slot()}"
+    win._task_edit.setText("lite_gripper")
+    win._start_recording()
+    assert not guard_msgs, f"录制守卫拦下了只开夹爪的录制: {guard_msgs}"
+    assert pipe.is_recording, "只开夹爪时录制未启动（守卫拦住了？）"
+    wait(app, int(DURATION_D * 1000))
+    win._stop_recording()
+    t_end = time.time() + 15
+    while not finished and time.time() < t_end:
+        wait(app, 50)
+    assert finished and finished[0] != "ABORTED", f"录制异常: {finished}"
+    task_dir = finished[0]
+    ep = pipe.last_episode_index
+    assert ep > 0, "episode 序号异常"
+    assert win._workers[dev.key]["matrix_pump_stop"] is None, \
+        "录制结束未停力矩阵泵"
+    win.close()
+    wait(app, 200)
+    assert bridge.closed_count == 1, "关窗未关闭桥接（进程会残留）"
+    assert dev.key not in win._workers, "关窗未回收夹爪条目"
+
+    videos = episode_video_files(task_dir, ep)
+    assert "gripper_rgb" in videos, f"夹爪 RGB 视频缺失: {videos}"
+    assert os.path.getsize(videos["gripper_rgb"]) > 1000, "夹爪视频过小"
+    tbl = pq.read_table(pooled_data_parquet_path(task_dir, ep))
+    assert tbl.num_rows > 0, "parquet 无行"
+    cols = tbl.column_names
+    want = ["observation.gripper_state",
+            "observation.gripper_left_force", "observation.gripper_right_force",
+            "observation.gripper_left_force_matrix",
+            "observation.gripper_right_force_matrix",
+            "observation.gripper_left_force_ns",
+            "observation.gripper_left_force_matrix_ns",
+            "observation.slam_trajectory",
+            # 逐点宿主时刻：这条覆盖的是完整 lite UI 接线（假桥 pose_ready
+            # 第 5 参 → lite_window lambda → _on_gripper_pose → pipeline），
+            # 信号参数个数或 lambda 形参写错这里就会缺列
+            "observation.slam_trajectory_ns"]
+    for name in want:
+        assert name in cols, f"缺列 {name}（有: {cols}）"
+    # 轨迹点列与其时刻列必须逐行等长（下标即配对）
+    _traj = tbl.column("observation.slam_trajectory").to_pylist()
+    _ns = tbl.column("observation.slam_trajectory_ns").to_pylist()
+    assert any(_ns), "slam_trajectory_ns 全空（假桥发了戳却没落盘）"
+    assert all(len(a) // 8 == len(b) for a, b in zip(_traj, _ns)), \
+        "slam_trajectory 与 slam_trajectory_ns 长度不同步"
+    mat = tbl.column("observation.gripper_left_force_matrix").to_pylist()
+    rows = [r for r in mat if r]
+    assert rows and len(rows[0]) == MATRIX_LEN, \
+        f"力矩阵长度异常: {len(rows[0]) if rows else 0} != {MATRIX_LEN}"
+    traj = [r for r in tbl.column("observation.slam_trajectory").to_pylist() if r]
+    assert traj and len(traj[0]) % 8 == 0, "轨迹列不是 8 值/点"
+    firsts = [row[0] for row in traj]
+    assert firsts == sorted(firsts), "轨迹时间戳非单调"
+    info = json.load(open(pooled_info_path(task_dir), encoding="utf-8"))
+    kinds = [d.get("kind") for d in info.get("devices", [])]
+    assert "gripper" in kinds, f"info.json devices 缺 gripper: {kinds}"
+    spec = settings.GRIPPER_FORCE_MATRIX_SPEC
+    scale = settings.GRIPPER_FORCE_MATRIX_SCALES.get(spec)
+    feat = info["features"]["observation.gripper_left_force_matrix"]
+    assert feat["scale"] == (scale or 1), \
+        f"features.scale 与规格不符: {feat} vs spec={spec}"
+    print(f"  D: {DURATION_D}s → gripper_rgb {os.path.getsize(videos['gripper_rgb']) // 1024}KB"
+          f" / {tbl.num_rows} 行 / 力矩阵 {len(rows)} 行 x{MATRIX_LEN}"
+          f" / 轨迹 {len(traj)} 行 / scale={feat['scale']}")
+    print("  D: PASS")
+    return 0
+
+
+# ── 路径 E: 纯管线 + rig2 命名空间（无 UI、无桥）──
+
+def path_e():
+    shutil.rmtree(OUT_ROOT_E, ignore_errors=True)
+    app = QApplication.instance() or QApplication(sys.argv)
+    settings.UPLOAD_AUTO_SYNC = False
+    settings.ENCODER_PROBE_ENABLED = False
+
+    prefix = "gripper_2_"          # 第二台夹爪的数据列命名空间
+    spec = settings.GRIPPER_FORCE_MATRIX_SPEC
+    pipe = CameraPipeline(output_dir=OUT_ROOT_E)
+    finished = []
+    pipe.recording_finished.connect(lambda sid, path: finished.append(path))
+    # 倍率只能挂在 recording_started 之后登记：start_recording 立刻返回，
+    # writer 由后台线程创建（pipeline._start_async）且在 start_episode 里
+    # 会清空已登记的倍率 —— 在 start_recording 之后紧跟着调是**静默无效**的
+    pipe.recording_started.connect(
+        lambda sid: pipe.set_force_matrix_spec(prefix, spec))
+    pipe.register_external_source(f"{prefix}rgb", (480, 640), fps=30.0)
+    pipe.start_recording(f"{prefix}rgb", task_name="lite_gripper2",
+                         device_meta=[{"key": "gripper:FAKE02",
+                                       "kind": "gripper", "name": "UMI 夹爪",
+                                       "serial": "FAKE02",
+                                       "slots": [f"{prefix}rgb"]}])
+
+    rgb = np.zeros((480, 640, 3), dtype=np.uint8)
+    matrix = FakeGripperBridge.make_matrix(7)
+    t0 = time.time()
+    state = {"n": 0}
+
+    def feed():
+        state["n"] += 1
+        rgb[..., 1] = (state["n"] * 3) & 255
+        pipe.write_external_frame(f"{prefix}rgb", rgb.copy(), hardware_ns=0)
+        if pipe._writer is None:
+            return
+        ns = time.monotonic_ns()
+        pipe.write_tactile_force("left", [1.5, 2.5, 3.5], prefix=prefix,
+                                 capture_ns=ns)
+        pipe.write_tactile_force("right", [4.5, 5.5, 6.5], prefix=prefix,
+                                 capture_ns=ns)
+        if state["n"] % 5 == 0:
+            pipe.write_tactile_force_matrix(
+                "left", encode_gripper_force_matrix(matrix, spec),
+                prefix=prefix, capture_ns=ns)
+            pipe.write_tactile_force_matrix(
+                "right", encode_gripper_force_matrix(matrix, spec),
+                prefix=prefix, capture_ns=ns)
+        pipe.write_gripper_state([55.0, 1.0, 900.0], prefix=prefix)
+        pipe.write_slam_trajectory([0.1, 0.2, 0.3, 0.0, 0.0, 0.0, 1.0,
+                                    float(state["n"]) * 0.03], prefix=prefix,
+                                   timestamp=float(state["n"]) * 0.03,
+                                   host_ns=time.monotonic_ns())
+        if time.time() - t0 >= DURATION_E:
+            feed_timer.stop()
+            pipe.finish_recording("")
+
+    feed_timer = QTimer()
+    feed_timer.timeout.connect(feed)
+    feed_timer.start(30)
+
+    t_end = time.time() + 20
+    while not finished and time.time() < t_end:
+        app.processEvents()
+        time.sleep(0.01)
+    assert finished, "未收到 recording_finished"
+    task_dir = finished[0]
+    ep = pipe.last_episode_index
+
+    tbl = pq.read_table(pooled_data_parquet_path(task_dir, ep))
+    cols = tbl.column_names
+    for side in ("left", "right"):
+        for suffix in ("force", "force_ns", "force_matrix", "force_matrix_ns"):
+            name = f"observation.{prefix}gripper_{side}_{suffix}"
+            assert name in cols, f"缺 rig2 列 {name}（有: {cols}）"
+    for bare in ("observation.gripper_state", "observation.slam_trajectory",
+                 "observation.gripper_left_force"):
+        assert bare not in cols, f"rig2 录制不该有裸 rig1 列 {bare}"
+    # rig2 的逐点宿主时刻列：与轨迹同序等长（下标即配对）是本列的硬契约
+    ns_col = f"observation.{prefix}slam_trajectory_ns"
+    assert ns_col in cols, f"缺 rig2 时刻列 {ns_col}（有: {cols}）"
+    traj2 = tbl.column(f"observation.{prefix}slam_trajectory").to_pylist()
+    ns2 = tbl.column(ns_col).to_pylist()
+    assert all(len(a) // 8 == len(b) for a, b in zip(traj2, ns2)), \
+        "rig2 轨迹点列与时刻列长度不同步"
+    assert any(ns2), "rig2 时刻列全空（写了 host_ns 却没落盘）"
+    assert all(all(v > 0 for v in b) for a, b in zip(traj2, ns2) if a), \
+        "rig2 有点的行出现了 0 时刻（与「0=未知」的约定混淆）"
+    info = json.load(open(pooled_info_path(task_dir), encoding="utf-8"))
+    feat = info["features"][
+        f"observation.{prefix}gripper_left_force_matrix"]
+    expect = settings.GRIPPER_FORCE_MATRIX_SCALES.get(spec) or 1
+    assert feat["scale"] == expect, f"rig2 倍率未登记: {feat} != {expect}"
+    print(f"  E: rig2 前缀列全在（{tbl.num_rows} 行），"
+          f"无 rig1 裸列，features.scale={feat['scale']}")
+    print("  E: PASS")
+    return 0
+
+
+# ── 路径 F: 编码器搬家回归（主程序 re-export 同一函数对象）──
+
+def path_f():
+    try:
+        import ui.main_window as mw
+    except Exception as exc:
+        print(f"  F: 跳过（ui.main_window 不可导入: {type(exc).__name__}: {exc}）")
+        return 0
+    assert mw.encode_gripper_force_matrix is encode_gripper_force_matrix, \
+        "ui.main_window 未从 core.gripper_codec re-export（出现第二份实现）"
+    assert (mw.describe_gripper_matrix_spec
+            is __import__("core.gripper_codec", fromlist=["x"]
+                          ).describe_gripper_matrix_spec), \
+        "describe_gripper_matrix_spec 未 re-export"
+    print("  F: ui.main_window 的编码器就是 core.gripper_codec 那个函数对象")
+    print("  F: PASS")
+    return 0
+
+
+def main():
+    for fn in (path_d, path_e, path_f):
+        rc = fn()
+        if rc:
+            return rc
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

collector/tools/tests/lite_import_guard_test.py

@@ -43,7 +43,10 @@ BLACKLIST = [
     "core.task_service", "core.glove_keypoint_solver",
     "core.render_engine", "core.sensor_hand_config",
     "core.hand_tracking", "core.hand_processor", "core.auto_labeler",
-    "core.s80m_manager", "core.session_loader", "core.session_timeline",
+    # 注：core.s80m_manager 2026-09-16 起**在 lite 闭包内**（UMI 夹爪的
+    # core/gripper/bridge.py 顶层 import 它的丢帧常量），已从禁止名单移出，
+    # 与 core/gripper/* 一起由下面的夹爪闭包段断言。
+    "core.session_loader", "core.session_timeline",
     "core.session_catalog", "core.recording_repository",
     "core.task_record", "core.device_manager", "core.device_naming",
     "core.exposure_controller",
@@ -58,6 +61,8 @@ WHITELIST = [
     "core.d435_camera", "core.camera", "core.device_detector",
     "core.ble_engine", "core.usb_glove_engine",
     "core.uploader", "core.api_client", "core.database", "core.helpers",
+    # 力矩阵编码的家（ui.main_window 只是 re-export）—— lite 直接用
+    "core.gripper_codec",
 ]
 
 
@@ -68,6 +73,18 @@ def main():
     win.close()
     app.processEvents()
 
+    # 夹爪闭包：扫描线程只在**真有夹爪插着**时才走到 core.gripper.bridge，
+    # 且它在后台线程里（win.close() 早于它完成 → 断言会 flaky），所以这里
+    # 显式导入一遍，让下面的禁止名单覆盖整个夹爪闭包 —— 确认它没把
+    # torch/scipy 之类的重依赖拖进来（那是 lite 体积与客户机装不上的红线）。
+    # 只在 Linux 上有意义：原生栈是 ELF，且 core/gripper 顶层 `import fcntl`
+    # 在 Windows 上直接导入失败——那正是 Windows 包的预期降级路径。
+    gripper_state = "跳过（非 Linux）"
+    if sys.platform.startswith("linux"):
+        import core.gripper.bridge   # noqa: F401
+        import core.s80m_manager     # noqa: F401
+        gripper_state = "已导入并断言"
+
     bad = sorted(m for m in BLACKLIST
                  if any(k == m or k.startswith(m + ".")
                         for k in sys.modules))
@@ -86,7 +103,7 @@ def main():
         print("FAIL")
         return 1
     print(f"PASS: {len(WHITELIST)} 个白名单模块全部就位，"
-          f"禁止名单无导入，编码器探针已关闭")
+          f"禁止名单无导入，编码器探针已关闭，夹爪闭包 {gripper_state}")
     return 0
 
 

collector/tools/tests/probe_gripper_rates.py

@@ -57,8 +57,11 @@ def main():
         def on_stereo(slot, frame, hw_ns, s=s):
             s["stereo_l"] += 1
 
-        def on_pose(pos, quat, traj=(), timestamp=None, s=s):
+        def on_pose(pos, quat, traj=(), timestamp=None, host_ns=None, s=s):
             s["pose"] += 1
+            # host_ns 只在签名里显式收下、本探针不消费：PyQt5 会把多余实参
+            # 静默截断给「收得少」的槽，漏写这个参数不会报错只会悄悄丢戳，
+            # 所以宁可显式列出也不靠截断兜底。
             if s["pose_first"] is None:
                 s["pose_first"] = time.monotonic()
                 raw = b._raw_client

collector/tools/tests/smoke_gripper_p3.py

@@ -54,12 +54,18 @@ def main():
                   f"{'None' if matrix is None else matrix.shape}",
                   flush=True)
 
-    def on_pose(pos, quat, traj=(), timestamp=None):
+    def on_pose(pos, quat, traj=(), timestamp=None, host_ns=None):
         stats["pose"] += 1
         stats["last_pos"] = pos
+        # host_ns 是取样帧的宿主单调钟纳秒（与 hardware_ns 同时基）；None =
+        # 当前 native 二进制未打印 Host 字段（只做了 Python 侧改动、没重编
+        # 原生库时的预期状态）。真机验收时应看到非 None、且逐点单调递增。
+        if host_ns is not None:
+            stats["host_ns_last"] = host_ns
         if stats["pose"] <= 3 or stats["pose"] % 100 == 0:
             print(f"[POSE] #{stats['pose']} pos={tuple(pos)} "
-                  f"quat={tuple(quat)}", flush=True)
+                  f"quat={tuple(quat)} t={timestamp} "
+                  f"host_ns={host_ns}", flush=True)
 
     def on_opened():
         print("[OPENED] 相机 + 触觉 + SLAM 链路就绪", flush=True)

collector/tools/tests/test_gripper_bridge.py

@@ -190,8 +190,8 @@ def _run_open_flow(fail_select=None, wait_ready=True, ready_errors=(),
         lambda s, h, f, m, ns: stats["tactile"].append(
             (s, tuple(f), m, ns)))
     bridge.pose_ready.connect(
-        lambda p, q, t, ts: stats["pose"].append(
-            (tuple(p), tuple(q), tuple(t), ts)))
+        lambda p, q, t, ts, ns: stats["pose"].append(
+            (tuple(p), tuple(q), tuple(t), ts, ns)))
     bridge.gripper_state_ready.connect(
         lambda payload: stats["state"].append(payload))
     bridge.opened.connect(lambda: stats.__setitem__(
@@ -330,21 +330,34 @@ def main():
           "paired 两包配对只发左目、右目包丢弃")
     bridge2.deleteLater()
 
-    # SLAM 位姿投递（pos3 + quat4 + 轨迹元组 + timestamp）
+    # SLAM 位姿投递（pos3 + quat4 + 轨迹元组 + timestamp + 宿主时刻）
     pose_count = len(stats["pose"])
     pose = SimpleNamespace(position=(1.0, 2.0, 3.0),
-                           rotation=(0.0, 0.0, 0.0, 1.0), timestamp=0.5)
+                           rotation=(0.0, 0.0, 0.0, 1.0), timestamp=0.5,
+                           host_mono_ns=287607702508638)
     bridge._on_slam_pose(pose)
     _pump_until(lambda: len(stats["pose"]) == pose_count + 1)
     check(stats["pose"][-1] == ((1.0, 2.0, 3.0), (0.0, 0.0, 0.0, 1.0),
-                                ((1.0, 2.0, 3.0),), 0.5),
-          "pose_ready 信号携带 pos/quat/traj/timestamp")
+                                ((1.0, 2.0, 3.0),), 0.5,
+                                287607702508638),
+          "pose_ready 信号携带 pos/quat/traj/timestamp/host_ns")
+    # 无 host_mono_ns 的位姿（旧 native 二进制 / 外部实现）也必须正常投递，
+    # 戳缺失只是让下游退回行号配对，不该断掉整条位姿流
+    pose_legacy = SimpleNamespace(position=(1.5, 2.5, 3.5),
+                                  rotation=(0.0, 0.0, 0.0, 1.0),
+                                  timestamp=0.55)
+    bridge._on_slam_pose(pose_legacy)
+    _pump_until(lambda: len(stats["pose"]) == pose_count + 2)
+    check(stats["pose"][-1][4] is None,
+          "缺 host_mono_ns 的位姿投递为 None（不抛异常）")
     # 第二个位姿追加进轨迹（同一元组缓存对象随新点重建）
     pose2 = SimpleNamespace(position=(2.0, 3.0, 4.0),
-                            rotation=(0.0, 0.0, 0.0, 1.0), timestamp=0.6)
+                            rotation=(0.0, 0.0, 0.0, 1.0), timestamp=0.6,
+                            host_mono_ns=287607702641000)
     bridge._on_slam_pose(pose2)
-    _pump_until(lambda: len(stats["pose"]) == pose_count + 2)
-    check(stats["pose"][-1][2] == ((1.0, 2.0, 3.0), (2.0, 3.0, 4.0)),
+    _pump_until(lambda: len(stats["pose"]) == pose_count + 3)
+    check(stats["pose"][-1][2] == ((1.0, 2.0, 3.0), (1.5, 2.5, 3.5),
+                                   (2.0, 3.0, 4.0)),
           "轨迹随位姿滚动累积")
 
     # P4 串口链接线：构造注入 on_board_update/on_grip_check，握手用 esp_tty

collector/tools/tests/test_gripper_pose_axes.py

@@ -150,7 +150,19 @@ def main():
                        atol=1e-12):
         failures.append("双应用旋转应为 R_z(+180°)·R")
 
-    # 7. 轨迹形状不变（等距）：相邻点距离一致
+    # 7. host_mono_ns（取样帧宿主时刻）必须原样透传：rotate_pose_z90 是
+    #    纯世界重标、不动时基。丢了它位姿就退回"只能按行号/相机钟对齐"，
+    #    而落盘侧正是靠它与 hardware_ns 直接比较来配 slam 点↔视频帧。
+    stamped = PoseSample(position=(1.0, 2.0, 3.0),
+                         rotation=random_unit_quaternion(rng), timestamp=1.0,
+                         host_mono_ns=287607702508638)
+    if rotate_pose_z90(stamped).host_mono_ns != 287607702508638:
+        failures.append("rotate_pose_z90 丢了 host_mono_ns")
+    # 无戳（旧 native 二进制）透传 None，不能被伪造成 0
+    if rotate_pose_z90(pose).host_mono_ns is not None:
+        failures.append("无戳位姿的 host_mono_ns 应为 None")
+
+    # 8. 轨迹形状不变（等距）：相邻点距离一致
     traj = [
         PoseSample(position=tuple(float(v) for v in rng.uniform(-1, 1, 3)),
                    rotation=random_unit_quaternion(rng), timestamp=float(i))

collector/tools/tests/test_gripper_pose_host_stamp.py

@@ -0,0 +1,143 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""位姿行 Host 字段（取样帧宿主时刻）解析契约自检（离线，无硬件）。
+
+    venv/bin/python tools/tests/test_gripper_pose_host_stamp.py
+
+背景：`slam_trajectory` 每点的 `t` 是**相机传感器钟**，而视频行的
+`hardware_ns` 是**宿主单调钟**，两者不同源、只差一个只能拟合的偏移
+（实测反推估计散布 ~104ms，已超一个帧间隔）。v1.3.6 起 native 在取样帧
+进进程时取一次 CLOCK_MONOTONIC，随帧走到 stdout：
+
+    [0.0000] XYZ:(...) Quat:(...) Host:(287607702508638)
+
+本测试钉死解析侧的向后兼容：**现场已部署的旧 native 二进制不打印 Host
+字段**，Python 侧升级后必须照旧能解析那些行（host_mono_ns = None），
+否则整条位姿流会断——采集链路直接不可用。
+
+覆盖:
+  1. 新格式（带 Host）→ 全部字段正确、host_mono_ns 取到
+  2. 旧格式（无 Host）→ 照旧解析，host_mono_ns = None（向后兼容）
+  3. 带 Δq 第二行的变体：首行仍解析出位姿（正则只吃首行）
+  4. Host 值畸形/缺失不污染其他字段
+  5. 宿主戳是 int 不是 float（纳秒精度不能被浮点吃掉）
+  6. 落盘链路的两步变换（rotate_pose_z90 + dataclasses.replace）
+     都不丢戳、不改戳
+退出码 0 = 全部通过。
+"""
+
+from __future__ import annotations
+
+import dataclasses
+import os
+import sys
+
+REPO_ROOT = os.path.dirname(os.path.dirname(os.path.dirname(
+    os.path.abspath(__file__))))
+sys.path.insert(0, REPO_ROOT)
+
+from core.gripper.slam.protocol import (                    # noqa: E402
+    _parse_pose, quat_conjugate, quat_product, rotate_pose_z90,
+)
+
+# 与 core/gripper/native/.../fayssense_orb_slam.cc 的 printf 逐字对应
+NEW_LINE = ("[1.2345] XYZ:(0.1000,-0.2000,0.3000) "
+            "Quat:(w=1.0000,x=0.0000,y=0.0000,z=0.0000) "
+            "Host:(287607702508638)")
+OLD_LINE = ("[1.2345] XYZ:(0.1000,-0.2000,0.3000) "
+            "Quat:(w=1.0000,x=0.0000,y=0.0000,z=0.0000)")
+DQ_LINE = ("[2.0000] XYZ:(1.0000,2.0000,3.0000) "
+           "Quat:(w=0.7071,x=0.7071,y=0.0000,z=0.0000) "
+           "Host:(287607705000000)\n"
+           "       Δq(10f):1.23° axis=(0.000,0.000,1.000)")
+
+_FAILS: list[str] = []
+
+
+def check(name: str, cond: bool, detail: str = ""):
+    tag = "PASS" if cond else "FAIL"
+    print(f"  [{tag}] {name}" + (f" — {detail}" if detail else ""))
+    if not cond:
+        _FAILS.append(name)
+
+
+def main() -> int:
+    print("[1] 新格式（native 已重编，带 Host 字段）")
+    pose = _parse_pose(NEW_LINE)
+    check("解析成功", pose is not None)
+    check("position 正确", pose.position == (0.1, -0.2, 0.3),
+          str(pose.position))
+    check("rotation 正确（w 在前 → 内部 x,y,z,w）",
+          pose.rotation == (0.0, 0.0, 0.0, 1.0), str(pose.rotation))
+    check("timestamp 正确", abs(pose.timestamp - 1.2345) < 1e-12,
+          str(pose.timestamp))
+    check("host_mono_ns = 287607702508638",
+          pose.host_mono_ns == 287607702508638, str(pose.host_mono_ns))
+    check("宿主戳是 int 不是 float（纳秒精度不被浮点吃掉）",
+          isinstance(pose.host_mono_ns, int)
+          and not isinstance(pose.host_mono_ns, bool),
+          type(pose.host_mono_ns).__name__)
+    check("valid 通过", pose.valid)
+
+    print("[2] 旧格式（现场已部署的 native 二进制，不打印 Host）")
+    old = _parse_pose(OLD_LINE)
+    check("照旧解析成功（否则整条位姿流会断）", old is not None)
+    check("几何字段与新版一致", old.position == pose.position
+          and old.rotation == pose.rotation
+          and abs(old.timestamp - pose.timestamp) < 1e-12)
+    check("host_mono_ns = None（不是 0）",
+          old.host_mono_ns is None, repr(old.host_mono_ns))
+    check("valid 通过（无戳不影响位姿有效性）", old.valid)
+
+    print("[3] Δq 变体：正则只吃首行，第二行不干扰")
+    dq = _parse_pose(DQ_LINE)
+    check("解析成功", dq is not None)
+    check("取到首行位姿", dq.position == (1.0, 2.0, 3.0), str(dq.position))
+    check("取到首行宿主戳", dq.host_mono_ns == 287607705000000,
+          str(dq.host_mono_ns))
+
+    print("[4] Host 畸形/截断不污染其他字段")
+    for bad, why in (
+        ("[1.0] XYZ:(1.0,2.0,3.0) Quat:(w=1.0,x=0.0,y=0.0,z=0.0) Host:()",
+         "空括号"),
+        ("[1.0] XYZ:(1.0,2.0,3.0) Quat:(w=1.0,x=0.0,y=0.0,z=0.0) Host:(abc)",
+         "非数字"),
+        ("[1.0] XYZ:(1.0,2.0,3.0) Quat:(w=1.0,x=0.0,y=0.0,z=0.0) Host:(12",
+         "括号未闭合"),
+        ("[1.0] XYZ:(1.0,2.0,3.0) Quat:(w=1.0,x=0.0,y=0.0,z=0.0) Host:123",
+         "缺括号"),
+    ):
+        got = _parse_pose(bad)
+        check(f"{why}：位姿字段仍完好、戳退化为 None",
+              got is not None and got.position == (1.0, 2.0, 3.0)
+              and got.host_mono_ns is None,
+              f"pose={None if got is None else got.position} "
+              f"ns={None if got is None else got.host_mono_ns}")
+
+    print("[5] 落盘链路两步变换不丢戳/不改戳")
+    # _publish_pose 实际做的是：rotate_pose_z90 → dataclasses.replace
+    # （原点后姿态相对化）。两步都必须原样带过宿主戳。
+    rolled = rotate_pose_z90(pose)
+    check("rotate_pose_z90 透传", rolled.host_mono_ns == 287607702508638,
+          str(rolled.host_mono_ns))
+    zero = (0.7071051, 0.0, 0.0, -0.7071051)
+    relativized = dataclasses.replace(
+        rolled,
+        rotation=quat_product(quat_conjugate(zero), rolled.rotation))
+    check("dataclasses.replace 相对化后仍在",
+          relativized.host_mono_ns == 287607702508638,
+          str(relativized.host_mono_ns))
+    check("位置/时间戳未被这两步改动",
+          relativized.position == rolled.position
+          and relativized.timestamp == rolled.timestamp)
+
+    print()
+    if _FAILS:
+        print(f"FAILED: {len(_FAILS)} 项 — {_FAILS}")
+        return 1
+    print("ALL PASS")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

collector/tools/tests/test_gripper_slam_columns.py

@@ -17,6 +17,12 @@ slam_trajectory（变长、每点带真实时间戳）信息严格更多，故
   3. 双 rig 前缀命名空间互不干扰
   4. 删分支后 state / force / force_matrix 仍各按原类型落盘（没被 else 误吞）
   5. 全空 episode（一帧夹爪数据都没有）不建任何夹爪列，且不抛异常
+  6. slam_trajectory_ns → 类型必须是 list<int64> 而非标量 int64（钉死
+     「专用分支排在通用 _ns 之前」）、与 slam_trajectory 逐行等长、
+     features dtype/shape/encoding
+  7. pipeline 侧 write_slam_trajectory/_pop_gripper_snapshots：时刻与点
+     锁步、缺戳补 0 不跳过、弹出后清空、全程无戳（旧 native 二进制）
+     不建 _ns 列
 退出码 0 = 全部通过。
 """
 
@@ -193,6 +199,78 @@ def main() -> int:
         check("features 无任何 slam 键",
               not [k for k in read_features(os.path.join(tmp, "none"))
                    if "slam_" in k])
+
+        print("[6] slam_trajectory_ns = 逐点并行宿主时刻（list<int64>，非标量）")
+        # 分支顺序陷阱：slam_trajectory_ns 也以 _ns 结尾，若排在通用 _ns
+        # 分支之后就会被落成"每行一个标量 int64"——一行 2 个点只剩 1 个
+        # 时刻，与点列表错位且下游无从察觉。这里用类型把它钉死。
+        NS2 = [287607702508638, 287607702575000]
+        w6 = build(os.path.join(tmp, "trajns"), [
+            {"slam_trajectory": TRAJ, "slam_trajectory_ns": NS2},
+            {},                                        # 空窗口 → []
+            {"slam_trajectory": TRAJ[:8],
+             "slam_trajectory_ns": [287607702641000]},  # 单点窗口
+        ])
+        w6._write_data_parquet()
+        w6._write_info_json()
+        colns = "observation.slam_trajectory_ns"
+        schema6 = read_schema(os.path.join(tmp, "trajns"))
+        check("列类型 = list<int64>（不是标量 int64）",
+              schema6.field(colns).type == pa.list_(pa.int64()),
+              str(schema6.field(colns).type))
+        check("确实是 list 而非标量 —— 分支顺序未被通用 _ns 抢先",
+              not schema6.field(colns).type.equals(pa.int64()))
+        gotns = read_col(os.path.join(tmp, "trajns"), colns)
+        check("多点点值逐位往返（两个点两个时刻）",
+              gotns[0] == NS2, str(gotns[0]))
+        check("无样本帧是 [] 而不是 0", gotns[1] == [], str(gotns[1]))
+        check("单点窗口 = 1 值", gotns[2] == [287607702641000], str(gotns[2]))
+        # 与 slam_trajectory 同序等长是本列的**全部意义**，逐行核对
+        traj6 = read_col(os.path.join(tmp, "trajns"),
+                         "observation.slam_trajectory")
+        check("逐行与 slam_trajectory 等长（下标即配对）",
+              all(len(a) // 8 == len(b) for a, b in zip(traj6, gotns)),
+              str([(len(a) // 8, len(b)) for a, b in zip(traj6, gotns)]))
+        feats6 = read_features(os.path.join(tmp, "trajns"))[colns]
+        check("features dtype=int64 / shape=[1]",
+              feats6["dtype"] == "int64" and feats6["shape"] == [1],
+              str(feats6))
+        check("features encoding=flat_parallel_to_slam_trajectory",
+              feats6.get("encoding") == "flat_parallel_to_slam_trajectory",
+              str(feats6))
+
+        print("[7] pipeline 侧：时刻与点锁步累积、无戳补 0、全无戳不建列")
+        from core.pipeline import CameraPipeline          # noqa: E402
+        p7 = CameraPipeline()
+        p7._writer = object()      # 非 None 即可（write_slam_trajectory 只判非空）
+        p7._recording = True
+        p7.write_slam_trajectory(POSE7, timestamp=10.0,
+                                 host_ns=287607702508638)
+        p7.write_slam_trajectory(POSE7, timestamp=10.02)          # 无戳
+        p7.write_slam_trajectory(POSE7, timestamp=10.04,
+                                 host_ns=287607702575000)
+        snap7 = p7._pop_gripper_snapshots()
+        check("三点窗口点/刻长度同步",
+              len(snap7["slam_trajectory"]) // 8 == 3
+              and len(snap7["slam_trajectory_ns"]) == 3,
+              f"{len(snap7['slam_trajectory']) // 8} vs "
+              f"{len(snap7['slam_trajectory_ns'])}")
+        check("缺戳点补 0 而不是被跳过（否则后续点全部错位）",
+              snap7["slam_trajectory_ns"] == [287607702508638, 0,
+                                              287607702575000],
+              str(snap7["slam_trajectory_ns"]))
+        check("弹出后累加器清空",
+              p7._pop_gripper_snapshots() == {}
+              and not p7._gripper_traj_ns)
+        p7b = CameraPipeline()
+        p7b._writer = object()
+        p7b._recording = True
+        p7b.write_slam_trajectory(POSE7, timestamp=1.0)           # 全程无戳
+        snap7b = p7b._pop_gripper_snapshots()
+        check("旧二进制（全程无戳）不建 _ns 列",
+              "slam_trajectory" in snap7b
+              and "slam_trajectory_ns" not in snap7b,
+              str(sorted(snap7b)))
     finally:
         shutil.rmtree(tmp, ignore_errors=True)
 

collector/ui/lite_window.py

@@ -6,10 +6,17 @@
 qt_material/mediapipe 及 ui.main_window 等），导入闭包由
 tools/tests/lite_import_guard_test.py 断言守护。
 
-设备范围（每类 1 台）:
+设备范围（每类 1 台；夹爪最多 2 台）:
   - D435 深度相机: RGB(1280×720) + 深度(848×480) 两路录制
+  - UVC 摄像头:    单路 RGB 录制
   - USB-C 手套:    UsbGloveEngine（触觉 + IMU 四元数，无骨架解算）
   - BLE 手套:      SensorBLEEngine（触觉）
+  - UMI 夹爪:      GripperBridge 全链（RGB 录制 + 触觉力/力矩阵 + SLAM
+                   轨迹），**只录不显** —— 无热力图/轨迹/开合板控件，
+                   预览区与主程序无夹爪时完全一致。原生资源
+                   （core/gripper/native，~470MB）缺失时扫描不到设备：
+                   Windows 包不带该资源，于是五组设备框照常都在（和没插
+                   D435 时一样），「UMI 夹爪」那一组里面是空的。
 """
 
 from __future__ import annotations
@@ -39,11 +46,14 @@ from core.d435_camera import D435Worker, list_d400_devices
 from core.d435_manager import D435DeviceManager
 from core.device_detector import (DeviceInfo, _list_ble_devices,
                                   _list_d435_devices,
+                                  _list_gripper_devices,
                                   _list_usb_glove_devices,
                                   _list_uvc_devices,
                                   set_ble_scan_suppressed,
                                   usb_glove_prefer_side)
 from core.encoder_probe import list_working_ffmpegs
+from core.gripper_codec import (describe_gripper_matrix_spec,
+                               encode_gripper_force_matrix)
 from core.helpers import delete_pooled_episode, format_duration
 from core.pipeline import CameraPipeline
 from core.uploader import UploadManager
@@ -63,6 +73,7 @@ LITE_PREVIEW_W, LITE_PREVIEW_H = 640, 360
 LITE_UVC_W, LITE_UVC_H = 640, 480   # UVC 采集分辨率（低端机友好）
 LITE_UVC_FPS = 30                   # UVC 采集帧率（=录制帧率）；预览刷新仍限 15
 LITE_UVC_SLOT = "uvc_rgb"           # UVC 固定槽名（与 d435_rgb 同规格）
+LITE_GRIPPER_MAX = 2                # 同时开启的夹爪上限（rig1/rig2）
 
 # 内置暗色 QSS（替代 qt-material 主题，~20 行）
 LITE_QSS = f"""
@@ -356,15 +367,19 @@ class LiteWindow(QMainWindow):
 
     构造注入点（与 MainWindow 同口径，供离线测试替身）:
         LiteWindow(pipeline=None, upload_manager=None, d435_worker_cls=None,
-                   uvc_capture=None)
+                   uvc_capture=None, gripper_bridge_cls=None)
     """
 
-    _scan_result = pyqtSignal(list, list, list, list)   # (d435, usb, ble, uvc)
+    # (d435, usb, ble, uvc, gripper)
+    _scan_result = pyqtSignal(list, list, list, list, list)
 
     def __init__(self, pipeline: Optional[CameraPipeline] = None,
                  upload_manager: Optional[LiteUploadManager] = None,
-                 d435_worker_cls=None, uvc_capture=None):
+                 d435_worker_cls=None, uvc_capture=None,
+                 gripper_bridge_cls=None):
         # uvc_capture: 测试注入的 cv2.VideoCapture 替身（真实环境为 None）
+        # gripper_bridge_cls: 测试注入的假桥（非 None 时跳过资源闸门，
+        # 与 d435_worker_cls 同口径）
         super().__init__()
         self.setWindowTitle(tr("DAQ 极简采集 (lite v{})", settings.APP_VERSION))
 
@@ -376,6 +391,7 @@ class LiteWindow(QMainWindow):
         self._d435_worker_cls = d435_worker_cls or D435Worker
         self._d435_manager = D435DeviceManager(self._pipeline)
         self._uvc_capture = uvc_capture
+        self._gripper_bridge_cls = gripper_bridge_cls
 
         # 设备注册表: dev.key → d435 entry / {"kind": glove, "pump": …,
         # "engine": …, "role": …}
@@ -445,7 +461,8 @@ class LiteWindow(QMainWindow):
                 ("d435", tr("D435 深度相机"), ["_d435_key"]),
                 ("uvc", tr("UVC 摄像头"), ["_uvc_key"]),
                 ("usb", tr("USB-C 手套"), ["_usb_key"]),
-                ("ble", tr("BLE 手套"), ["_ble_key", "_ble_key2"])):
+                ("ble", tr("BLE 手套"), ["_ble_key", "_ble_key2"]),
+                ("gripper", tr("UMI 夹爪"), ["_gripper_key"])):
             grp = QGroupBox(title)
             gv = QVBoxLayout(grp)
             rows = []
@@ -577,16 +594,27 @@ class LiteWindow(QMainWindow):
             usb = _list_usb_glove_devices()
             ble = _list_ble_devices()
             uvc = _list_uvc_devices()
-            self._scan_result.emit(d435, usb, ble, uvc)
+            # 夹爪：_list_gripper_devices 内部先查 paths.gripper_resources_available()
+            # （native/ 未随包交付 → 空列表 → 组框照建、里面空着；Windows 上
+            # core.gripper 因顶层 import fcntl 直接导入失败，同样被它内部
+            # 的 except 兜成空列表）
+            gripper = _list_gripper_devices()
+            try:
+                self._scan_result.emit(d435, usb, ble, uvc, gripper)
+            except RuntimeError:
+                # 窗口已销毁（关窗时扫描线程仍在跑）—— 投递不出去是预期，
+                # 不必在测试/生产日志里留下吓人的线程回溯
+                pass
         finally:
             self._scan_busy = False
 
     def _on_scan_result(self, d435: List[DeviceInfo],
                         usb: List[DeviceInfo], ble: List[DeviceInfo],
-                        uvc: List[DeviceInfo]):
+                        uvc: List[DeviceInfo],
+                        gripper: List[DeviceInfo] = None):
         """扫描结果回填设备下拉框（保留当前选中/已开启项）。"""
         for kind, devs in (("d435", d435), ("usb", usb), ("ble", ble),
-                           ("uvc", uvc)):
+                           ("uvc", uvc), ("gripper", gripper or [])):
             for row in self._dev_groups[kind]:
                 combo = row["combo"]
                 open_key = getattr(self, row["attr"]) or ""
@@ -628,7 +656,8 @@ class LiteWindow(QMainWindow):
         openers = {"d435": self._open_d435,
                    "uvc": self._open_uvc,
                    "usb": self._open_usb_glove,
-                   "ble": lambda d: self._open_ble_glove(d, attr)}
+                   "ble": lambda d: self._open_ble_glove(d, attr),
+                   "gripper": self._open_gripper}
         if openers[kind](dev):
             row["btn"].setText(tr("关闭"))
             self._log(tr("[设备] 已开启 {}", dev.label))
@@ -660,6 +689,9 @@ class LiteWindow(QMainWindow):
             self._pipeline.unregister_external_source(entry["slots"][0])
             self._ring.pop(entry["slots"][0], None)
             self._recover_preview_source(entry["slots"][0])
+        elif kind == "gripper":
+            # 夹爪条目没有 "pump" 键，必须排在下面 else（手套）分支之前
+            self._close_gripper(key)
         else:
             pump = entry["pump"]
             try:
@@ -838,6 +870,378 @@ class LiteWindow(QMainWindow):
                      dev.serial or dev.label, role))
         return True
 
+    # ── UMI 夹爪（只录不显：无网格槽/热力图/轨迹/开合板控件）──
+    #
+    # lite 版 = main_window 夹爪链的裁剪：**数据链一字不改**（槽名、数据列、
+    # 桥接信号、力矩阵泵、CPU 预留），只删控件相关（网格槽、PoseViewQt、
+    # GripperSideWidget、双目显示节流）与 S80M 冲突检查（lite 无 S80M）。
+    # 落盘能力全在 core.pipeline / core.egodata_writer，已数据驱动。
+
+    @staticmethod
+    def _gripper_slot_map(index: int) -> dict:
+        """夹爪槽位表：rig1 保持旧槽名，rig2 加序号。
+
+        与 main_window._gripper_slot_map 逐字相同 —— 槽名是下游数据契约
+        （视频目录名 / parquet 列前缀），lite 与主程序录出的 episode 必须
+        同名，改这里等于改数据格式。
+        """
+        mid = "" if index == 1 else f"_{index}"
+        return {
+            "stereo_l": f"gripper{mid}_stereo_left",
+            "rgb": f"gripper{mid}_rgb",
+            "pose": f"gripper{mid}_pose",
+            "force_l": f"gripper{mid}_force_left",
+            "force_r": f"gripper{mid}_force_right",
+        }
+
+    def _open_gripper(self, dev: DeviceInfo) -> bool:
+        """开启 UMI 夹爪：建数据链（bridge + 槽注册 + CPU 预留），无画面控件。
+
+        双目槽只交给桥接做 SLAM 解算，不注册外部帧源 → 不产生视频、不落盘；
+        RGB 槽由首帧惰性注册（分辨率以实际首帧为准）。
+        双夹爪：打开顺序分配 rig 序号（1..2，关闭即释放），槽名/数据列
+        rig1 保持旧契约、rig2 带 "gripper_2_" 前缀。
+        """
+        if dev.key in self._workers:
+            return True   # 已开启（幂等）
+        gripper_count = sum(
+            1 for e in self._workers.values() if e.get("kind") == "gripper")
+        if gripper_count >= LITE_GRIPPER_MAX:
+            QMessageBox.warning(
+                self, tr("夹爪数量上限"),
+                tr("最多支持同时开启 {} 台 UMI 夹爪。\n"
+                   "请先关闭其中一台再开启。", LITE_GRIPPER_MAX))
+            self._log(tr("[设备] 夹爪数量已达上限，已拒绝开启: {}", dev.label))
+            return False
+        index = 1 if gripper_count == 0 else 2
+        # 资源闸门：native/ 未随包交付时拒绝开启（Windows 包即此路径）。
+        # 注入假桥时跳过 —— 与 _open_d435 的 worker_cls 口径一致
+        if self._gripper_bridge_cls is None:
+            try:
+                from core.gripper import paths
+                if not paths.gripper_resources_available():
+                    QMessageBox.warning(
+                        self, tr("夹爪资源缺失"),
+                        tr("未找到夹爪原生资源（core/gripper/native 未随包"
+                           "交付），无法开启。"))
+                    return False
+            except Exception:
+                return False
+        if not dev.serial:
+            QMessageBox.warning(
+                self, tr("夹爪无序列号"),
+                tr("未读取到夹爪 ESP32 序列号，无法唯一定位控制板。"))
+            return False
+
+        slot_map = self._gripper_slot_map(index)
+        bridge_cls = self._gripper_bridge_cls
+        if bridge_cls is None:
+            from core.gripper.bridge import GripperBridge
+            bridge_cls = GripperBridge
+        bridge = bridge_cls(self, stereo_slot=slot_map["stereo_l"],
+                            rig_index=index)
+        key = dev.key
+        # 帧信号按 dev.key lambda 捕获路由（双夹爪各自归位）。
+        # 桥接还有 stereo_frame_ready —— lite 不显示双目，故不接线（丢帧
+        # 统计在桥接内部 _stereo_drop_tick，录制结束由 _gripper_drop_summary 取）。
+        bridge.rgb_frame_ready.connect(
+            lambda frame, hw_ns, key=key:
+                self._on_gripper_rgb(key, frame, hw_ns))
+        bridge.tactile_ready.connect(
+            lambda side, heatmap, force, matrix, capture_ns, key=key:
+                self._on_gripper_tactile(key, side, heatmap, force, matrix,
+                                         capture_ns))
+        bridge.pose_ready.connect(
+            lambda position, quat, trajectory=(), timestamp=None,
+                   host_ns=None, key=key:
+                self._on_gripper_pose(key, position, quat, trajectory,
+                                      timestamp, host_ns))
+        bridge.gripper_state_ready.connect(
+            lambda payload, key=key: self._on_gripper_state(key, payload))
+        bridge.log.connect(self._log)
+        bridge.error.connect(lambda msg, key=key: self._on_gripper_error(key, msg))
+        bridge.opened.connect(
+            lambda key=key: self._log(
+                tr("[夹爪] {} 相机 + 触觉 + SLAM 链路已就绪",
+                   self._workers.get(key, {}).get("label", key))))
+        entry = {"kind": "gripper", "label": dev.label,
+                 "serial": dev.serial or "",
+                 "slots": [slot_map["stereo_l"], slot_map["rgb"],
+                           slot_map["pose"], slot_map["force_l"],
+                           slot_map["force_r"]],
+                 "bridge": bridge, "fays_serial": "", "sensor_columns": [],
+                 "_video_registered": set(),      # RGB 槽惰性注册标记
+                 "matrix_pump_stop": None,        # 录制期力矩阵泵停止事件
+                 "gripper_index": index, "slot_map": slot_map,
+                 # 双夹爪数据列命名空间：rig1 空串（旧键 slam_trajectory/
+                 # gripper_state/gripper_{side}_force…不变），rig2 加前缀
+                 "snapshot_prefix": ("" if index == 1
+                                     else f"gripper_{index}_")}
+        self._workers[dev.key] = entry
+        # 非视频槽（pose/左右触觉）单独进 status 列
+        for sid in (slot_map["pose"], slot_map["force_l"], slot_map["force_r"]):
+            self._pipeline.register_gripper_device_id(sid)
+        self._pipeline.record_event(dev.key, "connected")
+        # CPU 预留（主线程掩码收窄，让本 rig 的 SLAM 分区与 raw 专用核不再被
+        # 主进程线程/ffmpeg 子进程抢占）——必须在 open() 派生各工作线程之前
+        # 生效（子线程继承受限掩码；native SLAM 走 taskset 显式设掩码不受影响）
+        try:
+            from core.gripper import affinity
+            affinity.reserve(index, self._log)
+        except Exception as exc:      # 预留失败不该拦下设备（lite 兜底）
+            self._log(tr("[夹爪] CPU 预留失败（忽略）: {}", exc))
+        bridge.open(dev.serial)
+        self._gripper_key = dev.key
+        self._log(tr("[夹爪] {} 正在启动相机/触觉/SLAM 链路…（只录不显）",
+                     dev.label))
+        return True
+
+    def _close_gripper(self, dev_key: str):
+        """关闭 UMI 夹爪：停泵 → 桥接逆序回收 → 注销数据列 → 退 CPU 预留。
+
+        槽位全部取自本条目 slot_map（rig2 前缀不同），关闭一台不碰另一台
+        的共享命名空间。lite 无网格槽/轨迹控件，故不删控件。
+        """
+        entry = self._workers.pop(dev_key, None)
+        if not entry or entry["kind"] != "gripper":
+            return
+        rig_index = entry.get("gripper_index") or 1
+        self._stop_matrix_pump(entry)
+        bridge = entry.get("bridge")
+        if bridge is not None:
+            try:
+                bridge.close()
+            except Exception as exc:
+                self._log(tr("[夹爪] 关闭桥接异常（忽略）: {}", exc))
+        # 退还本 rig 的 CPU 预留（掩码扩回；全部 rig 关闭后恢复完整掩码）
+        try:
+            from core.gripper import affinity
+            affinity.release(rig_index, self._log)
+        except Exception:
+            pass
+        slot_map = entry["slot_map"]
+        # 双目槽只供 SLAM 解算（从未注册外部帧源），只有 RGB 需要注销
+        self._pipeline.unregister_external_source(slot_map["rgb"])
+        for sid in (slot_map["pose"], slot_map["force_l"],
+                    slot_map["force_r"]):
+            self._pipeline.unregister_gripper_device_id(sid)
+        self._pipeline.record_event(dev_key, "disconnected")
+        # 直接调用本函数（错误路径/测试）时也要摘掉开着的标记，
+        # 否则面板按钮停在「关闭」、closeEvent 再也收不到这台
+        if self._gripper_key == dev_key:
+            self._gripper_key = ""
+
+    # ── 夹爪桥接信号（dev.key 路由，双夹爪各自归位）──
+
+    def _gripper_entry(self, dev_key: str):
+        entry = self._workers.get(dev_key)
+        if entry is None or entry.get("kind") != "gripper":
+            return None
+        return entry
+
+    def _gripper_entries(self) -> List[dict]:
+        """全部已开启夹爪条目（双夹爪录制时逐台处理）。"""
+        return [e for e in self._workers.values()
+                if e.get("kind") == "gripper"]
+
+    def _on_gripper_rgb(self, dev_key: str, frame, hw_ns: int):
+        """DECXIN RGB 帧（bridge 线程 → 队列回主线程）：首帧惰性注册外部
+        帧源（分辨率以实际首帧为准，帧率与主程序同口径 30），录制时写入
+        本 rig 的 RGB 视频槽。lite 无画面控件，帧不进预览也不显示。"""
+        entry = self._gripper_entry(dev_key)
+        if entry is None:
+            return
+        sid = entry["slot_map"]["rgb"]
+        if sid not in entry["_video_registered"]:
+            h, w = frame.shape[:2]
+            self._pipeline.register_external_source(sid, (h, w), fps=30.0)
+            entry["_video_registered"].add(sid)
+            self._log(tr("[夹爪] RGB 外部帧源已注册 {}x{}@30", w, h))
+        if self._pipeline.is_recording:
+            self._pipeline.write_external_frame(
+                sid, frame.copy(), hardware_ns=hw_ns)
+
+    def _on_gripper_pose(self, dev_key: str, position, quat, trajectory=(),
+                         timestamp=None, host_ns=None):
+        """SLAM 位姿（pos3, quat4, traj, t, host_ns）→ 轨迹点落盘（rig2 加前缀）。
+
+        轨迹并入 episode parquet，无 txt 侧车；t 与 host_ns 进
+        slam_trajectory / slam_trajectory_ns 列。位姿本身不落 slam_pose
+        列（2026-09-10 定案）。lite 无轨迹显示控件，trajectory/position/
+        quat 只用于拼落盘行。host_ns = 该取样帧的宿主单调钟纳秒（与
+        hardware_ns 同时基），是 slam 点与视频帧按时间对齐的依据。
+        """
+        entry = self._gripper_entry(dev_key)
+        if entry is None:
+            return
+        qx, qy, qz, qw = (float(value) for value in quat)
+        self._pipeline.write_slam_trajectory(
+            [float(position[0]), float(position[1]), float(position[2]),
+             qx, qy, qz, qw],
+            prefix=entry["snapshot_prefix"], timestamp=timestamp,
+            host_ns=host_ns)
+
+    def _on_gripper_tactile(self, dev_key: str, side, heatmap, force,
+                            force_matrix, capture_ns=0):
+        """触觉结果（左/右）：力值落盘；力矩阵由 P4 泵线程各自落盘。
+
+        capture_ns 是该样本的采集时刻，**必须随力值一起落盘** —— 力矩阵走
+        独立泵线程读最新单槽（恒最新），RGB 走主线程 FIFO（较旧），两者在
+        处理端靠这个时刻做最近邻对齐，丢了就再也对不上（见 v1.3.3 修复）。
+        lite 无热力图控件，heatmap/force_matrix 只用于保持信号签名一致。
+        """
+        entry = self._gripper_entry(dev_key)
+        if entry is None:
+            return
+        if force is not None and len(force) == 3:
+            self._pipeline.write_tactile_force(
+                side, force, prefix=entry["snapshot_prefix"],
+                capture_ns=capture_ns)
+
+    def _on_gripper_state(self, dev_key: str, payload):
+        """串口夹爪状态 {pct,gripped,fz,event,board} → gripper_state 稀疏列
+        快照（录制期随帧行落盘）。lite 无开合板控件。"""
+        entry = self._gripper_entry(dev_key)
+        if entry is None:
+            return
+        pct = payload.get("pct")
+        if pct is None:
+            return   # 板状态尚未到来：不写列（write 侧要求有限数值）
+        gripped = bool(payload.get("gripped", False))
+        fz = payload.get("fz", 0.0)
+        self._pipeline.write_gripper_state(
+            [float(pct), float(gripped), float(fz)],
+            prefix=entry["snapshot_prefix"])
+
+    def _on_gripper_error(self, dev_key: str, msg: str):
+        """桥接启动失败：弹窗 + 回收条目 + 面板按钮回退「开启」。"""
+        self._log(tr("[夹爪] 启动失败: {}", msg))
+        QMessageBox.critical(self, tr("夹爪启动失败"), msg)
+        # 先记下它是不是面板上开着的那台：_close_gripper 会把标记摘掉
+        was_open = self._gripper_key == dev_key
+        self._close_gripper(dev_key)
+        if was_open:
+            for row in self._dev_groups["gripper"]:
+                if row["attr"] == "_gripper_key":
+                    row["btn"].setText(tr("开启"))
+
+    def _gripper_drop_summary(self):
+        """录制结束汇总夹爪双目空桶统计（30fps 口径，有丢才打日志）。
+
+        只录不显时这是链路健康**唯一**的可见证据：双目取帧未达 30fps 就
+        意味着 SLAM 轨迹有缺帧，而画面上看不出来。
+        """
+        for entry in self._gripper_entries():
+            bridge = entry.get("bridge")
+            if bridge is None:
+                continue
+            dropped, elapsed = bridge.stereo_drop_snapshot()
+            if dropped > 0 and elapsed > 0:
+                self._log(tr("[夹爪] {} 本次录制双目空桶 {} 个（{:.0f}%）"
+                             "——SLAM 取帧未达 30fps，轨迹存在缺帧",
+                             entry.get("label", "UMI"),
+                             dropped, dropped / elapsed * 100))
+
+    # ── 力矩阵泵线程（录制期）──────────────────────────
+
+    def _start_matrix_pump(self):
+        """录制开始：为每台已开启的夹爪各起一个 30ms 力矩阵泵线程。
+
+        必须在 pipeline 的 start_episode 之后（recording_started 信号即
+        在它之后 emit），否则刚登记的倍率会被 start_episode 清掉。
+        """
+        started = 0
+        for entry in self._gripper_entries():
+            bridge = entry.get("bridge")
+            if bridge is None or entry.get("matrix_pump_stop") is not None:
+                continue
+            stop = threading.Event()
+            entry["matrix_pump_stop"] = stop
+            entry["matrix_wrote"] = {"left": 0, "right": 0}
+            # 规格在录制开始锁定：parquet 一列只有一种类型，录制中切换会让
+            # 同一列出现 int/float 混型（write 侧直接报错，整段录制废掉）。
+            spec = settings.GRIPPER_FORCE_MATRIX_SPEC
+            entry["matrix_spec"] = spec
+            # 倍率登记到 writer：×10/×100/×1000 落盘类型都是 int16，元素类型
+            # 分辨不出倍率，info.json features.scale 是唯一的对外凭据。
+            self._pipeline.set_force_matrix_spec(
+                entry["snapshot_prefix"], spec)
+            self._log(tr("[夹爪] 力矩阵保存规格：{}",
+                         describe_gripper_matrix_spec(spec)))
+            thread = threading.Thread(
+                target=self._matrix_pump_loop,
+                args=(bridge, stop, entry),
+                name="gripper-matrix-pump-{}".format(
+                    entry.get("gripper_index", "")),
+                daemon=True,
+            )
+            thread.start()
+            entry["matrix_pump_thread"] = thread
+            started += 1
+        if not started:
+            self._log(tr("[夹爪] 力矩阵泵未启动：无夹爪设备条目"))
+
+    def _matrix_pump_loop(self, bridge, stop, entry):
+        """泵线程体：仅在有新矩阵时编码（按本次录制锁定的规格）+ 快照写入。"""
+        last_seq = {"left": 0, "right": 0}
+        first_logged = {"left": False, "right": False}
+        wrote = entry["matrix_wrote"]
+        spec = entry.get("matrix_spec",
+                         settings.GRIPPER_FORCE_MATRIX_SPEC_DEFAULT)
+        started = time.monotonic()
+        self._log(tr("[夹爪] 力矩阵泵已启动 (L seq={} R seq={})",
+                     bridge.matrix_seq("left"),
+                     bridge.matrix_seq("right")))
+        while not stop.is_set():
+            for side in ("left", "right"):
+                seq = bridge.matrix_seq(side)
+                if seq == last_seq[side]:
+                    continue
+                last_seq[side] = seq
+                # 时刻与矩阵同锁取出（latest_matrix_stamped），保证配对；
+                # 泵线程与主线程各自落各自模态，所以矩阵的时刻单独记
+                stamped = bridge.latest_matrix_stamped(side)
+                if stamped is None:
+                    continue
+                capture_ns, matrix = stamped
+                try:
+                    encoded = encode_gripper_force_matrix(matrix, spec)
+                except Exception as exc:
+                    self._log(tr("[夹爪] 力矩阵编码失败 ({}): {}",
+                                 side, exc))
+                    continue
+                self._pipeline.write_tactile_force_matrix(
+                    side, encoded, prefix=entry["snapshot_prefix"],
+                    capture_ns=capture_ns)
+                wrote[side] += 1
+                if not first_logged[side]:
+                    first_logged[side] = True
+                    self._log(tr("[夹爪] {} 侧力矩阵首帧落盘 ({} 元素)",
+                                 "左" if side == "left" else "右",
+                                 len(encoded)))
+            if (time.monotonic() - started >= 10.0
+                    and not first_logged["left"]
+                    and not first_logged["right"]):
+                self._log(tr(
+                    "[夹爪] 力矩阵泵 10s 无新样本 (L seq={} R seq={})",
+                    bridge.matrix_seq("left"), bridge.matrix_seq("right")))
+                started = time.monotonic()
+            stop.wait(0.03)
+
+    def _stop_matrix_pump(self, entry):
+        """录制结束/设备关闭：停泵线程并等待退出。"""
+        stop = entry.get("matrix_pump_stop")
+        if stop is not None:
+            stop.set()
+            entry["matrix_pump_stop"] = None
+        thread = entry.pop("matrix_pump_thread", None)
+        if thread is not None and thread.is_alive():
+            thread.join(timeout=1.0)
+        wrote = entry.pop("matrix_wrote", None)
+        if wrote is not None:
+            self._log(tr("[夹爪] 力矩阵泵停止：L 写 {} 帧 R 写 {} 帧",
+                         wrote["left"], wrote["right"]))
+
     # ── 录制控制 ──────────────────────────────────────
 
     def _device_meta(self) -> List[dict]:
@@ -851,25 +1255,64 @@ class LiteWindow(QMainWindow):
                 meta.append({"key": key, "kind": "uvc", "name": e["label"],
                              "serial": e.get("serial", ""),
                              "slots": e["slots"]})
+            elif e.get("kind") == "gripper":
+                # 夹爪条目没有 "role" 键，必须显式分支（否则下面 else
+                # 取 e["role"] 直接 KeyError）
+                meta.append({"key": key, "kind": "gripper", "name": e["label"],
+                             "serial": e.get("serial", ""),
+                             "slots": e["slots"]})
             else:
                 meta.append({"key": key, "kind": e["kind"],
                              "name": e["label"], "serial": "",
                              "slots": [e["role"]]})
         return meta
 
+    def _master_video_slot(self) -> Optional[str]:
+        """本次录制的主视频源槽，没有可用主源时返回 None。
+
+        优先级 D435 → UVC → 夹爪 RGB。夹爪的 RGB 槽要到首帧才惰性注册
+        （bridge 启动要几秒），所以「开了夹爪但还没出图」也算没有主源。
+        """
+        if self._d435_key:
+            return settings.D435_SLOT_RGB
+        if self._uvc_key:
+            return LITE_UVC_SLOT
+        for entry in self._gripper_entries():
+            rgb = entry["slot_map"]["rgb"]
+            if rgb in entry["_video_registered"]:
+                return rgb
+        return None
+
+    def _reset_gripper_record_state(self):
+        """录制开始：重置夹爪双目 30fps 空桶看门狗 + 清空录制前累积的轨迹
+        （口径同 main_window._record_all；parquet 的 slam_trajectory 列由
+        writer 录制期独立累积，不受影响）。lite 无轨迹显示，清它只为让
+        「本次录制空桶」统计与主程序同口径。"""
+        for entry in self._gripper_entries():
+            bridge = entry.get("bridge")
+            if bridge is not None:
+                bridge.reset_stereo_drop_watch()
+                bridge.clear_trajectory()
+
     def _start_recording(self):
         if self._pipeline.is_recording:
             return
-        # pipeline.py:445 无源守卫 —— 无视频源无法录制，前置提示
-        # （D435 优先；只开 UVC 时 UVC 作主视频源）
-        if not self._d435_key and not self._uvc_key:
-            QMessageBox.warning(
-                self, tr("无法录制"),
-                tr("请先开启 D435 深度相机或 UVC 摄像头。\n"
-                   "录制必须有视频源。"))
+        # pipeline.py:474 无源守卫是**静默 return**（点了开始没反应），
+        # 故在前置检查里提示清楚
+        master = self._master_video_slot()
+        if master is None:
+            if self._gripper_entries():
+                QMessageBox.warning(
+                    self, tr("无法录制"),
+                    tr("夹爪视频尚未就绪（相机链路正在启动）。\n"
+                       "请稍候几秒再点「开始」，或先开启 D435 / UVC 摄像头。"))
+            else:
+                QMessageBox.warning(
+                    self, tr("无法录制"),
+                    tr("请先开启 D435 深度相机、UVC 摄像头或 UMI 夹爪。\n"
+                       "录制必须有视频源。"))
             return
-        master = (settings.D435_SLOT_RGB if self._d435_key
-                  else LITE_UVC_SLOT)
+        self._reset_gripper_record_state()
         self._pipeline.start_recording(
             master,
             task_name=self._task_edit.text().strip(),
@@ -885,6 +1328,9 @@ class LiteWindow(QMainWindow):
             self._pipeline.abort_recording("")
 
     def _on_recording_started(self, slot_id: str):
+        # 力矩阵泵最先启动：后续任何 UI 锁调用即使异常也不影响落盘
+        # （夹爪在场时启动泵线程，录制期才落 force_matrix 列）
+        self._start_matrix_pump()
         self._rec_status.setText(tr("⏺ 录制中"))
         self._btn_start.setEnabled(False)
         self._btn_stop.setEnabled(True)
@@ -892,6 +1338,11 @@ class LiteWindow(QMainWindow):
         self._set_device_buttons_enabled(False)
 
     def _on_recording_finished(self, slot_id: str, session_path: str):
+        # 空桶统计要在下一次录制重置看门狗之前取；停泵必须在写线程收尾前
+        # （口径同 main_window._stop_all / _on_recording_finished）
+        self._gripper_drop_summary()
+        for entry in self._gripper_entries():
+            self._stop_matrix_pump(entry)
         self._rec_status.setText(tr("待机"))
         self._btn_start.setEnabled(True)
         self._btn_stop.setEnabled(False)
@@ -924,6 +1375,10 @@ class LiteWindow(QMainWindow):
                              os.path.basename(session_path)))
 
     def _on_recording_aborted(self, slot_id: str):
+        # 中止走独立信号 recording_aborted，不经过 _on_recording_finished
+        # ——必须单独停泵，否则泵线程活到下段录制（主程序同口径）
+        for entry in self._gripper_entries():
+            self._stop_matrix_pump(entry)
         self._rec_status.setText(tr("待机"))
         self._btn_start.setEnabled(True)
         self._btn_stop.setEnabled(False)
@@ -1053,7 +1508,8 @@ class LiteWindow(QMainWindow):
 
     def closeEvent(self, event):
         self._scan_timer.stop()
-        for kind in ("d435", "uvc", "usb", "ble"):
+        # gripper 必须在列：漏了会让 SLAM/相机服务进程在关窗后残留、占住双目
+        for kind in ("d435", "uvc", "gripper", "usb", "ble"):
             for i, row in enumerate(self._dev_groups[kind]):
                 if getattr(self, row["attr"]):
                     try:

collector/ui/main_window.py

@@ -115,74 +115,11 @@ except ImportError:
     _GLOVE_AVAILABLE = False
 
 
-def encode_gripper_force_matrix(m: np.ndarray, spec: str = "int16") -> list:
-    """触觉力矩阵编码（P4 泵线程，返回扁平数值列表）。
-
-    spec 取 settings.GRIPPER_FORCE_MATRIX_SPECS 之一。
-
-    **注意**：省略 spec 时走的是函数签名默认 "int16"（兼容历史调用的冻结
-    契约），**不跟随工具栏的默认档**；生产路径（P4 泵）一律显式传入录制
-    开始时锁定的 spec，绝不省略。
-
-    "int16"（既有契约）：不缩放，与
-      online/recording/lerobot_v3.quantize_force_matrix 一致的有符号补码行
-      差分（mod 2^16 可逆），扩展到 (250,250,3) 三力平面：每行 250×3 个
-      元素横向差分；超出 ±32767 mN 饱和截断。**逐点 astype(int16) 是向零
-      截断，小数部分全部丢失**——实测真实录制里逐点值只剩 -3…8 的整数电平，
-      亚毫牛梯度（接触形状）不可恢复。保留向零截断是为了与历史录制逐位一致。
-
-    "int16xN"（N=10/100/1000，定标量化）：先 ×N 再四舍五入到整数存 int16，
-      解码端除以 N 还原，分辨率 1/N mN。饱和上限相应变为 ±32767/N mN
-      （×1000 即 ±32.767 mN）。定标档用 rint 而非截断：没有历史包袱，且
-      四舍五入把最大误差减半、不留系统性偏零。行差分与 int16 档完全相同，
-      所以仍然压得很小（×10 实测 0.122 字节/点，float32 的 1/6.5）。
-
-    "float32"（原值直存）：不做任何量化，把 (250,250,3) 按行展平成 250×750
-      的 float32 列表。无截断、无饱和，误差为 float32 本身的 ~1e-7 相对精度。
-      体积换精度：实测 0.797 字节/点（本段数据约为 int16 档的 119 倍）。
-
-    反解：整数档 reshape(-1,750) → cumsum(axis=1) → reshape(250,250,3)
-          （cumsum 走 int32 再截断回 int16 恢复 mod 2^16 回绕），
-          再按倍率 ÷N；float32 档 reshape(-1,750) → (250,250,3)。
-
-    ★ 返回的 Python 元素类型只区分「家族」：int = int16 系（**倍率无法从
-      元素类型看出**，×10 和 ×1000 都是 int），float = float32。
-      倍率必须由 info.json features.scale 携带，writer 与 demo 都按
-      scale + 列类型共同判别，不要只看元素类型。
-    """
-    if spec not in settings.GRIPPER_FORCE_MATRIX_SPECS:
-        raise ValueError(f"未知力矩阵规格 {spec!r}")
-    arr = np.asarray(m, dtype=np.float32)
-    if spec == "float32":
-        # 与整数档同为「扁平 250×750 列表」，只有元素类型不同：
-        # 读取端统一 reshape(-1,750) 后再按 dtype 决定是否 cumsum
-        return arr.reshape(-1).tolist()
-    scale = settings.GRIPPER_FORCE_MATRIX_SCALES[spec]
-    rows = int(arr.shape[0])
-    flat = arr.reshape(rows, -1)
-    if scale == 1:
-        q = np.clip(flat, -32767.0, 32767.0).astype(np.int16)
-    else:
-        # rint 后已是整数值，astype 的向零截断不再丢任何东西
-        q = np.clip(np.rint(flat * np.float32(scale)),
-                    -32767.0, 32767.0).astype(np.int16)
-    d = np.empty_like(q)
-    d[:, 0] = q[:, 0]
-    d[:, 1:] = q[:, 1:] - q[:, :-1]   # int16 mod 2^16 回绕
-    return np.frombuffer(d.tobytes(), dtype=np.int16).tolist()
-
-
-def describe_gripper_matrix_spec(spec: str) -> str:
-    """规格 → 人话（工具栏提示与日志共用，别在两处各写一份）。"""
-    if spec not in settings.GRIPPER_FORCE_MATRIX_SPECS:
-        return tr("未知规格 {}", spec)
-    scale = settings.GRIPPER_FORCE_MATRIX_SCALES.get(spec)
-    if scale is None:
-        return tr("float32 原值直存（无截断无饱和，体积最大）")
-    if scale == 1:
-        return tr("int16 行差分量化（1 mN 台阶、向零截断，体积最小）")
-    return tr("int16 定标 ×{}（分辨率 {} mN，饱和上限 ±{} mN）",
-              scale, 1.0 / scale, 32767.0 / scale)
+# 力矩阵编码与规格文案是**落盘契约**（家在 core/gripper_codec.py —— 极简版
+# lite 也要录夹爪，而 lite 的导入黑名单不含本模块，契约不能存两份）。
+# 这里 re-export，本窗口与 tools/tests/test_gripper_matrix_*.py 沿用旧路径。
+from core.gripper_codec import (  # noqa: E402,F401
+    encode_gripper_force_matrix, describe_gripper_matrix_spec)
 
 
 class MainWindow(QMainWindow):
@@ -1661,9 +1598,10 @@ class MainWindow(QMainWindow):
                 self._on_gripper_tactile(key, side, heatmap, force, matrix,
                                          capture_ns))
         bridge.pose_ready.connect(
-            lambda position, quat, trajectory=(), timestamp=None, key=key:
+            lambda position, quat, trajectory=(), timestamp=None,
+                   host_ns=None, key=key:
                 self._on_gripper_pose(key, position, quat, trajectory,
-                                      timestamp))
+                                      timestamp, host_ns))
         bridge.gripper_state_ready.connect(
             lambda payload, key=key: self._on_gripper_state(key, payload))
         bridge.log.connect(self._log)
@@ -1797,11 +1735,13 @@ class MainWindow(QMainWindow):
             widget.video_widget.set_frame(frame, flip_vertical=False)
 
     def _on_gripper_pose(self, dev_key: str, position, quat, trajectory=(),
-                         timestamp=None):
-        """SLAM 位姿（pos3, quat4, traj, t）：quat→3x3 驱动 PoseViewQt
-        （含轨迹） + 轨迹点落盘（rig2 加前缀）；t 随位姿进入
-        slam_trajectory 列（轨迹并入 episode parquet，无 txt 侧车）。
-        位姿本身不再落 slam_pose 列（2026-09-10 定案）。"""
+                         timestamp=None, host_ns=None):
+        """SLAM 位姿（pos3, quat4, traj, t, host_ns）：quat→3x3 驱动
+        PoseViewQt（含轨迹） + 轨迹点落盘（rig2 加前缀）；t 与 host_ns
+        随位姿进入 slam_trajectory / slam_trajectory_ns 列（轨迹并入
+        episode parquet，无 txt 侧车）。位姿本身不再落 slam_pose 列
+        （2026-09-10 定案）。host_ns = 该取样帧的宿主单调钟纳秒
+        （与 hardware_ns 同时基），是 slam 点与视频帧按时间对齐的依据。"""
         entry = self._gripper_entry(dev_key)
         if entry is None:
             return
@@ -1824,7 +1764,8 @@ class MainWindow(QMainWindow):
         self._pipeline.write_slam_trajectory(
             [float(position[0]), float(position[1]), float(position[2]),
              qx, qy, qz, qw],
-            prefix=entry["snapshot_prefix"], timestamp=timestamp)
+            prefix=entry["snapshot_prefix"], timestamp=timestamp,
+            host_ns=host_ns)
 
     def _on_gripper_tactile(self, dev_key: str, side, heatmap, force,
                             force_matrix, capture_ns=0):

collector/使用手册.md

@@ -89,7 +89,8 @@ After extraction you will see these items; only the listed ones matter to you:
 | `run.bat` / `run.sh` | Direct launch (fastest, for everyday use after setup) |
 | `main.py` | Main program entry (you won't run it manually) |
 | `data/` | **All your recordings + local config live here** — back up by copying the whole folder |
-| `lite_package/` | The Lite edition (see 2.7) |
+| `start_lite.bat` / `start_lite.sh` | **Lite edition** one-click setup + launch (own env `venv_lite/`), see 2.7 |
+| `lite_package/` | Lite edition distribution folder (a ready-to-ship copy of the same thing; on Linux it also carries the ~460 MB gripper payload — see 2.7) |
 | `wheels/` | Offline installer packages (prepared by admins; ignore if absent) |
 | `docs/` | Documentation set |
 
@@ -200,14 +201,16 @@ The Lite edition is a stripped-down collector in its own folder with its own env
 
 | Step | Action |
 |---|---|
-| Go to | `lite_package/` |
+| Run in | the folder holding `main_lite.py` — in this repo that is the **root** (see 1.3); `lite_package/` is the packaged copy |
 | Double-click | `start_lite.bat` (Windows) / `./start_lite.sh` (Linux) |
 | Automatic | Same six steps → independent venv `venv_lite/` → 9 slim dependencies → self-check → launch |
-| Size | ~750 MB environment, smaller than the main edition |
+| Size | ~750 MB environment, smaller than the main edition; the **Linux** package adds the gripper native stack (~460 MB payload → ~1.22 GB total), the Windows package does not |
+| Gripper | **UMI gripper is supported on Linux only, and records without any visualization** (no stereo view, no force-matrix heatmap, no pose view — data is written to disk as usual). The Windows package ships the gripper code but no payload, so the "UMI Gripper" group stays empty — the group box is always there (like every other group), the dropdown just has no entries and clicking "Open" answers "no device in the list". Expected, not a fault |
 
 ![Fig 2-2 start_lite output](docs/images/fig-2-2.png)
 
 - Sub-commands: `reinstall`, `help`; offline: `pack_wheels.py --lite`.
+- The **Linux** launcher additionally runs a 7-item gripper resource check (`[B]`) and refuses to start with `[Error B]` if the payload is missing; `KSQ_GRIPPER_SKIP_CHECK=1 ./start_lite.sh` skips it (gripper then just doesn't show up).
 - **Data is shared**: Lite and main editions use the same `data/` folder — recordings made in Lite can be played back and uploaded in the main edition (see Appendix C).
 
 <a id="en-ch2-8"></a>
@@ -322,7 +325,7 @@ Note: the choice is **not saved** — the program restarts in Chinese. Switch it
 The Lite edition does exactly three things: **connect devices → record → upload**. No login, no task page, no playback. Window 980×640, title "DAQ 极简采集 (lite v1.2.0)". Top to bottom:
 
 1. **Server row**: address field + "Test Connection" button + "Auto Upload" and "Delete After Upload" checkboxes;
-2. **Left device area**: four groups (D435 Depth Camera / UVC Camera / USB-C Glove / BLE Glove), each a device dropdown + an "Open" button (becomes "Close"; the BLE Glove group has two rows, so you can connect the left and right gloves at the same time), plus a "Rescan" button;
+2. **Left device area**: five groups (D435 Depth Camera / UVC Camera / USB-C Glove / BLE Glove / UMI Gripper, Linux package only), each a device dropdown + an "Open" button (becomes "Close"; the BLE Glove group has two rows, so you can connect the left and right gloves at the same time), plus a "Rescan" button;
 3. **Right preview**: 640×360 feed at 15 fps; "Preview Source" dropdown switches RGB / Depth Heatmap / UVC RGB;
 4. **Recording row**: task-name field (optional) + "▶ Start" (green) "■ Stop" (red) "⛔ Discard" (orange) + status text (Standby / ⏺ Recording HH:MM:SS);
 5. **Upload row**: pending list ("task —— status (ep n)": Not Uploaded / Uploading / Uploaded / Failed) + "Upload Selected" / "Upload All Pending" + progress bar;
@@ -445,6 +448,7 @@ One table, everything you can plug in. **The universal flow: plug in → wait ~2
 | Stereo S80C / S80M | USB 3.0 | 1 | Capture 50 fps → recorded at 30 fps | SDK built in; cannot run together with RealSense (6.3) |
 | USB Type-C glove | USB serial (STM32 CDC) | 1 per hand | 16 IMU sensors + 16×16 tactile, rated 60 fps | No driver; 115200 baud |
 | BLE glove | Bluetooth | 1 per hand | 16×16 tactile | PC Bluetooth on; broadcast name L/R picks the hand |
+| UMI gripper (Fays S80M) | USB 3.0 + serial | 2 | Left-lens RGB + 10×10×3 force matrix + SLAM trajectory, 30 fps | **Linux only** (native stack is ELF); needs the 460 MB payload (see 2.7 and Appendix C) |
 
 ![Fig 6-1 Devices panel](docs/images/fig-6-1.png)
 
@@ -670,7 +674,7 @@ Depth has its own **anti-drop mechanism** (repeats the last frame when one is mi
 
 Three buttons, one straight flow:
 
-1. Open at least one device first — **D435 or UVC is mandatory**: gloves alone can't record (no video source; the program says "Please open the D435 depth camera or UVC camera first");
+1. Open at least one device first — **D435, UVC, or the UMI gripper (Linux) is mandatory**: gloves alone can't record (no video source; the program says "请先开启 D435 深度相机、UVC 摄像头或 UMI 夹爪。录制必须有视频源。"). A gripper-only setup records its left-lens RGB as the master video;
 2. Task name field is optional (recordings fall under the default task);
 3. **▶ Start** → status shows "⏺ Recording HH:MM:SS"; **■ Stop** = save; **⛔ Discard** = throw this take away;
 4. Fixed Lite parameters: UVC records 640×480@30, preview 640×360@15 fps; **encoder fixed at H.264/x264** (no probe, low-end friendly);
@@ -818,6 +822,7 @@ data/recordings/<task name>/
 | `d435_rgb` / `D435_head_depth` | RealSense D435 color / depth |
 | `stereo_left` / `stereo_right` | Stereo camera left / right |
 | `stereo_depth` | Stereo disparity depth |
+| `gripper_rgb` (`gripper_2_rgb` for the 2nd gripper) | UMI gripper left lens (recorded whenever a gripper is open — in the Lite edition this is the only gripper video) |
 
 <a id="en-ch9-3"></a>
 
@@ -847,6 +852,13 @@ data/recordings/<task name>/
 | `observation.<sn>_imu_quat` | USB glove IMU: 16 sensors × 4-component quaternion = 64 dims |
 | `observation.<sn>_imu_valid` | Validity flags for those 16 sensors (16 dims) |
 | `observation.left_hand_pose` / `observation.right_hand_pose` | Hand keypoints: **63 dims = 21 points × 3 coordinates (meters)**; zeros when not solved (placeholder column) |
+| `observation.gripper_left_force` / `_right_force` | **UMI gripper contact force** `[fx, fy, fz]` in mN (3 dims); the twin column `…_force_ns` carries that sample's capture time (ns, monotonic) |
+| `observation.gripper_left_force_matrix` / `_right_force_matrix` | **Force matrix**, 10×10×3 = 300 values, integer-encoded — the multiplier is per-recording, read `features["observation.…_force_matrix"].scale` in `meta/info.json` (default ×100); twin column `…_force_matrix_ns` = capture time (ns) |
+| `observation.gripper_state` | Gripper state `[open %, gripped flag, fz mN]` (3 dims) |
+| `observation.slam_trajectory` | **Gripper SLAM trajectory** (variable length): 8 values per point `[t, x, y, z, qx, qy, qz, qw]` — position in meters in the post-origin frame, quaternion, `t` monotonic in seconds |
+
+> The force/matrix `_ns` columns exist because forces are sampled latest-wins while RGB takes the oldest queued frame, so row numbers alone drift apart within a take; resample by those timestamps to align modalities.
+> With a **second gripper**, every one of its columns gets the `gripper_2_` prefix (e.g. `observation.gripper_2_gripper_left_force`), so two grippers never collide.
 
 **③ Action & status**
 
@@ -924,7 +936,7 @@ Besides recordings, `data/` holds a few small program files:
 | 6-2 | 6.1 | One UVC tile (info bar: name/FPS/light) | `docs/images/fig-6-2.png` | Main | 800×450 |
 | 6-3 | 6.2 | D435 two tiles (RGB + depth heatmap) | `docs/images/fig-6-3.png` | Main | 1200×450 |
 | 6-4 | 6.3 | Stereo three tiles (left/right/depth) | `docs/images/fig-6-4.png` | Main | 1400×450 |
-| 6-6 | 6.0 | Lite device area close-up (four dropdowns + buttons) | `docs/images/fig-6-6.png` | Lite | 400×300 |
+| 6-6 | 6.0 | Lite device area close-up (five dropdowns + buttons; the UMI Gripper group appears on Linux packages only) | `docs/images/fig-6-6.png` | Lite | 400×300 |
 | 7-1 | 7.1/7.2 | Recording in progress (⏱ timer, "Recording: 1", locked panel) | `docs/images/fig-7-1.png` | Main | 1600×900 |
 | 7-2 | 7.1 | Progress-full refusal dialog | `docs/images/fig-7-2.png` | Main | native |
 | 7-3 | 7.4 | Leave-confirmation dialog while recording | `docs/images/fig-7-3.png` | Main | native |
@@ -954,6 +966,7 @@ Besides recordings, `data/` holds a few small program files:
 | Code | Symptom | Solution |
 |---|---|---|
 | **A** | Python not found / auto-install failed | ① Offline: put `python-3.12.10-amd64.exe` into `wheels/` and retry; ② Install Python 3.12.x 64-bit manually, tick **Add python.exe to PATH**; ③ A Microsoft Store Python may interfere — uninstall it, install the official one; ④ Python < 3.10 counts as missing |
+| **B** | *(Lite edition on Linux only)* "夹爪原生资源缺失" — the gripper native payload is missing | The Linux Lite package ships the UMI gripper payload (`core/gripper/native/` ~460 MB + `core/gripper/sightac_sdk/`) as a **required** resource; the launcher checks 7 items up front and refuses to start (so you don't sit through a wheel install first). The message lists exactly which items are missing. ① Re-extract the full package (most common cause: one directory level short, or an upgrade that copied code but not the payload); ② Only need D435/UVC/gloves → `KSQ_GRIPPER_SKIP_CHECK=1 ./start_lite.sh` (the gripper group then stays empty); ③ Custom install location → point `KSQ_GRIPPER_NATIVE_ROOT` at the payload |
 | **C** | venv creation failed | ① Free disk space (needs ~2 GB); ② Antivirus blocked it → whitelist the folder, then `start.bat reinstall`; ③ Path too long → move to a short path like `C:\collector`; ④ Special characters in path → use a plain-English folder |
 | **C2** | Old venv deletion failed | The main program is still running — close its window, then `start.bat reinstall` |
 | **D** | Dependency download/install failed | ① Check the network and rerun (partial downloads are cached); ② Corporate firewall → ask admin to allow PyPI mirrors or use the offline route (2.6); ③ Antivirus blocking pip → whitelist; ④ Repeated failures → `start.bat reinstall` |
@@ -1015,7 +1028,9 @@ Not sure which edition to use? This table settles it:
 | Quick-start guide | Yes (pops on first launch) | No |
 | Hand skeleton solving | Yes (MANO 21 keypoints filled live) | No (columns stay zero — valid) |
 | Theme | qt-material dark theme | Lightweight dark style |
-| Devices | UVC ≤ 8 + D435 + stereo S80C/S80M + gloves | One of each: D435 / UVC / USB-C glove; BLE gloves 2 (left + right at once) |
+| Devices | UVC ≤ 8 + D435 + stereo S80C/S80M + gloves + UMI gripper (Linux) | One of each: D435 / UVC / USB-C glove; BLE gloves 2 (left + right at once); UMI grippers up to 2 (Linux package only) |
+| Gripper (UMI / Fays S80M) | Full visualization (stereo tiles, force-matrix heatmaps, pose view, open/close panel) | **Records without any visualization** — RGB video + force/tactile/matrix + SLAM trajectory are written to disk, nothing is shown; no "re-read factory calibration" context menu (use `tools/import_gripper_calibration.py --generate` instead) |
+| Gripper payload (~460 MB) | Ships in the repo (`core/gripper/native/`, not in git) | Ships in the **Linux** package (required; `[Error B]` if missing) — the **Windows** package carries the gripper code but no payload, so its gripper group stays empty there |
 | UVC recording | Linux 1280×960, Windows 1280×720 @30 | Fixed 640×480 @30 |
 | Preview | Full res, capped 30 fps | 640×360 @15 fps |
 | Encoder | Auto probe (nvenc → x265 → x264) | Fixed x264 (low-end friendly) |
@@ -1077,7 +1092,7 @@ Real-time 3D hand-keypoint demo for the S80C stereo camera (`run_live_s80c.sh`,
 | 使用说明.md / 使用说明_EN.md | Quick guide + error-code reference (opened by `start.bat help`) |
 | README.md | Repo overview & dev info (hardware table, changelog) |
 | docs/ (ui.md, data.md, file_format.md …) | Implementation details, advanced reading |
-| lite_package/使用说明_lite.md | Lite edition quick guide & acceptance checklist |
+| 使用说明_lite.md | Lite edition quick guide & acceptance checklist |
 | tools/glove_package/使用说明.md | Glove toolchain details |
 
 **When reporting a problem**, include these three things to speed things up:
@@ -1182,7 +1197,8 @@ Real-time 3D hand-keypoint demo for the S80C stereo camera (`run_live_s80c.sh`,
 | `run.bat` / `run.sh` | 直接启动（部署完成后日常用它，更快） |
 | `main.py` | 主程序入口（不需要手动运行） |
 | `data/` | **你录的全部数据 + 本地配置都在这里**，备份就拷贝整个目录 |
-| `lite_package/` | 极简版（精简采集程序），见 2.7 |
+| `start_lite.bat` / `start_lite.sh` | **极简版**一键部署 + 启动（独立环境 `venv_lite/`），见 2.7 |
+| `lite_package/` | 极简版发行目录（同一套东西的打包副本，可直接发给只装极简版的机器；Linux 版另含约 460MB 夹爪原生载荷，见 2.7） |
 | `wheels/` | 离线安装包（管理员准备的，普通用户没有就忽略） |
 | `docs/` | 文档集（开发文档，进阶阅读用） |
 
@@ -1303,14 +1319,16 @@ python scripts/pack_wheels.py --lite     # 极简版依赖
 
 | 步骤 | 操作 |
 |---|---|
-| 进入目录 | `lite_package/` |
+| 运行位置 | 含 `main_lite.py` 的目录 —— 本仓库里就是**根目录**（见 1.3）；`lite_package/` 是同一套东西的打包副本 |
 | 双击 | `start_lite.bat`（Windows）/ `./start_lite.sh`（Linux） |
 | 自动完成 | 同样六步：定位 Python → 建独立虚拟环境 `venv_lite/` → 装精简依赖（9 个包）→ 自检 → 启动 |
-| 体积 | 环境约 750MB，比主程序小 |
+| 体积 | 环境约 750MB，比主程序小；**Linux** 包另含夹爪原生载荷约 460MB（合计约 1.22GB），Windows 包不含 |
+| 夹爪 | **UMI 夹爪仅 Linux 包支持，且只录不显**（无双目画面、无力矩阵热力图、无位姿轨迹，数据照常落盘）。Windows 包带夹爪代码但不带载荷，「UMI 夹爪」组**框还在但永远是空的**（下拉框无条目，点「开启」提示「列表中没有设备」）——属**预期**，不是故障 |
 
 ![图 2-2 start_lite.bat 输出截图](docs/images/fig-2-2.png)
 
 - 子命令同样支持：`reinstall`（重装）、`help`（打开极简版说明）。
+- **Linux** 启动时多做一步夹爪资源自检（7 项，`[B]`），缺资源直接报 `[错误 B]` 拒启；只想要 D435/UVC/手套时 `KSQ_GRIPPER_SKIP_CHECK=1 ./start_lite.sh` 跳过（跳过后夹爪组为空，其它设备照常）。
 - 离线环境用 `python scripts/pack_wheels.py --lite` 生成 `wheels/` 后同法拷贝。
 - **数据互通**：极简版与主程序共用 `data/` 目录——极简版录��数据，主程序照样能回放、上传（见附录 C）。
 
@@ -1426,7 +1444,7 @@ python scripts/pack_wheels.py --lite     # 极简版依赖
 极简版定位「**连设备 → 采集 → 上传**」三件事，砍掉了登录、任务页、回放等一切多余功能。窗口 980×640，标题「DAQ 极简采集 (lite v1.2.0)」，自上而下：
 
 1. **顶部服务器行**：服务器地址输入框 + 「测试连接」按钮 + 「自动上传」「上传后删除」两个勾选框；
-2. **左侧设备区**：四组设备（D435 深度相机 / UVC 摄像头 / USB-C 手套 / BLE 手套），每组一个设备下拉框 + 一个「开启」按钮（开启后变成「关闭」；BLE 手套组有两行，可同时连左右两只手套），底部「重新扫描」按钮；
+2. **左侧设备区**：五组设备（D435 深度相机 / UVC 摄像头 / USB-C 手套 / BLE 手套 / UMI 夹爪——最后一组仅 Linux 包有），每组一个设备下拉框 + 一个「开启」按钮（开启后变成「关闭」；BLE 手套组有两行，可同时连左右两只手套），底部「重新扫描」按钮；
 3. **右侧预览区**：640×360 实时画面（15fps），「预览源」下拉可切换 RGB / 深度热力图 / UVC RGB；
 4. **录制行**：任务名输入框（可选填）+ 「▶ 开始」（绿）「■ 停止」（红）「⛔ 丢弃」（橙）三个按钮 + 状态文字（待机 / ⏺ 录制中 时长）；
 5. **上传行**：待上传列表（显示 任务名 —— 状态 (ep n)，状态有 未上传/上传中/已上传/失败）+「上传选中」「上传全部未上传」按钮 + 上传进度条；
@@ -1553,6 +1571,7 @@ python scripts/pack_wheels.py --lite     # 极简版依赖
 | 双目相机 S80C / S80M | USB 3.0 | 1 | 采集 50fps → 录制抽帧 30fps | 免装 SDK（程序自带）；与 RealSense 不能同开（见 6.3） |
 | USB Type-C 手套 | USB 串口（STM32 CDC） | 左右各 1 | 16 传感器 IMU + 16×16 触觉，额定 60fps | 免驱动；串口波特率 115200 |
 | BLE 蓝牙手套 | 蓝牙 | 左右各 1 | 16×16 触觉 | 电脑需开蓝牙；广播名含 L/R 自动分左右手 |
+| UMI 夹爪（Fays S80M） | USB 3.0 + 串口 | 2 台 | 左目 RGB + 10×10×3 力矩阵 + SLAM 轨迹，30fps | **仅 Linux**（原生栈是 ELF）；需 460MB 原生载荷（见 2.7 与附录 C） |
 
 ![图 6-1 设备检测面板截图](docs/images/fig-6-1.png)
 
@@ -1782,7 +1801,7 @@ RECORD_VIDEO_ENCODER = "auto"   # 自动（默认）；也可填 "nvenc" | "x265
 
 极简版的录制只有三个按钮，流程更直白：
 
-1. 先在左侧设备区开启至少一台设备——**必须先开 D435 或 UVC**：只开手套是录不了的（录制必须有视频源，程序会提示「请先开启 D435 深度相机或 UVC 摄像头」）；
+1. 先在左侧设备区开启至少一台设备——**必须先开 D435、UVC 或 UMI 夹爪（Linux）**：只开手套是录不了的（录制必须有视频源，程序会提示「请先开启 D435 深度相机、UVC 摄像头或 UMI 夹爪」）；只开夹爪时以夹爪**左目 RGB** 为主视频源；
 2. 任务名输入框选填（不填也能录，数据归到默认任务下）；
 3. 点 **「▶ 开始」** → 录制中显示「⏺ 录制中 时长」；点 **「■ 停止」** = 保存；点 **「⛔ 丢弃」** = 作废本段；
 4. 极简版的固定参数：UVC 录制 640×480@30、预览 640×360@15fps；**编码固定 H.264/x264**（跳过编码器探针，低端机友好）；
@@ -1935,6 +1954,7 @@ data/recordings/<任务名>/
 | `d435_rgb` / `D435_head_depth` | RealSense D435 的彩色 / 深度 |
 | `stereo_left` / `stereo_right` | 双目相机左 / 右目 |
 | `stereo_depth` | 双目视差深度 |
+| `gripper_rgb`（第二台夹爪是 `gripper_2_rgb`） | UMI 夹爪左目（开着夹爪就会录；极简版里这是唯一的夹爪视频） |
 
 <a id="cn-ch9-3"></a>
 
@@ -1964,6 +1984,13 @@ data/recordings/<任务名>/
 | `observation.<sn>_imu_quat` | USB 手套 IMU：16 传感器 × 4 分量四元数 = 64 维 |
 | `observation.<sn>_imu_valid` | 对应 16 个传感器有效性标志（16 维） |
 | `observation.left_hand_pose` / `observation.right_hand_pose` | 手部关键点：**63 维 = 21 点 × 3 坐标（米）**；未解算时是 0 占位列 |
+| `observation.gripper_left_force` / `_right_force` | **UMI 夹爪接触力** `[fx, fy, fz]`（mN，3 维）；孪生列 `…_force_ns` 是该样本的采集时刻（纳秒，单调钟） |
+| `observation.gripper_left_force_matrix` / `_right_force_matrix` | **力矩阵** 10×10×3 = 300 维，整型编码 —— 倍率逐段记录在 `meta/info.json` 的 `features["observation.…_force_matrix"].scale`（默认 ×100）；孪生列 `…_force_matrix_ns` = 采集时刻（纳秒） |
+| `observation.gripper_state` | 夹爪状态 `[开合百分比, 抓握判定, fz(mN)]`（3 维） |
+| `observation.slam_trajectory` | **夹爪 SLAM 轨迹**（变长）：每点 8 值 `[t, x, y, z, qx, qy, qz, qw]` —— 位置是原点相对化后的米制坐标，四元数为姿态，`t` 单调递增（秒） |
+
+> 力/力矩阵的 `_ns` 孪生列存在的理由：力走 latest-wins 单槽（永远取最新），RGB 走队头最旧帧，两条支路的行号在段内会持续错开；按这些时间戳重采样即可把跨模态对齐压到半帧以内。
+> 开**第二台夹爪**时，它的所有列统一加 `gripper_2_` 前缀（如 `observation.gripper_2_gripper_left_force`），两台互不串列。
 
 **③ 动作与状态**
 
@@ -2041,7 +2068,7 @@ data/recordings/<任务名>/
 | 6-2 | 6.1 UVC | 一路 UVC 画面格（信息条：设备名/FPS/状态灯） | `docs/images/fig-6-2.png` | 普通版 | 800×450 |
 | 6-3 | 6.2 RealSense | D435 两格画面（RGB + 深度热力图） | `docs/images/fig-6-3.png` | 普通版 | 1200×450 |
 | 6-4 | 6.3 双目 | S80C 三格画面（左目/右目/深度热力图） | `docs/images/fig-6-4.png` | 普通版 | 1400×450 |
-| 6-6 | 6.0 极简版设备区 | 极简版左列设备区特写（四组下拉框与开启按钮） | `docs/images/fig-6-6.png` | 极简版 | 400×300 |
+| 6-6 | 6.0 极简版设备区 | 极简版左列设备区特写（五组下拉框与开启按钮；UMI 夹爪那组仅 Linux 包有） | `docs/images/fig-6-6.png` | 极简版 | 400×300 |
 | 7-1 | 7.1/7.2 录制中 | 录制中整窗（⏱计时、录制中: 1、面板锁定态） | `docs/images/fig-7-1.png` | 普通版 | 1600×900 |
 | 7-2 | 7.1 拒绝录制 | 「任务进度已满」拒绝弹窗 | `docs/images/fig-7-2.png` | 普通版 | 对话框原生 |
 | 7-3 | 7.4 中断确认 | 录制中返回任务选择的确认弹窗 | `docs/images/fig-7-3.png` | 普通版 | 对话框原生 |
@@ -2071,6 +2098,7 @@ data/recordings/<任务名>/
 | 错误码 | 现象 | 解决方案 |
 |---|---|---|
 | **A** | 找不到 Python / 自动安装失败 | ① 离线环境：把 `python-3.12.10-amd64.exe` 放入 `wheels/` 后重试；② 手动安装：官网下载 Python 3.12.x **64 位**，安装时勾选 **Add python.exe to PATH**；③ 已装过 Python：可能是 Microsoft Store 版干扰，在「设置-应用」卸载后装官网版；④ 已有 Python 但版本低于 3.10 同样走 ② |
+| **B** | **夹爪原生资源缺失**（仅极简版 Linux 包；输出里逐项列了缺什么） | 极简版 Linux 包把 UMI 夹爪的原生载荷（`core/gripper/native/` 约 460MB + `core/gripper/sightac_sdk/`）当**必需资源**，启动时先查 7 项，缺了直接拒启（不会白装一遍依赖）。① 最省事：重新完整解压分发包（最常见原因是解压少了一层目录，或覆盖升级时只拷了代码没拷载荷）；② 只想要 D435/UVC/手套：`KSQ_GRIPPER_SKIP_CHECK=1 ./start_lite.sh` 跳过（跳过后夹爪组为空，其它设备照常）；③ 自定义安装位置：用 `KSQ_GRIPPER_NATIVE_ROOT=<native 目录>` 指路 |
 | **C** | 虚拟环境创建失败 | ① 磁盘空间不足（需约 2GB）；② 杀毒软件拦截 → 目录加白名单后 `start.bat reinstall`；③ 路径过长 → 移到 `C:\collector` 之类短路径；④ 路径含特殊字符 → 换纯英文目录 |
 | **C2** | 旧 venv 删除失败 | 主程序还在运行，先关闭窗口再 `start.bat reinstall` |
 | **D** | 依赖下载/安装失败 | ① 网络不通 → 检查网络后重跑（已下载部分有缓存，不重复）；② 公司网络限制 → 请管理员放行 PyPI 镜像，或走离线交付（见第 2.6 节）；③ 杀毒/防火墙拦 pip → 白名单；④ 多次失败 → `start.bat reinstall` |
@@ -2135,7 +2163,9 @@ data/recordings/<任务名>/
 | 使用说明向导 | 有（首次启动弹出） | 无 |
 | 手部骨架解算 | 有（MANO 21 关键点实时回填） | 无（数据列留 0 占位，合法） |
 | 界面主题 | qt-material 暗色主题 | 轻量暗色样式 |
-| 设备数量 | UVC ≤ 8 路 + D435 + 双目 S80C/S80M + 手套 | 每类 1 台：D435 / UVC / USB-C 手套；BLE 手套 2 台（左右手同时） |
+| 设备数量 | UVC ≤ 8 路 + D435 + 双目 S80C/S80M + 手套 + UMI 夹爪（Linux） | 每类 1 台：D435 / UVC / USB-C 手套；BLE 手套 2 台（左右手同时）；UMI 夹爪最多 2 台（仅 Linux 包） |
+| 夹爪（UMI / Fays S80M） | 完整可视化（双目画面、力矩阵热力图、位姿轨迹、开合面板） | **只录不显**——RGB 视频 + 力/触觉/力矩阵 + SLAM 轨迹照常落盘，界面上什么都不显示；也没有「重新读取出厂标定」右键菜单（改走 `tools/import_gripper_calibration.py --generate`） |
+| 夹爪原生载荷（约 460MB） | 仓库自带（`core/gripper/native/`，不入库） | 随 **Linux** 包下发（必需资源，缺了报 `[错误 B]`）；**Windows** 包带夹爪代码但不带载荷，那边的夹爪组框在、里面永远为空 |
 | UVC 录制分辨率 | Linux 1280×960、Windows 1280×720 @30 | 固定 640×480 @30 |
 | 预览 | 全分辨率，30fps 上限 | 640×360 @15fps |
 | 编码器 | 自动探测（nvenc → x265 → x264） | 固定 x264（低端机友好） |
@@ -2197,7 +2227,7 @@ S80C 双目相机的实时 3D 手部关键点 demo（`run_live_s80c.sh`，`--glo
 | 使用说明.md / 使用说明_EN.md | 快速指引 + 错误码速查（`start.bat help` 打开它） |
 | README.md | 仓库总览与开发信息（硬件支持表、更新记录） |
 | docs/（ui.md、data.md、file_format.md 等） | 模块与格式实现细节，进阶阅读 |
-| lite_package/使用说明_lite.md | 极简版快速指引与验收清单 |
+| 使用说明_lite.md | 极简版快速指引与验收清单 |
 | tools/glove_package/使用说明.md | 手套识别工具链详细说明 |
 
 **遇到问题反馈时**，请附上三样东西，能大幅加快排查：

collector/{lite_package/使用说明_lite.md → 使用说明_lite.md}

@@ -3,6 +3,13 @@
 只做三件事：**连接设备 → 采集数据 → 上传**。无登录、无回放、无任务页、无骨架解算。
 体积小（无 torch/scipy/mediapipe/pyvista）、CPU 要求低（录制直接 x264、预览 15fps）。
 
+设备：**D435 / UVC 摄像头 / USB-C 手套 / BLE 手套 / UMI 夹爪**。夹爪**只录不显**
+（数据照常落盘，不做任何夹爪可视化），且**仅 Linux 包**支持 —— Windows 包里「UMI 夹爪」
+组是空的（和没插 D435 时的 D435 组一样），见 [§三](#三夹爪umi--fays-s80m仅-linux-包)。
+
+包体积（含首次自动安装的 `venv_lite`，约 750MB）：Linux 包约 **1.22GB**（含夹爪原生载荷
+460MB），Windows 包约 **0.75GB**（不含载荷）。
+
 > 与主程序共用 `data/`（录制目录、`pipeline.db`、`server_config.json`、手套序列号绑定），
 > 两版可交替使用、数据互通；但虚拟环境独立（`venv_lite/`，与主程序 `venv/` 互不影响）。
 
@@ -24,6 +31,7 @@
 | `start_lite.bat help` | 打开本文档 |
 
 **错误码**：`[错误 A]` 无 Python 且自动安装失败 → 手动装 3.12 并勾选 "Add python.exe to PATH"；
+`[错误 B]`（**仅 Linux 包**）夹爪原生资源缺失 → 见 §三，多半是解压少了一层目录；
 `[错误 C]` 建 venv 失败 → 磁盘空间/杀毒软件/中文路径；`[错误 D]` 依赖安装失败 → 网络或让管理员
 生成离线包；`[错误 E]` 自检失败 → 杀毒软件或 `reinstall`；`[错误 F]` 启动即退 → 显卡驱动/远程桌面；
 `[错误 G]` 解压层次不对 → 保持文件夹完整、不要只拷 bat。
@@ -32,16 +40,20 @@
 `wheels\` 目录（约几百 MB），连同 `python-3.12.10-amd64.exe` 一起拷到客户项目根目录，
 `start_lite.bat` 自动改走纯离线安装。
 
-**Linux**：`./start_lite.sh`（`reinstall` / `help` 子命令同上）。
+**Linux**：`./start_lite.sh`（`reinstall` / `help` 子命令同上）。Linux 包**带夹爪支持**，
+启动时会多做一步夹爪原生资源自检（`[B]`），见 §三。
 
 ---
 
 ## 二、日常操作流程
 
-1. **插设备**：D435（USB3）、UVC 摄像头、USB-C 手套、BLE 手套（已配对）。约 2 秒后出现在左侧对应列表。
+1. **插设备**：D435（USB3）、UVC 摄像头、USB-C 手套、BLE 手套（已配对）、UMI 夹爪
+   （USB3 双目 + 串口，仅 Linux 包）。约 2 秒后出现在左侧对应列表；夹爪扫描略慢
+   （要经 ESP32 读序列号配对），首次「开启」还要核对/生成出厂标定。
 2. **开启**：左侧设备组选中设备 → 点「开启」；中上方出现预览（RGB / 深度热力图 / UVC 可切换，
    开启设备后预览源会自动切到新开的设备）。
-   - 录制必须有视频源：**先开 D435 或 UVC 摄像头**（只开 UVC 时以其为主视频源，无深度图）。
+   - 录制必须有视频源：**先开 D435 / UVC 摄像头 / 夹爪**（只开 UVC 时以其为主视频源、无深度图；
+     只开夹爪时以夹爪**左目 RGB** 为主视频源）。
    - 手套左右手按序列号/广播名 L/R 自动绑定传感器列，与主程序共用绑定记忆。
 3. **录制**：填任务名（可选）→「▶ 开始」→「■ 停止」保存（「X 丢弃」作废）。
    保存后按「自动上传」开关决定是否自动入队上传。
@@ -52,33 +64,101 @@
 
 ---
 
-## 三、与主程序的差异（本版没有的东西）
+## 三、夹爪（UMI / Fays S80M，仅 Linux 包）
+
+夹爪在极简版里是**只录不显**：数据全部照常落盘，但不做任何夹爪可视化（双目画面、
+力矩阵热力图、位姿轨迹、开合力读数都没有 —— 需要看这些请用主程序）。
+
+**开启**：插好夹爪 → 左侧「UMI 夹爪」组里选中 → 点「开启」。最多 2 台，按开启顺序
+编号；第二台的列名自动加 `gripper_2_` 前缀（同一台机器上两套数据互不串列）。
+开启后窗口下方日志会打印链路就绪信息；夹爪的**左目 RGB 可当主视频源**，只开夹爪
+也能录（此时 parquet 里没有深度相关列）。
+
+**录什么**：
+
+| 落盘位置 | 内容 |
+|---|---|
+| `videos/…/gripper_rgb/` | 夹爪左目 RGB 视频 |
+| `observation.gripper_state` | 开合百分比 / 抓握判定 / 法向力 |
+| `observation.gripper_{left,right}_force` | 三轴合力；`_force_ns` 是它的采集时刻 |
+| `observation.gripper_{left,right}_force_matrix` | 10×10×3 力矩阵（整型编码，倍率见 `meta/info.json` 的 `features.*.scale`） |
+| `observation.slam_trajectory` | SLAM 轨迹（8 个值一个点，时间戳单调） |
+
+**不存**双目视频与 IMU。录制结束的日志里有一行双目丢帧汇总 —— 只录不显时，那是
+判断链路是否健康的唯一证据，出问题请把它连同 `logs/` 一起发给开发。
+
+**为什么需要 460MB**：夹爪的原生栈（`core/gripper/native/` 与 `core/gripper/sightac_sdk/`）
+是**必需资源**，随 Linux 分发包下发，`start_lite.sh` 的 `[B]` 会逐项��验（7 项），
+缺任何一项直接报 `[错误 B]` 并**拒启**（不会白装一遍依赖再失败）。修复办法见报错提示，
+或只想要 D435/UVC/手套时跳过自检：
+
+```bash
+KSQ_GRIPPER_SKIP_CHECK=1 ./start_lite.sh    # 跳过后夹爪组为空，其它设备照常
+```
+
+**换新夹爪 / 重新读取出厂标定**：正常情况下插上新夹爪、点「开启」就会自动读取出厂
+标定并连上，不用手工操作。只有换模组或怀疑标定被写坏时才需要强制重读 —— 极简版
+**没有这个 UI**，用命令行（在部署目录下执行）：
+
+```bash
+cd <部署目录>
+./venv_lite/bin/python tools/import_gripper_calibration.py --list        # 看已覆盖哪些序列号
+./venv_lite/bin/python tools/import_gripper_calibration.py --detect      # 现场插着的这只的序列号
+./venv_lite/bin/python tools/import_gripper_calibration.py --generate    # 就地为它读一份出厂标定
+```
+
+标定是**逐台**的（焦距/基线/IMU 外参各不相同），绝不能跨设备抄；旧文件会先备份成
+`*.bak_<时间戳>`。跑之前先关掉正在用这只夹爪的程序（主程序或极简版窗口）。
+
+**Windows**：不支持夹爪（原生栈是 ELF，Windows 上跑不了）。「UMI 夹爪」这一组**还在**
+（五组的框一直都在，和没插 D435 时一样），但里面永远是空的、点「开启」只会提示
+「列表中没有设备」—— 这是**预期**，不是故障。
+
+---
+
+## 四、与主程序的差异（本版没有的东西）
 
 - 无登录/任务页/回放/查看器/使用向导；无骨架关键点解算（parquet 的 hand_pose 列为全零占位，合法）。
-- 无 S80M/S80C；每类设备（D435 / UVC / USB 手套 / BLE 手套）只支持 1 台。
+- 无独立双目相机 S80C/S80M（那是主程序的设备类型，与夹爪的「只录不显」不是一回事）；
+  每类设备（D435 / UVC / USB 手套 / BLE 手套 / 夹爪）只支持 1 台（夹爪 2 台）。
+- 无夹爪可视化，也没有「重新读取出厂标定」的右键菜单（改走上面的命令行）。
 - UVC 摄像头采集固定 640×480、30fps（预览刷新仍限 15fps；无深度图）；
   Windows 枚举无需额外依赖（pygrabber+comtypes 可选，装了仅提升枚举质量）。
 - 预览固定 640×360、15fps；编码器固定 x264（跳过 x265 速度探针，低端机友好）。
 - 依赖只有 9 个包（`requirements-lite.txt`）；`imageio-ffmpeg`（77MB）提供内置 ffmpeg，
   装有系统 ffmpeg 的机器可删除该行再重装以省体积。
 
-## 四、手工验收清单（真实设备）
+## 五、手工验收清单（真实设备）
 
 - [ ] D435 出现在列表 → 开启 → RGB/深度预览切换正常 → 录 30s → 停止 → `data/recordings/<任务>/`
       出现 `videos/chunk-000/d435_rgb/`、`depth/`、`data/chunk-000/*.parquet`、`meta/info.json`
 - [ ] UVC 摄像头出现在列表 → 开启（不开 D435）→ 预览切到 UVC 有画面 → 录 10s → 停止 →
       `videos/chunk-000/uvc_rgb/` 有视频，parquet 无深度相关列
+- [ ] **夹爪**（Linux 包）：冷启无 `[错误 B]` → 列表出现「UMI 夹爪 (序列号)」→ 开启 → 日志有
+      链路就绪 → **只开夹爪**录 60s → `videos/…/gripper_rgb/` 有视频、`observation.gripper_state`
+      与 `gripper_{left,right}_force*`、`slam_trajectory` 列有值、抓握时力非零、轨迹时间戳单调
+- [ ] **夹爪**：录制中拔掉夹爪 USB → 弹窗提示 + 条目录回收 + **录制不中断**（其它设备继续录）
+- [ ] **夹爪**：关窗后 `ps -ef | grep -E "fayssense|ksq-camera-service|fays_vikit"` 零残留
+- [ ] **夹爪**：插第二台夹爪 → 列名走 `gripper_2_*` 前缀、两条 RGB 各自成档、互不串列
 - [ ] 主程序 ☁ 上传对话框能看到刚才的会话（共用 `pipeline.db`）
 - [ ] USB 手套开启 → parquet 含 `observation.<列>_imu_quat/_imu_valid`，hand_pose 列全零
 - [ ] BLE 手套广播名 L/R 绑定左右列正确
 - [ ] 服务器地址保存后重启仍在（与主程序共用 `server_config.json`，不互相覆盖）
 - [ ] 勾「自动上传」→ 录制完成后自动上传 → 服务器可见 session
-- [ ] 无 Python 的 Windows 真机跑 `start_lite.bat` 全流程（含 `wheels\` 离线安装）
+- [ ] 无 Python 的 Windows 真机跑 `start_lite.bat` 全流程（含 `wheels\` 离线安装），
+      确认「UMI 夹爪」组是空的（组框在、无条目）且无任何报错
 
-## 五、常见问题
+## 六、常见问题
 
 - **预览显示「无信号」**：开启设备后预览会自动切到新开设备的画面；若仍无信号，
   看窗口下方日志 —— 出现「无法打开…可能被其他程序占用」说明摄像头正被别的程序
   使用（主程序 / 浏览器 / 另一个极简版窗口），关掉它们后点「关闭」再重新「开启」。
-- **录不了**：录制必须有视频源 —— 先开 D435 或 UVC 摄像头。
+- **录不了**：录制必须有视频源 —— 先开 D435、UVC 摄像头或夹爪。
+- **「UMI 夹爪」组里是空的**：① Windows 或用了 `KSQ_GRIPPER_SKIP_CHECK=1` —— 预期行为
+  （组标题还在、下拉框空、点「开启」提示「列表中没有设备」）；② Linux 上先看启动时有没有
+  `[错误 B]`；③ 夹爪没插好（双目 / 串口都要通），日志里会有扫描失败的原始原因。
+- **`[错误 B]` 夹爪原生资源缺失**：按提示逐项补 `core/gripper/native/`（约 460MB）——
+  最常见的原因是解压时少了一层目录，或覆盖升级时只拷了代码没拷载荷。
+- **夹爪开着但没数据**：日志里那条双目丢帧汇总 + `logs/` 目录是排查入口；先确认不是
+  被别处的同类进程占着设备（标定/探测程序与运行中的夹爪互斥）。
 - **改了代码不生效**：`start_lite.sh reinstall` 重装依赖，或先关闭所有旧窗口再重开。