collector: 更新采集工程至 v1.3.15（姿态语义文档/注释校正 + 夹爪配对报错分型 + 设备检测栏可收起）

同步 master 自 177ef0ef（v1.3.13）以来的 6 个提交：

c62e21c0 feat: 删除即真删除 —— 删完校验三处落盘 + 真删录制行（含上传后删除与任务页删除）
00612cb1 fix: UVC 发现结果不再丢弃 —— rc=0 也留 stderr，配对失败带上身份字段
0ab64d7c fix: 坐标帧语义校准 —— 原点相对化改为右乘 R0ᵀ（v1.3.13 表观旋转轴转错的 bug）+ 注释/文档同步
7b668fa4 feat: v1.3.14 —— 发布位姿死区 3mm（静止毫米级游走不进轨迹/落盘）+ 跳变门限值改为不随抽帧膨胀
3e381717 fix: v1.3.15 —— 姿态语义文档/注释校正 + 夹爪配对报错分型 + lite 取号跨 chunk
e77c5cc2 feat: 设备检测栏可拖窄 + 可收起（标题栏 × / 视图▸设备检测栏 Ctrl+D）

变更 36 个文件（29 修改 / 7 新增 / 0 删除），全部为文本文件。__version__ = 1.3.15。

collector/README.md

@@ -1,6 +1,6 @@
 # collector — Multimodal Data Acquisition SDK · 多模态数据采集 SDK
 
-![Version](https://img.shields.io/badge/version-1.3.13-blue)
+![Version](https://img.shields.io/badge/version-1.3.15-blue)
 ![Python](https://img.shields.io/badge/python-3.10-blue)
 ![License](https://img.shields.io/badge/license-TBD-lightgrey)
 
@@ -339,13 +339,17 @@ venv/bin/python tools/tests/test_sdk_python_version.py
 # gripper pairing / ESP32 port diagnostics in the main GUI (v1.3.12)
 venv/bin/python tools/tests/test_gripper_fays_pairing.py
 venv/bin/python tools/tests/test_gripper_esp_binding.py
-# published pose frame + pose view (v1.3.13) — run all five after touching
-# either side of the frame contract (protocol/ vs ui/pose_view_qt.py)
+# published pose frame + pose view + publish-exit deadband / jump gate
+# (v1.3.13-v1.3.14) — run all eight after touching either side of the
+# frame or publish contract (protocol/ vs ui/pose_view_qt.py)
 venv/bin/python tools/tests/test_gripper_pose_axes.py
 venv/bin/python tools/tests/test_gripper_pose_host_stamp.py
 venv/bin/python tools/tests/test_gripper_slam_columns.py
 venv/bin/python tools/tests/test_gripper_latest_pose_frame.py
 venv/bin/python tools/tests/test_pose_view_qt.py
+venv/bin/python tools/tests/test_pose_publish_deadband.py
+venv/bin/python tools/tests/test_gripper_pose_deadband_publish.py
+venv/bin/python tools/tests/test_pose_guard_limits.py
 # hardware tests require the corresponding device attached: d405_worker_test,
 # d435_e2e_test, d435_gui_smoke_test, mono_regression, d435_playback_test, etc.
 ```
@@ -407,6 +411,49 @@ are documented in [docs/index.md](docs/index.md#开发约定).
 
 ### Changelog
 
+- **v1.3.15** — pose-semantics documentation/comment corrections, a gripper
+  pairing error-message split, and a chunk-aware episode-number fix in lite.
+  **Fixed a false equation**: `finish_publish_pose`'s docstring asserted
+  `M·(R0ᵀ·R)·Mᵀ = (M·R0ᵀ·Mᵀ)(M·R·Mᵀ)(M·R0ᵀ·Mᵀ)ᵀ`, which is wrong by O(1); the
+  correct two-factor form is `(M·R0ᵀ·Mᵀ)(M·R·Mᵀ)`, and the left/right branches
+  relate by **conjugation** (`left = P·right·Pᵀ`, `P = M·R0·Mᵀ`). The "order
+  isn't a contract" argument in `process_controller`/README now cites the
+  **right**-multiply identity (`(M·R·Mᵀ)(M·R0·Mᵀ)ᵀ = M·R·R0ᵀ·Mᵀ`), matching
+  protocol.py and test section 5. **Removed unsourced numbers**: the "5000
+  random poses / max deviation 2.2e-16 m" in `docs/ui.md` and `pose_view_qt.py`
+  had no artifact behind it (one hand-written line each); the real regression is
+  `check_gripper_model_frame_invariant` — a **per-pixel** assertion (2 fixed
+  poses, `mismatch == 0`) — and the identity is algebraically exact for any R, v
+  (`MᵀM = I`). `test_pose_publish_deadband.py` no longer quotes the 7.2 mm
+  *false value* as the measured limit (back to 1.39–4.98 mm); `process_controller`'s
+  sourceless "≈1.4°" now cites protocol.py's p50 0.25°/max 1.80°; the
+  guard-interval comment reads "capped at 1.5× the nominal frame period (= 30 ms)".
+  **Gripper pairing**: the single "identity not unique" error conflated "this
+  camera reported no side (empty Flash)" with "both cameras reported the same
+  side"; split into two headlines, the former carrying
+  `sightac[i]/side/flash_ok/device_type/serial/error`. **lite**: `_episode_max`
+  took "largest filename `f` + 1", but `f` wraps every 1000, so once chunk-001
+  exists it returned a *real but wrong* episode in chunk-000 (N=1001 → 1); now
+  uses `list_task_episodes` (`N = c*1000 + f + 1`).
+- **v1.3.14** — a publish-exit **deadband (3 mm)** keeps the estimator's
+  millimetre rest wander out of the trail, the end point, the pose view
+  and `orb_pose.json`. Below the deadband the **previously published
+  value** is published — a substitution, not a suppression, so the sample
+  cadence, timestamps, `lost_count` and the `slam_trajectory` point
+  contract are untouched; only real movement updates it. Rotation is
+  deliberately *not* deadbanded. Measured on strict rest windows (10 s,
+  net displacement <2 mm **and** every point <5 mm from the window
+  median): position wander radius p50 1.06–1.85 mm / max 1.39–4.98 mm per
+  session. The same commit drops the jump gate's constants
+  (`POSE_STEP_ALLOWANCE_M` / `POSE_MAX_LINEAR_SPEED_MPS` /
+  `POSE_MAX_GUARD_INTERVAL_S`) from 0.05 / 3.0 / 0.1 to 0.03 / 2.0 / 0.03
+  — not "stricter" but **no longer inflated by decimation**: stereo frames
+  are decimated 3-of-5, so every third frame arrives after 60 ms, and
+  charging the speed term for that 60 ms tripled the limit exactly on the
+  frames a re-placed pose lands on, letting 0.107–0.224 m of estimator
+  excursion through verbatim (genuine single-sample steps peak at
+  0.0601 m). Mirrored verbatim in the native guard
+  (`fayssense_orb_slam.cc`, `kPose*`).
 - **v1.3.13** — the published gripper SLAM frame changes to **+X=down /
   +Y=left / +Z=forward** (was +X=right / +Y=forward / +Z=up). The same
   numbers feed the pose view, `observation.*slam_trajectory` and
@@ -421,7 +468,7 @@ are documented in [docs/index.md](docs/index.md#开发约定).
   multiply alone would leave it at the constant `M` — two triads ~120°
   apart, which is exactly what the user rejected; the earlier "order is
   a contract" hazard is gone too, since the conjugating `M` now cancels:
-  `(M·R0·Mᵀ)ᵀ(M·R·Mᵀ) == M·R0ᵀ·R·Mᵀ`.) The gripper's *physical*
+  `(M·R·Mᵀ)(M·R0·Mᵀ)ᵀ == M·R·R0ᵀ·Mᵀ`.) The gripper's *physical*
   orientation is untouched: the view moves the model's local vertices by
   the same `M` before rotating them, so the drawn model is pixel-identical
   to before — the two halves must change together, or the gripper renders
@@ -446,9 +493,11 @@ are documented in [docs/index.md](docs/index.md#开发约定).
   Caveat: that tag is **task-level** — a task directory spanning the
   switch can only attest to the last frame written. The cutover is the
   **release**, not a calendar day: episodes recorded by v1.3.12 or
-  earlier (which includes everything currently on disk — the newest
-  episode is from 2026-09-21 21:01) are the old convention and carry no
-  `frame` key at all, so "key absent" means old frame.
+  earlier carry no `frame` key at all, so "key absent" means old frame.
+  The oldest data on disk is all on that side (newest legacy episode
+  2026-09-21 21:01), but the line has since been crossed —
+  `UMI_9_29` (recorded 2026-09-29, 204 episodes) is v1.3.13 and does
+  carry the key, so both conventions now coexist under `data/recordings`.
 - **v1.3.12** — pairing a new gripper no longer needs the vendor toolkit GUI.
   When the app refused to connect a fresh gripper
   (`串口连接失败，无法查询绑定的 Fays 序列号: serial open/handshake failed: Write
@@ -1255,6 +1304,10 @@ venv/bin/python tools/tests/test_sdk_python_version.py
 # 主程序内的夹爪配对与 ESP32 串口诊断（v1.3.12）
 venv/bin/python tools/tests/test_gripper_fays_pairing.py
 venv/bin/python tools/tests/test_gripper_esp_binding.py
+# 删除即真删除（文件 + 录制行；含 lite 上传后删除的编号回归、任务页删除）
+venv/bin/python tools/tests/test_local_delete.py
+venv/bin/python tools/tests/test_task_delete.py
+venv/bin/python tools/tests/lite_delete_test.py
 # 真机相关测试需连接对应设备：d405_worker_test、d435_e2e_test、
 # d435_gui_smoke_test、mono_regression、d435_playback_test 等
 ```
@@ -1306,6 +1359,40 @@ i18n 文案经 `tr()` 翻译、PyQt5 信号参数用 `object` 封送大整数、
 
 ### 更新记录
 
+- **v1.3.15** —— 姿态语义的文档/注释校正 + 夹爪配对报错分型 + lite 取号跨 chunk。
+  **修一处数学错误**：`finish_publish_pose` 的 docstring 把
+  `M·(R0ᵀ·R)·Mᵀ = (M·R0ᵀ·Mᵀ)·(M·R·Mᵀ)·(M·R0ᵀ·Mᵀ)ᵀ` 写成恒等式，代数上不成立
+  （差 O(1)）；正确的两因子式是 `(M·R0ᵀ·Mᵀ)(M·R·Mᵀ)`，左乘/右乘两支的关系是
+  **共轭**（左乘版 = `P·右乘版·Pᵀ`，`P = M·R0·Mᵀ`）。`process_controller`/README
+  论证「顺序不敏感」的左乘支恒等式换成**右乘支**
+  （`(M·R·Mᵀ)(M·R0·Mᵀ)ᵀ = M·R·R0ᵀ·Mᵀ`），与 protocol.py、测试第 5 节一致。
+  **删无出处数字**：`docs/ui.md` 与 `pose_view_qt.py` 的「实测 5000 组随机
+  姿态/最大偏差 2.2e-16 m」背后没有任何产出物（全仓各一行手写），真回归是
+  `check_gripper_model_frame_invariant` 的**逐像素**断言（2 个固定姿态、
+  `mismatch == 0`），而该恒等式对任意 R、v 代数上精确成立（`MᵀM = I`）；
+  `test_pose_publish_deadband.py` 不再把 7.2mm 那个**假值**当实测上限（改回
+  1.39–4.98mm）；`process_controller` 无出处的「≈1.4°」改用 protocol.py 的
+  p50 0.25°/max 1.80°；guard-interval 注释改写成「封顶在 1.5× 名义帧周期
+  （= 30ms）」。**夹爪配对**：原来那句「身份不唯一」把「这台没报出 side
+  （Flash 空/无效）」与「两台报了同一个左右」压在一起（前者会被指成拓扑重复，
+  真因是厂商产线没写 side），拆成两条抬头，前者带
+  `sightac[i]/side/flash_ok/device_type/serial/error`。**lite**：`_episode_max`
+  原来取「最大文件名 `f` + 1」，而 `f` 每 1000 回绕 ⇒ chunk-001 出现后返回
+  chunk-000 里**真实存在**的错段（N=1001 → 1），上传/删除静默操作错段；改走
+  `list_task_episodes`（`N = c*1000 + f + 1`）。
+- **v1.3.14** —— 发布出口加 **3mm 死区**：估计器静止时的毫米级游走不再进
+  轨迹线/末端点/位姿视图/`orb_pose.json`。不足死区时**发布上次的值**（替换，
+  不是抑制 ⇒ 采样节拍、时间戳、`lost_count`、`slam_trajectory` 的逐点契约
+  都不变），只有真实移动才更新它；旋转**故意不做**死区（姿态游走峰峰
+  p50 0.25°/max 1.80°，视觉上不可见，而死区会给真实转动引入手感延迟）。
+  严格静止窗（10s、净位移<2mm **且**窗内每点距窗中���<5mm）实测位置游走半径
+  逐会话 p50 1.06-1.85mm / max 1.39-4.98mm。同一笔把跳变门常量
+  （`POSE_STEP_ALLOWANCE_M` / `POSE_MAX_LINEAR_SPEED_MPS` /
+  `POSE_MAX_GUARD_INTERVAL_S`）从 0.05 / 3.0 / 0.1 收到 0.03 / 2.0 / 0.03
+  —— 不是"更严"，是**不再随抽帧膨胀**：立体帧 3-of-5 抽帧，每三帧有一帧是
+  60ms，把速度项按 60ms 计会把限值在那批帧上抬到 3×，而重定位后的位姿恰好
+  落在那种帧上，于是 0.107-0.224m 的估计器跳变被原样放过去（真实单步峰值
+  0.0601m）。native 侧 `kPose*` 逐字对齐。
 - **v1.3.13** — 夹爪 SLAM 的发布坐标帧改为 **+X=下 / +Y=左 / +Z=前**
   （原 +X=右 / +Y=正对 / +Z=上）。位姿视图、`observation.*slam_trajectory`、
   `orb_pose.json` 是同一份数值，帧也就只有一处 —— 发布入口，形态是
@@ -1315,7 +1402,7 @@ i18n 文案经 `tr()` 翻译、PyQt5 信号参数用 `object` 封送大整数、
   发布姿态 = `M·Mᵀ` = **单位矩阵**，跟随夹爪的三支箭头与世界三箭头在原点
   那一瞬**重合**。只左乘不右乘时它是常数 `M`，两套箭头差约 120° —— 那正是
   被否掉的一版；而且左右都乘之后 `M` 在两边相遇处整个约掉，
-  `(M·R0·Mᵀ)ᵀ(M·R·Mᵀ) == M·R0ᵀ·R·Mᵀ`，原先"顺序是契约"的隐患也一并消失。
+  `(M·R·Mᵀ)(M·R0·Mᵀ)ᵀ == M·R·R0ᵀ·Mᵀ`，原先"顺序是契约"的隐患也一并消失。
   夹爪的**物理朝向一点没变**：视图按同一张 `M` 把模型顶点从旧体轴坐标搬到
   新体轴坐标再旋转，画出来逐像素与改前相同 —— ★这两处必须同进同退，
   只改一处夹爪会被画歪 120°，且两种改法各自都"看起来自洽"。
@@ -1332,8 +1419,9 @@ i18n 文案经 `tr()` 翻译、PyQt5 信号参数用 `object` 封送大整数、
   `frame_axes` 与顶层 `gripper_slam_frame`），读端据此分辨新旧。
   注意该标注是**任务级**的：一个任务目录若跨了这次改帧，只能记住最后写入
   的帧。分界是**发布版本**不是日历日 —— v1.3.12 及更早录的一律旧约定
-  （现存数据最新一段录于 2026-09-21 21:01，全在旧帧那侧），且那些 episode
-  **没有** `frame` 键：键不在就按旧帧读。
+  （老数据最新一段录于 2026-09-21 21:01），且那些 episode **没有** `frame`
+  键：键不在就按旧帧读。这条线**已经跨过去了**：`UMI_9_29`（2026-09-29 录、
+  204 段）是 v1.3.13、带键，两种帧现在并存于 `data/recordings`。
 - **v1.3.12** — 接新夹爪不再需要开厂商工具包 GUI。新板子连不上时报的那句
   `串口连接失败，无法查询绑定的 Fays 序列号: serial open/handshake failed: Write
   timeout` 里，最要紧的问题是「板子到底在不在说话」，而主程序原本答不了。夹爪

collector/config/__init__.py

@@ -3,8 +3,49 @@
 版本号集中定义于此：settings.APP_VERSION 及其他模块均从这里取值。
 """
 
-__version__ = "1.3.13"
+__version__ = "1.3.15"
 
+# v1.3.15 —— 姿态语义的文档/注释校正 + 夹爪配对报错分型 + lite 取号跨 chunk
+#   ①**修一处数学错误**：protocol.finish_publish_pose 的 docstring 把
+#   「M·(R0ᵀ·R)·Mᵀ = (M·R0ᵀ·Mᵀ)·(M·R·Mᵀ)·(M·R0ᵀ·Mᵀ)ᵀ」写成恒等式，代数上不成立
+#   （数值差 O(1)）。正确的两因子式是 M·(R0ᵀ·R)·Mᵀ = (M·R0ᵀ·Mᵀ)(M·R·Mᵀ)；左乘
+#   与右乘两支之间是**共轭**（左乘版 = P·右乘版·Pᵀ，P = M·R0·Mᵀ，R0/M 皆旋转
+#   ⇒ P 正交）。同一主题：README 两处 changelog、process_controller 第 329/857
+#   行论证「顺序不敏感」用的**左乘支**恒等式换成**右乘支**（与 protocol 第 537
+#   行、测试第 5 节一致）；process_controller 第 1018 行记号 R0ᵀ·R 改 R·R0ᵀ。
+#   姿态相对化「新旧数据分开看」的整套说明落在 docs/data.md（新帧已按右乘回填；
+#   旧帧〔无 frame 键〕同样是左乘、本次未动，要不要重解释仍**待判定**）。
+#   ②**无出处数字清理**：docs/ui.md 与 ui/pose_view_qt.py 里「实测 5000 组随机
+#   姿态/顶点，最大偏差 2.2e-16 m」没有任何产出物（全仓只这两行，`git log -S`
+#   指向 0ab64d7c 手写加入），真回归是 test_pose_view_qt.py 的
+#   check_gripper_model_frame_invariant —— **逐像素**断言（2 个固定姿态、
+#   mismatch==0），不是 5000 组、不是米制。该恒等式对任意 R、v 代数上精确成立
+#   （MᵀM = I），只改一半的实偏差是 0.3–0.4 m：删掉那个计数，改成代数事实 +
+#   测试引用。test_pose_publish_deadband.py 把 protocol.py 定性为「假值」的
+#   7.2mm 当成实测上限（同文件 docstring 自相矛盾），改回 1.39–4.98mm；
+#   process_controller 第 898 行的「≈1.4°」无出处，改用 protocol.py 的
+#   p50 0.25°/max 1.80°。protocol.py 的 guard-interval 注释按作者口径写成
+#   「封顶在 1.5× 名义帧周期（= 30ms）」，不再把 cap 本身称作名义周期。
+#   ③**夹爪配对报错分型**：_associate_group 原来把「这台没报出 side（Flash
+#   空/无效）」与「两台报了同一个左右」挤在同一句「身份不唯一」下 —— 前者会被
+#   指成拓扑/端口重复，真因却是厂商产线没写 side（仓库无写路径）。拆成两条
+#   抬头，前者带 sightac[i]/side/flash_ok/device_type/serial/error。
+#   ④**lite 取号跨 chunk**：_episode_max 原来取「最大文件名 f + 1」，而 f
+#   每 1000 回绕 ⇒ chunk-001 出现后返回 chunk-000 里**真实存在**的错段
+#   （N=1001 → 得 1），上传/删除静默操作错段。改走 list_task_episodes
+#   （N = c*1000 + f + 1），顺带删掉随之未用的 import re。
+#   测试：test_device_access_selflock.py 第 8/9/10 节、lite_delete_test.py 第 6 节。
+#
+# v1.3.14 —— 发布位姿死区（最小可报告位移 3mm）：静止时估计器的毫米级游走
+#   （严格静止窗实测：游走半径逐会话 p50 1.06-1.85mm / max 1.39-4.98mm，单帧
+#   步长 p99 只有 0.5mm；"只卡首末"的宽口径会给到 7.2mm 的假值，见
+#   protocol.py 的定义）不再进
+#   轨迹线/末端点/落盘。判据是"距上次**发布**值的累积位移"，与跳变门（比相邻
+#   样本）是两件事；不足死区时**发布上次的值**，所以采样节拍、时间戳、
+#   slam_trajectory 的逐点契约都不变，只是值冻结。详见
+#   core/gripper/slam/protocol.py 的 POSE_PUBLISH_DEADBAND_M 注释与
+#   tools/tests/test_pose_publish_deadband.py / test_gripper_pose_deadband_publish.py。
+#
 # v1.3.13 —— 夹爪 SLAM 的**发布坐标帧**改为 +X=下 / +Y=左 / +Z=前
 #   （原 +X=右 / +Y=正对 / +Z=上）。位姿视图、`observation.*slam_trajectory`、
 #   `orb_pose.json` 是同一份数值 ⇒ 帧只有一处：发布入口，形态是在"姿态相对化
@@ -21,7 +62,17 @@ __version__ = "1.3.13"
 #   各自都"看起来自洽"，从画面上看不出是谁漏了。
 #   左右都乘之后**顺序不再是契约**：M 在两边相遇处整个约掉，
 #   (M·R0·Mᵀ)ᵀ(M·R·Mᵀ) == M·R0ᵀ·R·Mᵀ，"先相对化再重标"与"先重标再相对化"
-#   逐元素相同（有回归钉住）。①位姿视图**不做任何换帧补偿**，发布帧就是它的
+#   逐元素相同（有回归钉住）。⚠这条恒等式写的是**左乘**那一支（`R0ᵀ·R`，锚点体
+#   轴系里的 body delta）—— 相对化从 ≤1.3.12 起一直是左乘（先 process_controller、
+#   v1.3.13 起搬到 protocol），它后来被判定**错**（位置/幅度看着正常，但读端按它
+#   解会让表观旋转轴整体转错），正确口径是**右乘 `R·R0ᵀ`**（世界系相对姿态），修在
+#   v1.3.14。两种乘法只差一个常数共轭，而 `frame` 与 `app_version` **���分不出**
+#   （两个构建都是 `down_left_forward`、`__version__` 都写 "1.3.13"）⇒ 别按版本猜。
+#   **新帧**数据已按右乘回填（UMI_9_29，逐文件 sha256 记在 MIGRATION.json）；
+#   **旧帧**数据（无 frame 键）也是左乘、本次没动，要不要重解释待判定 —— 详见
+#   docs/data.md 的「⚠ 姿态相对化的语义改过一次」。右乘同样与重标可交换
+#   （(M·R·Mᵀ)(M·R0·Mᵀ)ᵀ == M·R·R0ᵀ·Mᵀ），所以「顺序不是契约」的结论不变。
+#   ①位姿视图**不做任何换帧补偿**，发布帧就是它的
 #   数据帧 —— gui 坐标系与轨迹系是同一个，换帧后画面随之整体改变
 #   （场景相对画布转约 120°，世界轴三箭头屏幕位置不动、含义改成下/左/前）。
 #   ⚠v1.3.13 第一版曾在视图入口左乘 V = Mᵀ 求"画面逐像素不变"，那等于把换帧
@@ -47,8 +98,14 @@ __version__ = "1.3.13"
 #   coordinate_frame.json，不是本仓库产的，别混为一谈）。
 #   ⚠它是**任务级**的（features 按并集/后写覆盖合并），一个任务目录跨了改帧时
 #   早期 episode 会被标错。★分界是**发布版本**不是日历日：v1.3.12 及更早录的
-#   （现存 153 个 episode，一律是旧约定、本次原样留着没动；最新一段录于
-#   2026-09-21 21:01）**不写这个键** —— 键不在就等于旧帧，别当默认值读。
+#   **不写这个键** —— 键不在就等于旧帧，别当默认值读。
+#   （老数据一律是旧约定、本次原样留着没动：`data/recordings/UMIGripper_Action_AI`
+#   一个任务就 153 个 episode（另有 `9_21_Test` 15 / `D435-裸手…` 6 /
+#   `S80C-裸手…` 1，都不是 UMI 夹爪的、也不带这个键），最新一段录于
+#   2026-09-21 21:01，**都没有这个键**。新帧那边已有
+#   `data/recordings/UMI_9_29`（2026-09-29 录，204 段，app_version 1.3.13、
+#   gripper_slam_frame=down_left_forward；其姿态已在 2026-10-12 按右乘口径回填）
+#   —— 这条线**已经跨过去了**。）
 #   按 episode 精确区分需要往 meta/episodes 加列（本次未加）。
 #   C++ 侧一字未动（native 帧没变，变的只是 Python 侧 native→发布帧这一映射），
 #   所以无需重编、`libORB_SLAM3.so` 的 md5 也不变。

collector/config/i18n.py

@@ -32,6 +32,12 @@ _TRANSLATIONS = {
     "清空日志":                   {"en": "Clear Log",                     "zh": "清空日志"},
     "刷新历史记录":               {"en": "Refresh History",               "zh": "刷新历史记录"},
     "重置画面大小":               {"en": "Reset Camera Sizes",            "zh": "重置画面大小"},
+    "设备检测栏":                 {"en": "Device Panel",                  "zh": "设备检测栏"},
+    "显示/收起左侧设备检测栏（也可点它标题栏的 × 收起）": {
+        "en": "Show/collapse the left device panel "
+              "(or click the × on its title bar)",
+        "zh": "显示/收起左侧设备检测栏（也可点它标题栏的 × 收起）",
+    },
     "帮助(&H)":                  {"en": "&Help",                         "zh": "帮助(&H)"},
     "关于":                      {"en": "About",                         "zh": "关于"},
     "语言(&L)":                  {"en": "&Language",                     "zh": "语言(&L)"},

collector/config/settings.py

@@ -176,6 +176,14 @@ DEVICE_POLL_INTERVAL_MS = 2000     # 设备列表轮询间隔（毫秒，sysfs
 REALSENSE_VID = "8086"             # Intel vendor ID（排除 RealSense UVC 节点用）
 REALSENSE_PID = "0b07"             # D435 的 product ID；其它型号（如 D435i=0b3a）靠驱动 name 含 "RealSense" 兜底
 
+# 左侧设备检测栏（QDockWidget）的尺寸口径：默认宽度 = 首次启动时的栏宽；
+# 下限 = 允许拖到的最窄（一行「图标 + 勾选框 + 省略号」仍认得出设备）。
+# 栏宽与「是否收起」由用户操作决定并持久化（见 load_device_dock_prefs）。
+# 注：面板内的长提示文案必须自动换行，否则单行 label 的 minimumSizeHint
+# 会成为栏宽的硬地板，把栏顶宽到拖不小（2026-10-13 修的就是这个）。
+DEVICE_DOCK_DEFAULT_WIDTH = 240
+DEVICE_DOCK_MIN_WIDTH = 96
+
 # 传感器命名（写入 parquet observation.<name> 列）
 SENSOR_NAMES = [
     "right_glove",     # 右手手套传感器（16×16 压力矩阵）
@@ -293,6 +301,27 @@ def save_upload_delete_after(on: bool):
     """持久化"上传成功后自动删除本地文件"开关。"""
     _save_server_config({"upload_delete_after": bool(on)})
 
+def load_device_dock_prefs() -> dict:
+    """读取左侧设备检测栏的显示偏好 {"visible": bool, "width": int}。
+
+    缺字段 / 类型不对 / 越界一律回默认（可见、DEVICE_DOCK_DEFAULT_WIDTH）；
+    宽度夹在 [DEVICE_DOCK_MIN_WIDTH, 1200]（上限防手改配置把画面挤没）。
+    """
+    raw = _load_server_config().get("device_dock")
+    if not isinstance(raw, dict):
+        raw = {}
+    try:
+        width = int(raw.get("width", DEVICE_DOCK_DEFAULT_WIDTH))
+    except (TypeError, ValueError):
+        width = DEVICE_DOCK_DEFAULT_WIDTH
+    width = min(max(width, DEVICE_DOCK_MIN_WIDTH), 1200)
+    return {"visible": bool(raw.get("visible", True)), "width": width}
+
+def save_device_dock_prefs(visible: bool, width: int):
+    """持久化设备检测栏的可见性与宽度（收起或拖窄后重启保持）。"""
+    _save_server_config({"device_dock": {"visible": bool(visible),
+                                         "width": int(width)}})
+
 def load_gripper_force_matrix_spec() -> str:
     """读取力矩阵落盘规格（server_config.json，默认 "int16x100"）。
 
@@ -562,12 +591,20 @@ GRIPPER_SLAM_READY_TIMEOUT_S = 45.0             # wait_sdk_ready 上限（SDK
 # ★ 分界是**发布版本**，不是日历日：v1.3.13（2026-09-28）起录的才是本值，
 #   v1.3.12 及更早录的一律旧约定、而且那时**根本不写**这个键 —— 所以
 #   旧 episode 里 frame 键**不存在**，"键不在"就是"旧帧"，别去 lookup 默认。
-#   （2026-09-22..09-27 用 v1.3.12 录的也一样：没有键、旧帧。现存
-#   data/recordings 最新一段录于 2026-09-21 21:01，尚未跨到这条线。）
+#   （2026-09-22..09-27 用 v1.3.12 录的也一样：没有键、旧帧。老数据最新一段
+#   录于 2026-09-21 21:01；新帧那边 `data/recordings/UMI_9_29`（2026-09-29
+#   录、204 段）已经带着这个键 —— 这条线**已经跨过去了**，别再说"尚未跨到"。）
 # ★ 标注还是**任务级**的：features 按并集/后写覆盖合并，一个任务目录若跨了
 #   这次改帧，info.json 只能记住最后写入的帧，早期 episode 会被标错。要按
 #   episode 精确区分得往 meta/episodes 加列（本次未加）；跨线的任务目录请按
 #   录制日期切开，切点用"哪一天升到 v1.3.13"而不是写死的日期。
+# ⚠ 帧是**一套**含义、姿态**相对化**是另一套：相对化从 ≤1.3.12 起一直是**左乘**
+#   （`R0ᵀ·R`，先在 process_controller、v1.3.13 起搬到 protocol），v1.3.14 才改成
+#   正确的**右乘**（`R·R0ᵀ`）。两者只差一个常数共轭，而 frame 与 app_version
+#   **都分不出**（都写 "1.3.13"）⇒ 别按版本猜。**新帧**数据已按右乘回填
+#   （UMI_9_29，逐文件 sha256 见 MIGRATION.json）；**旧帧**数据（无 frame 键）
+#   同样是左乘、本次**没动**，要不要重解释待判定 —— 详见 docs/data.md 的
+#   「⚠ 姿态相对化的语义改过一次」。
 GRIPPER_SLAM_FRAME_ENV = "KSQ_GRIPPER_SLAM_FRAME"
 GRIPPER_SLAM_FRAME_NEW = "down_left_forward"
 GRIPPER_SLAM_FRAME_LEGACY = "right_forward_up"
@@ -580,8 +617,11 @@ GRIPPER_SLAM_FRAME_AXES = {
 # 同上，给界面用的中文。**只此一份** —— ui/pose_view_qt.py 直接读这张表，
 # 不自己抄：屏幕上写的字和上面落进 info.json 的 frame_axes 必须同源，否则
 # 改词只剩一边动，界面和落盘各说各话。
-# 旧约定的 +Y 写"正对"不是"前"：用户自己的叫法就是「X=右 / Y=正对 / Z=上」；
-# 两个帧的 forward 混用同一个中文字，会让人以为它们的 Y 是同一个物理方向。
+# 旧约定的 +Y 写"正对"而不是"前"，理由只有一条：用户自己的叫法就是
+# 「X=右 / Y=正对 / Z=上」，照抄。（**不是**因为两�� forward 指向不同的物理
+# 方向 —— 它们其实是同一个方向：M 把中间帧 +Y 映到发布帧 +Z，所以旧 +Y
+# 「正对」和新 +Z「前」指的是同一处。真正会骗人的是**轴字母**：旧 +Y 与新
+# +Y 差 90°（正对 vs 左），跨帧对齐要看方向词，不能看字母。）
 GRIPPER_SLAM_FRAME_AXES_CN = {
     GRIPPER_SLAM_FRAME_NEW: {"+X": "下", "+Y": "左", "+Z": "前"},
     GRIPPER_SLAM_FRAME_LEGACY: {"+X": "右", "+Y": "正对", "+Z": "上"},

collector/core/egodata_writer.py

@@ -1155,9 +1155,13 @@ class EgoDataWriter(QObject):
                     f"observation.{key}"]
             elif key.endswith("slam_trajectory"):
                 # 帧标注（v1.3.13）：没有它，读端无从知道 xyz 在现实中
-                # 指向哪 —— 2026-09-21 及更早录的 episode 是旧约定
-                # （+X=右/+Y=正对/+Z=上），之后默认 +X=下/+Y=左/+Z=前，
+                # 指向哪 —— v1.3.12 及更早录的 episode 是旧约定
+                # （+X=右/+Y=正对/+Z=上），v1.3.13 起默认 +X=下/+Y=左/+Z=前，
                 # 两者的数值都能正常解出来，只是含义不同。
+                # ★ 分界是**发布版本**（v1.3.13，2026-09-28），不是日历日：
+                # 早先这里写过"2026-09-21 及更早"，那会让 2026-09-22..09-27
+                # 用 v1.3.12 录的数据被当成新帧 —— 它们其实是旧帧且**没有**
+                # 这个键（"键不在"= 旧帧，见 settings.resolve_gripper_slam_frame）。
                 # ⚠ features 是**任务级**、按并集/后写覆盖合并的：一个
                 # 任务目录若跨了这次改帧，这里只能记住最后写入的帧，
                 # 该任务早期的 episode 会被标错。按 episode 精确区分需要

collector/core/gripper/devices/uvc_camera_service.py

@@ -585,6 +585,18 @@ class UvcCameraServiceManager:
                 "libusb/libuvc 动态发现失败 "
                 f"rc={completed.returncode}: {details or '<no detail>'}"
             )
+        # 发现程序那行逐台相机的现场（stderr 的 `[DISCOVERY] …`）在 rc==0
+        # 时同样是唯一线索。注意它**不是**唯一的载体：JSON 里也有 `error`
+        # 字段（"XU unit: …" / "XU6 prepare: …" 就是写进去再回显到 stderr
+        # 的）。JSON 丢掉的是**三态**——`mode` 的 ok/unknown/failed 被压成
+        # `mode_ok` 布尔，flash/calibration 的 ok|failed|skipped 只剩两个布尔
+        # ——而认不认得出「模式协商失败」还是「Flash 读出来是空串」就靠它。
+        # 过去这里只在 rc!=0 时读 stderr，rc==0 那次的现场就整份不进日志，
+        # 只剩一句 side=''。
+        stderr_text = (completed.stderr or "").strip()
+        if stderr_text:
+            for line in stderr_text.splitlines():
+                self._logger(f"[UVC-DISCOVER] {line}")
         try:
             report = json.loads(completed.stdout)
         except json.JSONDecodeError as exc:
@@ -650,13 +662,32 @@ class UvcCameraServiceManager:
             raise UvcCameraServiceError(
                 "UVC 组 Sightac 数量不是 2"
             )
-        for candidate in sightac:
+        for index, candidate in enumerate(sightac):
             side = str(candidate.get("side") or "").strip().lower()
-            if side not in {"left", "right"} or side in normalized[
-                "sightac"
-            ]:
+            # 两种故障分开报：①这台相机**没报出** left/right（Flash 的 side
+            # 字段读不出来 / 是空串 / 值不认识）；②两台报了同一个左右。
+            # 挤在一句「身份不唯一」下会把①指成「拓扑/端口重复」——那台相机
+            # 的 side 得由厂商产线补写（仓库无写路径），照"重复"去查只会在
+            # 拓扑上白转一圈。现场原文见 docs/data.md / memory
+            # `uvc-pairing-side-empty`。
+            if side not in {"left", "right"}:
                 raise UvcCameraServiceError(
-                    f"UVC 组 left/right Flash 身份不唯一: side={side!r}"
+                    "UVC 组 Sightac 未报出有效左右（Flash 的 side 为空/"
+                    "无效，非左右重复）: "
+                    f"sightac[{index}] side={side!r} "
+                    f"flash_ok={candidate.get('flash_ok')!r} "
+                    f"device_type={candidate.get('device_type')!r} "
+                    f"serial={candidate.get('flash_serial')!r} "
+                    f"error={candidate.get('error')!r}"
+                )
+            if side in normalized["sightac"]:
+                raise UvcCameraServiceError(
+                    f"UVC 组 left/right Flash 身份不唯一: "
+                    f"sightac[{index}] side={side!r} "
+                    f"flash_ok={candidate.get('flash_ok')!r} "
+                    f"device_type={candidate.get('device_type')!r} "
+                    f"serial={candidate.get('flash_serial')!r} "
+                    f"error={candidate.get('error')!r}"
                 )
             normalized["sightac"][side] = candidate
         if set(normalized["sightac"]) != {"left", "right"}:
@@ -708,7 +739,7 @@ class UvcCameraServiceManager:
                 # 逐组记下拒绝原因：这里吞掉的往往才是真因（触觉相机
                 # mode 探测失败、Flash 身份缺失…），只报 matches/groups
                 # 计数会让人去猜拓扑，等于把现场丢掉一次。
-                label = group.get("physical_usb_path") or "group#{}".format(index)
+                label = group.get("outer_path") or "group#{}".format(index)
                 rejections.append("{}: {}".format(label, exc))
                 continue
         if len(matches) != 1:

collector/core/gripper/orb_slam_src/ORB-SLAM/Examples/fays/fayssense_orb_slam.cc

@@ -103,9 +103,22 @@ static constexpr double kInactiveCleanupRetryS = 1.0;
 // may nevertheless change its world frame after VIBA/loop correction; that
 // coordinate-frame jump is rebased below instead of being published as
 // motion.  The same limits are independently enforced at the Python boundary.
-static constexpr float kPoseStepAllowanceM = 0.05f;
-static constexpr float kPoseMaxLinearSpeedMps = 3.0f;
-static constexpr double kPoseMaxGuardIntervalS = 0.1;
+//
+// The interval is capped at the *nominal* frame period, not the largest one
+// seen: stereo frames are decimated 3-of-5, so one frame in every three
+// arrives after 60 ms instead of 20 ms.  Charging the speed term for that
+// 60 ms triples the limit exactly on the frames a re-placed pose lands on
+// (0.05 + 3.0*0.06 = 0.23 m), which let 0.107-0.224 m of estimator excursion
+// through verbatim instead of being rebased -- the visible 抖/飘.
+// Measured over 69061 published samples in 20 sessions (2026-10-10..13):
+// genuine single-sample steps peak at 0.0601 m (p99 0.043) and the smallest
+// excursion is 0.1075 m, so 0.03 + 2.0*0.03 = 0.09 m at dt>=30 ms separates
+// them with margin on both sides and is a no-op on every clean session.
+// (Rotation keeps 20 deg + 1080 deg/s; with the same cap the 30 ms limit is
+// 52.4 deg against a largest genuine step of 15.75 deg.)
+static constexpr float kPoseStepAllowanceM = 0.03f;
+static constexpr float kPoseMaxLinearSpeedMps = 2.0f;
+static constexpr double kPoseMaxGuardIntervalS = 0.03;
 static constexpr float kPoseAngleAllowanceRad =
     20.0f * static_cast<float>(M_PI) / 180.0f;
 static constexpr float kPoseMaxAngularSpeedRadS =

collector/core/gripper/slam/process_controller.py

@@ -22,8 +22,9 @@ from core.gripper.runtime.device_access import device_access_guard, FAYS_SDK_INI
 from config import settings as app_settings
 
 from .protocol import (
-    FAYS_STAGE_KEYS, PoseSample, finish_publish_pose, parse_slam_line,
-    pose_rejection_reason, rotate_pose_z90,
+    FAYS_STAGE_KEYS, POSE_PUBLISH_DEADBAND_M, PoseSample, finish_publish_pose,
+    parse_slam_line, pose_below_deadband, pose_rejection_reason,
+    rotate_pose_z90,
 )
 
 
@@ -314,13 +315,18 @@ class SlamProcessController:
         self._pose_buffer_lock = threading.Lock()
         self._last_accepted_pose = None
         self._pose_rejecting = False
+        # 死区参照：**上次真正发布出去的位置**（发布帧）。保持期间**不更新**
+        # 它 —— 累计位移要一直算到超过死区才换值（见 _publish_pose）。
+        self._last_published_position = None
         # 原点后姿态相对化：设原点事件后捕获首帧**中间帧**姿态作为
-        # 基准，此后所有姿态左乘基准的逆 → 中间帧第一帧恒为单位矩阵，
+        # 基准，此后所有姿态**右乘**基准的逆（R·R0ᵀ = 世界系相对姿态；左乘
+        # 算出来的是锚点体轴系里的增量，差一个常数共轭、表观旋转轴整体转错）
+        # → 中间帧第一帧恒为单位矩阵，
         # 帧轴与轨迹同基准（相对原点），见 _publish_pose。
         # ★ 基准活在中间帧（rotate_pose_z90 的输出）里，**不是**发布帧。
         #   字段名里的 _mid 就是提醒这件事，改名前先读 _publish_pose。
         #   顺序本身自 v1.3.13 起不再敏感（姿态左右各乘一次 M 之后，
-        #   M 在两步相遇处整个约掉，(M·R0·Mᵀ)ᵀ(M·R·Mᵀ) 与先相对化再重标
+        #   M 在两步相遇处整个约掉，(M·R·Mᵀ)(M·R0·Mᵀ)ᵀ 与先相对化再重标
         #   逐元素相同，有回归钉着）；但基准必须与**进来的样本**同帧才好
         #   推理，而样本在这一步还是中间帧 —— 所以基准就留在中间帧。
         self._pose_rotation_zero_mid = None
@@ -436,6 +442,7 @@ class SlamProcessController:
             self._initial_origin_generation = None
             self._last_accepted_pose = None
             self._pose_rejecting = False
+            self._last_published_position = None
             self._last_pose_reject_log = float("-inf")
             self._fays_rates_alarm.reset()
             self._pose_raw_seq = 0
@@ -847,7 +854,7 @@ class SlamProcessController:
         # 发布帧自 v1.3.13 起是中间帧再叠一次世界重标，环境变量可回落。
         # ★ 相对化与重标的先后顺序自 v1.3.13 起**不再敏感**：姿态是左右各
         #   乘一次 M·R·Mᵀ，两步一倒 M 会在相遇处整个约掉，
-        #   (M·R0·Mᵀ)ᵀ(M·R·Mᵀ) == M·R0ᵀ·R·Mᵀ（回归钉在
+        #   (M·R·Mᵀ)(M·R0·Mᵀ)ᵀ == M·R·R0ᵀ·Mᵀ（回归钉在
         #   tools/tests/test_gripper_pose_axes.py 第 5 节）。改动之前那个
         #   "反过来就少换一次帧、夹爪跟轨迹差 90°" 的坑已经不在了。
         #   finish_publish_pose 仍是唯一入口，因为它同时管着锚定与要不要重标。
@@ -862,11 +869,11 @@ class SlamProcessController:
         # 原点后姿态相对化：C++ 设原点只把位置归零，静止首帧的姿态
         # 仍带部署校正/启动朝向的常数旋转（旋转跳变的根源，两轮
         # 变换形式修正都没能抵消它）。改为捕获首帧**中间帧**姿态为基准，
-        # 全部姿态左乘基准的逆 → 中间帧首帧恒为单位矩阵（帧轴与世界
-        # 轴对齐，不跳变），此后姿态 = 相对原点的真实转动，与轨迹
+        # 全部姿态**右乘**基准的逆（R·R0ᵀ）→ 中间帧首帧恒为单位矩阵（帧轴与
+        # 世界轴对齐，不跳变），此后姿态 = 相对原点的真实转动，与轨迹
         # （位置相对原点）同基准。位置不动，保持已验证的轨迹映射。
         #
-        # 基准捕获与左乘都必须留在中间帧里 —— 基准是拿来跟**进来的样本**
+        # 基准捕获与右乘都必须留在中间帧里 —— 基准是拿来跟**进来的样本**
         # 直接相乘的，样本走到这一步还是中间帧，基准就得同帧（字段名里的
         # _mid 就是这个约束）。
         # ⚠ 别再照抄老注释说"提到前面会让发布帧退回中间帧"：自 v1.3.13
@@ -882,6 +889,20 @@ class SlamProcessController:
             self._pose_rotation_zero_mid,
             relabel=self._publish_relabel,
         )
+        # 极小幅度噪声死区（最小可报告位移，见 protocol.POSE_PUBLISH_DEADBAND_M）：
+        # 静止时估计器的毫米级游走单帧远在跳变限值之下，跳变门管不着，于是
+        # 轨迹末端在放大视图里持续微抖。位移不足死区时**发布上次的值**——
+        # 不是像跳变门那样不发布：采样节拍、时间戳、落盘的 slam_trajectory
+        # 逐点时刻全部保持不变，只是值冻结，下游按时间对齐/回放那套契约
+        # 一个字都不动（轨迹是按发布位置追加的，冻结值 = 末端点不再加噪声）。
+        # 姿态这一路不动：静止姿态游走峰峰 p50 0.25°/max 1.80°（另一会话
+        # 3.46°，出处见 protocol.py 的 POSE_PUBLISH_DEADBAND_M 注释），比
+        # 位置更该镇，但按死区量化会把真实慢转也切成一档一档，得不偿失
+        # （要动先测清楚再动）。
+        if pose_below_deadband(pose.position, self._last_published_position):
+            pose = replace(pose, position=self._last_published_position)
+        else:
+            self._last_published_position = pose.position
         self._on_pose(pose)
         timestamp = pose.timestamp
         x, y, z = pose.position
@@ -974,6 +995,13 @@ class SlamProcessController:
             return
         if event.kind == "ready":
             self._set_state(status="READY - Press ENTER")
+            # 死区生效与否必须**在画面上能确认**：开机时把当次生效值打进日志。
+            # 用户是拿 GUI 验收的（静止时轨迹线/末端点还抖不抖），没有这一行
+            # 就只能靠"感觉没变"来判断，而感觉分辨不出 3mm。
+            self._log(
+                f"[SLAM] 发布位姿死区 {POSE_PUBLISH_DEADBAND_M * 1000:.1f}mm："
+                "静止时的毫米级游走不再进轨迹/落盘（真实移动不量化）"
+            )
             if self._auto_origin:
                 self.send_origin("initial origin")
             else:
@@ -982,10 +1010,14 @@ class SlamProcessController:
         if event.kind == "origin":
             self._last_accepted_pose = None
             self._pose_rejecting = False
+            # 重设原点 = 发布位置整体换锚（当前位姿归零），死区参照必须一起
+            # 丢：否则会拿旧锚下的位置去比新锚下的位置，差出来的那段锚位移
+            # 会把首帧顶掉或反过来冻住首帧。
+            self._last_published_position = None
             # 位置在原点帧被 C++ 归零，姿态却带着部署校正/启动朝向的
             # 常数残留（上次跳变的根源）；每个 origin 事件（含 NEW
             # ORIGIN）都重新捕获首帧姿态基准，与位置重归零保持一致。
-            # 重新锚定后发布帧的首帧姿态是**单位矩阵**（相对化 R0ᵀ·R 再
+            # 重新锚定后发布帧的首帧姿态是**单位矩阵**（相对化 R·R0ᵀ 再
             # 左乘 M、右乘 Mᵀ 给体轴改名，M·Mᵀ = I）——夹爪体轴与世界轴
             # 在原点那一瞬重合，跟位置的"首帧就是原点"一致。
             # ⚠只左乘不右乘（v1.3.13 之前）时它是常数 M，那才是要留心的

collector/core/gripper/slam/protocol.py

@@ -66,15 +66,40 @@ MP_CLEANUP_SPECS = (
 FAYS_STAGE_KEYS = ("wait_ms", "preprocess_ms", "middle_ms", "post_ms")
 
 # The gripper cannot physically cover these distances between consecutive
-# 25 Hz SLAM samples.  The small fixed allowance absorbs normal estimator
+# SLAM samples.  The small fixed allowance absorbs normal estimator
 # corrections; the speed term keeps the gate independent of the exact FPS.
+#
+# POSE_MAX_GUARD_INTERVAL_S caps the interval at 1.5x the *nominal* frame
+# period (= 30 ms; the nominal is the 20 ms 50 fps input period), not the
+# largest one seen: stereo frames are decimated 3-of-5, so one frame in
+# every three arrives after 60 ms instead of 20 ms.  Charging the speed term
+# for that 60 ms triples the limit exactly on the frames a re-placed pose lands
+# on, which let 0.107-0.224 m of estimator excursion through verbatim instead
+# of being held.  Measured over 69061 published samples in 20 sessions: genuine
+# single-sample steps peak at 0.0601 m (p99 0.043), smallest excursion 0.1075 m.
+# Mirrored verbatim in the native guard (fayssense_orb_slam.cc, kPose*).
 POSE_MAX_ABS_POSITION_M = 10.0
-POSE_STEP_ALLOWANCE_M = 0.05
-POSE_MAX_LINEAR_SPEED_MPS = 3.0
-POSE_MAX_GUARD_INTERVAL_S = 0.1
+POSE_STEP_ALLOWANCE_M = 0.03
+POSE_MAX_LINEAR_SPEED_MPS = 2.0
+POSE_MAX_GUARD_INTERVAL_S = 0.03
 POSE_ANGLE_ALLOWANCE_RAD = math.radians(20.0)
 POSE_MAX_ANGULAR_SPEED_RAD_S = math.radians(1080.0)
 
+# 极小幅度噪声死区：**最小可报告位移**。静止时估计器仍在游走——实测 20 个
+# 会话、69061 条发布位姿。静止段的判据是（10s 窗、净位移<2mm）**且**（窗内
+# 每点距窗中位<5mm）——后半条不能省：只卡首末时，那些"出去又回来"的窗会把
+# 统计量整体抬高（单看首末得到的 max 是 7.2mm 的假值）。按这个严格口径，位置
+# 游走半径（距窗中位）逐会话 p50 1.06-1.85mm、逐会话 max 1.39-4.98mm；姿态
+# 峰峰 p50 0.25°、max 1.80°（另有一会话 3.46°）。默认视野
+# 327px/m（span 0.5m 画在 420px 上）下 1mm≈0.33px 看不出来，但用户放大到
+# 4-10× 检查轨迹时，那就是 3-10px 的连续抖动——「静止时轨迹线/末端点还在
+# 小抖」报的就是它。3mm 死区实测：四个会话的静止窗 99.8-100% 帧被冻结，
+# 全段误差 p50≤1.4mm、max=3.0mm（10× 下 10px，且只出现在真实移动时的量化，
+# 不出现在静止时）。
+# ★ 与上面那组"跳变门"是两件事：跳变门比的是**相邻样本**（毫米级游走远在
+#   限值之下，它管不着），死区比的是**距上次发布值**的累积位移。
+POSE_PUBLISH_DEADBAND_M = 0.003
+
 _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+]+)\)"
@@ -209,6 +234,21 @@ def pose_rejection_reason(current, previous=None):
     return None
 
 
+def pose_below_deadband(position, reference, epsilon=POSE_PUBLISH_DEADBAND_M):
+    """当前位置距**上次发布值**是否小于死区（是 → 保持上次发布的值）。
+
+    比的是**累积位移**而不是相邻样本：静止时的毫米级游走单帧远小于任何跳变
+    限值，只有对着"上次真正发出去的那个位置"累计，才分得出游走与真实移动。
+    reference 为 None（会话首帧 / 刚重设原点）时恒为 False —— 首帧必须发。
+    """
+
+    if reference is None:
+        return False
+    return math.sqrt(sum(
+        (position[index] - reference[index]) ** 2 for index in range(3)
+    )) < epsilon
+
+
 @dataclass(frozen=True)
 class FaysRateSample:
     image_input: float
@@ -481,15 +521,28 @@ def relabel_published_frame(pose):
 def finish_publish_pose(pose, rotation_zero=None, relabel=True):
     """发布入口最后一步：原点后姿态相对化 →（可选）世界重标（含体轴改名）。
 
-    顺序：**现在两种顺序等价**，不再有雷。旧版（重标只左乘 M）时反过来做
-    会让 M 整体约掉、发出去的还是中间帧，而位置确实换了帧，于是 GUI 里
-    夹爪体轴模型会画成转了 90° 的姿势；v1.3.13 的重标改成左右各乘一次
-    （M·R·Mᵀ，右乘 = 体轴改名，见 relabel_published_frame）之后，
-        (M·R0·Mᵀ)ᵀ·(M·R·Mᵀ) = M·R0ᵀ·R·Mᵀ
-    与"先相对化再重标"逐元素相同 —— 共轭让 M 在两步里都自消。
-    tools/tests/test_gripper_pose_axes.py 第 5 节把这条等价性钉住了。
-    保留这个函数当唯一入口，是因为它同时管着"锚点相对化"和"要不要重标"
-    两件事，拆开调用迟早有人只做一半。
+    ★ 相对化是**右乘** R0ᵀ（世界系相对姿态 R·R0ᵀ），不是左乘。v1.3.13 里
+    写成了左乘 R0ᵀ·R，那算出来的是"在锚点体轴系里表达的相对转动"（body
+    delta）——数值上只差一个常数共轭，却让人看见的旋转轴整体转错：
+      发布姿态(右乘) = M·(R·R0ᵀ)·Mᵀ = (M·R·Mᵀ)·(M·R0·Mᵀ)ᵀ
+      发布姿态(左乘) = M·(R0ᵀ·R)·Mᵀ = P·[发布姿态(右乘)]·Pᵀ，
+      其中 P = M·R0·Mᵀ（R0、M 都是旋转 ⇒ P 正交，P⁻¹ 就是 Pᵀ）
+    ⚠别把这两支写成"同一个式子多乘一个因子"：左乘支不是右乘支右边再挂一个
+    (M·R0·Mᵀ) 的转置（代数上不成立，数值差 O(1)），而是**共轭**关系。
+    早期注释里那个三因子式是错的，已删。
+    锚点 R0 = R_z(90°)·correction = R_x(−90°) 时，那个常数恰是"绕发布帧
+    Y 轴 ±90°"：Y 正好是不动轴（所以只有绕 Y 的手感是对的），X 与 Z 被
+    对调并翻一个号。用户实测三条（绕 X → 表观绕 Z 同向、绕 Z → 表观绕 X
+    反向、绕 Y → 正常）逐条由此而来。右乘后表观旋转轴 = M·a 与物理一致，
+    锚点那一瞬仍是单位矩阵（画面不变），位置一个字不动。
+    tools/tests/test_gripper_pose_axes.py 第 10 节把"世界系相对姿态"钉住了，
+    第 4 节钉"锚点 = 单位矩阵"。
+
+    顺序：**先相对化再重标 与 先重标再相对化等价**（共轭让 M 在两步里都
+    自消）：
+        (M·R·Mᵀ)·(M·R0·Mᵀ)ᵀ = M·R·R0ᵀ·Mᵀ
+    第 5 节把这条等价性钉住了。保留这个函数当唯一入口，是因为它同时管着
+    "锚点相对化"和"要不要重标"两件事，拆开调用迟早有人只做一半。
 
     pose 必须已处于中间帧（rotate_pose_z90 的输出）。
     rotation_zero = 本锚段的**中间帧**首帧姿态；None → 不做相对化
@@ -500,8 +553,10 @@ def finish_publish_pose(pose, rotation_zero=None, relabel=True):
     if rotation_zero is not None:
         pose = replace(
             pose,
+            # 右乘 R0ᵀ = 世界系相对姿态；写成左乘会把表观旋转轴整体转错
+            # 一个常数（v1.3.13 的 bug，见上面 docstring）
             rotation=quat_product(
-                quat_conjugate(rotation_zero), pose.rotation),
+                pose.rotation, quat_conjugate(rotation_zero)),
         )
     if not relabel:
         return pose

collector/core/helpers.py

@@ -884,8 +884,39 @@ def _rmdir_empty(path: str) -> bool:
         return False
 
 
+def pooled_episode_leftovers(task_dir: str, episode_index: int) -> list:
+    """episode N 删除后仍留在磁盘上的文件（空列表 = 真删干净）。
+
+    三处都要查：data/chunk-c/episode-f.parquet、videos/chunk-c/*/episode-f.*、
+    meta/episodes 行（每段一文件；旧分片则在分片里查该行还在不在）。
+    读不出分片内容时按「疑似残留」处理——宁可报未删净也不谎报成功。
+    """
+    left = []
+    dp = pooled_data_parquet_path(task_dir, episode_index)
+    if os.path.isfile(dp):
+        left.append(dp)
+    for _key, p in episode_video_files(task_dir, episode_index).items():
+        if os.path.isfile(p):
+            left.append(p)
+    cidx, _f = episode_chunk_file(episode_index)
+    ep_candidates = [pooled_episodes_path(task_dir, episode_index),
+                     _legacy_episodes_shard_path(task_dir, cidx)]
+    import pyarrow.parquet as pq
+    for ep_file in ep_candidates:
+        if not os.path.isfile(ep_file):
+            continue
+        try:
+            rows = pq.read_table(ep_file).to_pylist()
+        except Exception:
+            left.append(ep_file)   # 读不出来 → 无法确认该行还在不在，按残留算
+            continue
+        if any(r.get("episode_index") == episode_index for r in rows):
+            left.append(ep_file)
+    return left
+
+
 def delete_pooled_episode(task_dir: str, episode_index: int) -> bool:
-    """彻底删除 episode N 的文件组（用户裁决：GUI 删除不走回收区）。
+    """彻底删除 episode N 的文件组（用户裁决：GUI 删除不走回收区），并校验。
 
     - videos/<key>/episode-{f}.{ext} 各流文件
     - data/chunk-{c}/episode-{f}.parquet
@@ -893,7 +924,11 @@ def delete_pooled_episode(task_dir: str, episode_index: int) -> bool:
       同口径）
     统计不回退（stats/total_episodes 保持，与进度语义一致）。
 
-    幂等：文件组已不存在也返回 True（视为已删）。
+    幂等：文件组已不存在返回 True（视为已删）。
+
+    返回 True **仅当三处都确认没了**（pooled_episode_leftovers 为空）；
+    os.remove 失败/权限/读不出分片 → 返回 False，由调用方如实报错——
+    不许再出现「界面报已删除、文件还在」。
     """
     files = episode_video_files(task_dir, episode_index)
     for key, src in files.items():
@@ -950,7 +985,39 @@ def delete_pooled_episode(task_dir: str, episode_index: int) -> bool:
                 if _fcntl is not None:
                     _fcntl.flock(fh.fileno(), _fcntl.LOCK_UN)
                 fh.close()
-    return True
+    return not pooled_episode_leftovers(task_dir, episode_index)
+
+
+def delete_local_session(session_path: str, episode_index: int = 0) -> tuple:
+    """本地删除统一入口（真删除）——播放页手动删除与上传后删除共用同一口径。
+
+    池化布局（episode_index > 0）删该 episode 文件组（数据 + 视频 + meta 行）；
+    旧格式会话目录（episode_index == 0）整目录删除。两处都做删除后校验。
+
+    返回 (ok, err)：ok=True 时 err 为空串；否则 err 是给界面显示的原因
+    （残留文件路径 / OSError 文本 / 目录不存在）。绝不吞错——报成功必须
+    真的是文件已不在。
+    """
+    if not session_path:
+        return False, "会话路径为空"
+    if episode_index > 0:
+        if delete_pooled_episode(session_path, episode_index):
+            return True, ""
+        left = pooled_episode_leftovers(session_path, episode_index)
+        if left:
+            return False, "删除后仍有 {} 个文件残留（如 {}）".format(
+                len(left), left[0])
+        return False, "删除未完成"
+    import shutil
+    if not os.path.isdir(session_path):
+        return False, "会话目录不存在"
+    try:
+        shutil.rmtree(session_path)
+    except OSError as e:
+        return False, str(e)
+    if os.path.isdir(session_path):
+        return False, "删除后目录仍存在"
+    return True, ""
 
 
 # ═══════════════════════════════════════════════════════════

collector/core/recording_repository.py

@@ -2,6 +2,7 @@
 数据仓库层 —— 录制记录的增删改查操作。
 """
 
+import os
 from typing import List, Optional
 from core.database import db
 from core.recording_record import RecordingRecord
@@ -49,6 +50,37 @@ class RecordingRepo:
         db.conn.execute("DELETE FROM recording WHERE id=?", (record_id,))
         db.conn.commit()
 
+    @staticmethod
+    def delete_local_episode(file_path: str, episode_index=None) -> int:
+        """真删除：本地文件已删净后，把该 episode 的录制行从库里删掉。
+
+        与 mark_deleted / mark_uploaded_deleted 的区别就是不受「行保留」约束——
+        删除 = 真删除（文件 + 记录一起消失），返回删除行数。
+        """
+        cond, args = RecordingRepo._where(file_path, episode_index)
+        cur = db.conn.execute(f"DELETE FROM recording WHERE {cond}", args)
+        db.conn.commit()
+        return cur.rowcount
+
+    @staticmethod
+    def delete_local_dir(dir_path: str) -> int:
+        """真删除：某个录制目录（整个任务/旧格式会话目录）下的全部录制行。
+
+        路径按 abspath+normpath 归一化后比较——库里历史行可能带尾斜杠或用
+        了不同的相对写法，不能只靠字符串等值。
+        """
+        if not dir_path:
+            return 0
+        target = os.path.normpath(os.path.abspath(dir_path))
+        rows = db.conn.execute("SELECT id, file_path FROM recording").fetchall()
+        ids = [r[0] for r in rows
+               if r[1] and os.path.normpath(os.path.abspath(r[1])) == target]
+        if not ids:
+            return 0
+        db.conn.executemany("DELETE FROM recording WHERE id=?", [(i,) for i in ids])
+        db.conn.commit()
+        return len(ids)
+
     @staticmethod
     def _where(file_path: str, episode_index):
         """匹配条件：v1.1.0 起按 (file_path, episode_index) 定位一个 episode；

collector/docs/config.md

@@ -47,6 +47,7 @@ config/ 是应用全局配置、国际化与版本号所在的配置包。版本
 | `load_server_url` / `save_server_url` | `() -> str` / `(url: str)` | 读 / 存用户服务器地址 | 无保存值或空串时返回出厂默认 `SERVER_URL` |
 | `load_credentials` / `save_credentials` | `() -> tuple[str, str]` / `(username, password)` | 读 / 存登录凭据 | 返回 `(username, password)` |
 | `load_upload_auto_sync` / `save_upload_auto_sync` | `() -> bool` / `(on: bool)` | 读 / 存"录制完成后自动上传"开关 | 缺省默认 `True`（沿用历史行为） |
+| `load_device_dock_prefs` / `save_device_dock_prefs` | `() -> dict` / `(visible: bool, width: int)` | 读 / 存左侧设备检测栏的显示偏好 `{"visible": bool, "width": int}` | 缺字段/类型不对回默认（可见、`DEVICE_DOCK_DEFAULT_WIDTH`）；宽度夹在 `[DEVICE_DOCK_MIN_WIDTH, 1200]` |
 | `load_upload_delete_after` / `save_upload_delete_after` | `() -> bool` / `(on: bool)` | 读 / 存"上传成功后自动删除本地文件"开关 | 缺省默认 `False` |
 | `load_device_names` / `save_device_name` / `remove_device_name` | `() -> dict` / `(key, name, sensor="")` / `(key)` | 设备命名表读 / merge-write / 删除 | `sensor` 仅 `data_ble` 用，绑定 parquet 列名；`""` 表示不动原值 |
 | `device_name` / `device_sensor_role` | `(key: str) -> str` | 读单个设备名 / 读绑定列名 | 兼容 `{"name": …}` 结构与旧版纯字符串；无则空串 |
@@ -85,6 +86,7 @@ config/ 是应用全局配置、国际化与版本号所在的配置包。版本
 | RealSense | `REALSENSE_PROFILES["D405"]` | dict | `depth_resolution`/`rgb_resolution` `(1280,720)`、`fps` 30、`depth_near_mm` 100、`depth_far_mm` 1000、`heatmap_smooth_k` 3、`heatmap_temporal_alpha` 0.5 | D405 短距近景配置 |
 | 设备检测 | `DEVICE_SCAN_MAX_INDEX` / `DEVICE_POLL_INTERVAL_MS` | int | 16 / 2000 | V4L2 枚举上限 / 轮询间隔（毫秒） |
 | 设备检测 | `REALSENSE_VID` / `REALSENSE_PID` | str | `"8086"` / `"0b07"` | Intel vendor ID / D435 product ID（其他型号靠驱动 name 兜底） |
+| 设备检测 | `DEVICE_DOCK_DEFAULT_WIDTH` / `DEVICE_DOCK_MIN_WIDTH` | int | 240 / 96 | 左侧设备检测栏首启宽度 / 允许拖到的最窄（面板内提示文案必须自动换行，否则单行 label 会把栏宽地板顶宽 —— 见 `docs/ui.md` DevicePanel 段） |
 | 传感器 | `SENSOR_NAMES` | list | `["right_glove", "left_glove"]` | 写入 parquet observation 列名 |
 | 手部 | `HAND_POSE_LEFT` / `HAND_POSE_RIGHT` / `HAND_POSE_DIM` / `SENSOR_DIM` | str / str / int / int | `"left_hand_pose"` / `"right_hand_pose"` / 63（21×3）/ 256 | 手部 63 维、触觉 16×16 展平 |
 | 显示 | `CAMERA_MIRROR_HORIZONTAL` / `DISPLAY_FPS_LIMIT` / `FEED_MIN_WIDTH` / `FEED_MIN_HEIGHT` | bool / int / int / int | `True` / 30 / 320 / 240 | 镜像翻转（显示+录制）、GUI 帧率上限、最小画面 |
@@ -119,7 +121,7 @@ config/ 是应用全局配置、国际化与版本号所在的配置包。版本
 
 **JSON 字段约定**（由本模块的读写函数定义）：
 
-- `data/server_config.json`：`server_url`（str）、`username`（str）、`password`（str）、`upload_auto_sync`（bool，缺省 `True`）、`upload_delete_after`（bool，缺省 `False`）。
+- `data/server_config.json`：`server_url`（str）、`username`（str）、`password`（str）、`upload_auto_sync`（bool，缺省 `True`）、`upload_delete_after`（bool，缺省 `False`）、`device_dock`（dict，设备检测栏的 `{"visible": bool, "width": int}`，缺省 `{"visible": True, "width": 240}`）。
 - `data/device_names.json`：key = `DeviceInfo.stable_key`（形如 `"uvc:{by-id前缀}"` / `"uvc:usb-1-5"`（无 by-id 链接、或该前缀被同型号多台共用而归属会翻转时，退到 USB 拓扑路径）/ `"d435:{serial}"` / `"ble:{MAC}"` 等），value = `{"name": str, "sensor"?: str}`（`sensor` 仅 `data_ble` 设备用，绑定 parquet 列名 `right_glove`/`left_glove`，按 MAC 持久化）；旧版纯字符串自动升级为 `{"name": …}`。
 - `data/device_params.json`：key 同 `stable_key`，value = `{"exposure": {"auto": bool, "value": float}, "original": {同结构}}`；`auto=True` 时 `value` 忽略；`original` 首次看到才写入、之后永不覆盖，供"恢复默认"回到开机原厂曝光。
 

collector/docs/core.md

@@ -450,6 +450,8 @@ JSON 读写。docstring 写明其 JSON 布局即为 `calibration/head_stereo.jso
 `core.database` 的单例 `db`。其中 `mark_uploaded` 支持"上传成功、本地保留"
 的语义（行保留、状态改为 `uploaded`），`mark_uploaded_deleted` 支持"上传
 成功、本地已删"（状态 `uploaded_deleted`），两者都保证历史可查。
+**本地文件被真删除时用 `delete_local_episode` / `delete_local_dir` 把录制行
+一并真删**（2026-10-12：删除 = 真删除，文件与记录一起消失，不再留痕迹行）。
 
 **类/函数**：
 
@@ -459,6 +461,8 @@ JSON 读写。docstring 写明其 JSON 布局即为 `calibration/head_stereo.jso
 | `RecordingRepo.list_all` | `(limit=100)` | 按 `started_at` 倒序取最近 N 条 | `List[RecordingRecord]` |
 | `RecordingRepo.list_by_camera` | `(camera_index, limit=50)` | 按摄像机索引筛选 | `List[RecordingRecord]` |
 | `RecordingRepo.delete` | `(record_id)` | 按 id 删除 | 删除并 commit |
+| `RecordingRepo.delete_local_episode` | `(file_path, episode_index=None)` | 本地文件已删净后真删该 episode 的录制行（DELETE，不标状态） | 删除行数 `int` |
+| `RecordingRepo.delete_local_dir` | `(dir_path)` | 真删某录制目录下全部录制行（路径 abspath+normpath 归一化比较） | 删除行数 `int` |
 | `RecordingRepo.mark_uploaded` | `(file_path)` | 按路径把状态改为 `uploaded`（已上传、本地保留） | 受影响行数 `int` |
 | `RecordingRepo.mark_uploaded_deleted` | `(file_path)` | 按路径把状态改为 `uploaded_deleted` | 受影响行数 `int` |
 

collector/docs/data.md

@@ -78,7 +78,7 @@
 | `params` | object | 任务自定义参数（如对象、用手等） |
 | `completed_count` | int | 录制完成次数（持久化权威值，每次录制完成 +1，与本地文件是否被删除无关） |
 | `status` | string | `pending` / `in_progress` / `completed`，每次加载时由 `completed_count` 与 `total_required` 重新推算 |
-| `hidden` | bool | 删除墓碑：用户删除过的任务标 `true`，防止后端再次推送时“复活” |
+| `hidden` | bool | 删除墓碑：用户删除过的任务标 `true`，防止后端再次推送时“复活”（任务页删除同时会真删本地录制目录与录制记录，这里只留墓碑；进度 `local_count` 不回退） |
 
 行为要点（均来自代码）：
 
@@ -89,6 +89,10 @@
   其余标 `hidden`。
 - 旧数据缺少 `completed_count` 时，一次性按 `data/recordings/<name>/` 下含
   `meta/info.json` 的会话目录数回填初值并写回，此后以持久化值为准。
+- 任务页「🗑 删除」= 真删除：先按 `<RECORDING_DIR>/<task_tag>/` 校验删净
+  （删不掉则弹窗报错且任务不隐藏），再删除该目录下的录制记录行，最后只在本
+  文件写 `hidden` 墓碑。`completed_count` 等进度计数按「持久化权威值」处理，
+  不随删除回退。
 
 ### 2.4 `device_params.json`
 
@@ -326,7 +330,9 @@ data/recordings/                          # 录制根目录（settings.RECORDING
 - ⚠ 分界是**发布版本**，不是日历日：v1.3.13（2026-09-28）起才是新帧；
   此前的版本**不写** `frame` 键 —— 所以旧 episode 里这两个键**不存在**，
   「键不在」就等于旧帧，不要当成"缺省 = 新帧"。（2026-09-22..09-27 用
-  v1.3.12 录的也在旧帧那侧：没有键。现存数据最新一段录于 2026-09-21 21:01。）
+  v1.3.12 录的也在旧帧那侧：没有键。老数据最新一段录于 2026-09-21 21:01；
+  新帧那边已有 `UMI_9_29`（2026-09-29 录、204 段、`app_version` 1.3.13）——
+  这条线**已经跨过去了**，同一份 `data/recordings` 里两种帧并存。）
 - ⚠ 帧标注是**任务级**的（`meta/info.json` 的 `features` 按并集/后写覆盖合并）：
   一个任务目录若跨了这次改帧，它只能记住最后写入的帧，该任务早期 episode
   会被标错。按 episode 精确区分需要 `meta/episodes` 加列（v1.3.13 未加）——
@@ -365,6 +371,49 @@ mapping, residual_ns = align_episode("episode-000.parquet", side="left")
   的 `hardware_ns` 还被 `pyqtSignal(int)` 截成 32 位（每 2.147 s 翻符号）。
   脚本对这类 episode 明确报「无法对齐」而不是拿行号或增长率去猜。
 
+##### ⚠ 姿态相对化的语义改过一次 —— 新旧数据要分开看
+
+上面说的「姿态相对该帧首帧」有个**乘在哪一侧**的区别，v1.3.14 之前一直是
+左边那一侧：
+
+- **正确（v1.3.14 起）＝右乘 `R · R0ᵀ`**——在世界系里表达的相对姿态
+  （「相对锚点转了多大」）。
+- **改前＝左乘 `R0ᵀ · R`**——在锚点体轴系里表达的相对转动（body delta）。
+  两者数值上只差一个**常数共轭**，所以位置/幅度都「看着正常」，但读端按它解
+  会让**表观旋转轴整体转错**（本机锚点下约等于绕发布帧 −Y 轴转了 90°：绕 X
+  的表观变成绕 Z、绕 Z 的变成反向绕 X，只有绕 Y 正常）。修在 `0ab64d7c`
+  （v1.3.14 那一笔），同一笔把 `process_controller` 里描述该语义的注释同步了。
+
+**`frame` 与 `app_version` 都分不出这两者**：两个构建写的都是
+`frame=down_left_forward`，`__version__` 从 `177ef0ef`（左乘）到 `0ab64d7c`
+（右乘）**一直是 `"1.3.13"`**（版本号在下一笔才抬到 1.3.14）。⇒ **不能按版本
+猜 1.3.13 的数据是哪一种**。
+
+**三类数据要分开**（左乘那段代码换过位置，但乘的侧一直没变 —— 别以为
+「≤1.3.12 是另一条路径所以不受影响」）：
+
+| 数据 | 相对化 | 现况 |
+|---|---|---|
+| **新帧 + v1.3.14 起**（`frame=down_left_forward` 且 `__version__` ≥1.3.14） | 右乘 | 按右乘读，就是现状 |
+| **新帧 + v1.3.13**（`frame=down_left_forward`，`app_version` 1.3.13） | **左乘** | 仓库内只有 `UMI_9_29`，**已回填成右乘**（见下） |
+| **旧帧**（没有 `frame` 键，≤1.3.12） | **也是左乘** | 在 `process_controller._pose_rotation_zero` 里做的（注释原文「全部姿态左乘基准的逆」），v1.3.13 只是把它搬进 `protocol.finish_publish_pose` 而**没有改乘的侧**；**本次没动**，仓库里的旧帧库（`UMIGripper_Action_AI` 153 段等）原样留在左乘 |
+
+⇒ 所以**「仓库内一律按右乘解释」只对新帧那一支成立**。**旧帧数据要不要也按
+右乘重解释，需要单独判定**（左乘的差异是「绕锚点 R0 的常数共轭」，旧帧的 R0
+与轴定义与旧帧文档是配套写的，不能想当然地照新帧的结论搬）——这一条**待办**，
+不要按「旧数据没受影响」理解。
+
+本机新帧那一支是**已经回填好了**：`data/recordings/UMI_9_29`（204 段，
+`app_version` 1.3.13）已于 2026-10-12 按右乘语义整体回填（逐点
+`q_new = A · q_old · A⁻¹`，A = 绕发布帧 −Y 轴 90°，即把左乘值换成右乘值）。
+逐点核验（全部 53272 点）与**逐文件 sha256 前后值**记在
+`data/recordings_rotfix_backup/UMI_9_29_rotfix_20261012/MIGRATION.json`，
+回填前的原值就存在**同一个目录**下（`data/`、`meta/` 两棵子树，204 段都在）；
+逐文件核对：204/204 现场文件 = 记录的 `sha256_after`、204/204 备份 = `sha256_before`。
+
+拿到**仓库之外**的 1.3.13 数据时先按这条确认（`app_version` 不足以判定）。
+`config/settings.py` 与 `config/__init__.py` 的帧注释块有同一提醒。
+
 ### 4.5.2 SLAM 点与视频帧的时间对齐
 
 `slam_trajectory` 每点的第 0 个字段 `t` 是**相机传感器钟**上的时间（native

collector/docs/file_format.md

@@ -63,7 +63,9 @@ fnum  = (N - 1) % 1000      # 三位零起：episode-000 .. episode-999
   写下 `meta/recycled_episode.json` 标记（§7.5），下一次录制优先复用该号
   （即使进度水位已跑在前面也不跳号）；正常完成即清标记。**删除（含上传后
   自动删除）不回退**：已完成的 episode 序号永不复用（服务器已持有该号）。
-  删除即彻底删除（v1.1.2 起无 `_trash/` 回收区）。
+  删除即彻底删除（v1.1.2 起无 `_trash/` 回收区）；2026-10-12 起删完**校验**
+  三处（videos/data/meta 行）确实不在，并真删本地录制记录（`pipeline.db`
+  的 recording 行），删不净如实报错。
 - **旧分片命名残留（读侧 MUST 容忍）**：v1.1.0 早期曾用「每 chunk 一个
   分片」，分片文件名 = chunk 自身编号（chunk-000 → file-000.parquet，
   一个文件装该 chunk 内最多 1000 个 episode 的行）。该布局已废除，新写入
@@ -107,7 +109,7 @@ fnum  = (N - 1) % 1000      # 三位零起：episode-000 .. episode-999
 - **`features["observation.<sn>_slam_trajectory"]` 里的 `frame` / `frame_axes`**：
 
   ```json
-  "observation.gripper_1_slam_trajectory": {
+  "observation.slam_trajectory": {
     "dtype": "float64", "shape": [8],
     "encoding": "flat_points_8_txyz_qxyzw",
     "frame": "down_left_forward",
@@ -115,6 +117,11 @@ fnum  = (N - 1) % 1000      # 三位零起：episode-000 .. episode-999
   }
   ```
 
+  ★键名带**夹爪前缀**：第 1 台夹爪前缀是空串（列就叫 `observation.slam_trajectory`，
+  上面的例子就是它），第 2 台起才是 `observation.gripper_2_slam_trajectory`。
+  读端请按 `observation.*slam_trajectory` 配，别写死带 `gripper_1_` 的名字——
+  那个键在磁盘上**不存在**。
+
   `frame` 是帧 id，`frame_axes` 是各轴在现实中指向哪（中文名只在 GUI 上，不落盘）。
   两个已知 id：
 
@@ -123,8 +130,12 @@ fnum  = (N - 1) % 1000      # 三位零起：episode-000 .. episode-999
   | `down_left_forward` | `{"+X":"down","+Y":"left","+Z":"forward"}` | 新帧，**v1.3.13 起的默认** |
   | `right_forward_up` | `{"+X":"right","+Y":"forward","+Z":"up"}` | 旧帧（`X=右/Y=正对/Z=上`） |
 
-  ★注意旧帧的 `+Y` 是 `forward` 而中文叫「正对」不是「前」：两个帧的 `forward`
-  指的是**不同物理方向**，读端别把两个 id 的 `forward` 当成同一个。
+  ★旧帧的 `+Y` 也叫 `forward`（中文写「正对」不是「前」），而它和新帧 `+Z` 的
+  `forward` **是同一个物理方向** —— M 恰好把中间帧 +Y 映到发布帧 +Z（实测映射：
+  旧+X 右→新−Y **右**、旧+Y 正对→新+Z 前、旧+Z 上→新−X **上**；后两项的方向词
+  读的是**落点那个轴是什么方向**，不是新帧同名字母的含义）。所以：
+  **`forward` 可以跨帧等同，轴字母不行**。旧 `+Y` 与新 `+Y` 差 90°（前者正对、
+  后者左），读端别按轴字母把两个帧对齐，要按 `frame_axes` 里的方向词。
 
 **读侧两条硬规则：**
 
@@ -135,9 +146,20 @@ fnum  = (N - 1) % 1000      # 三位零起：episode-000 .. episode-999
    一个任务目录若跨了这次改帧，`info.json` 只能记住**最后写入**的那个帧，
    该任务早期的 episode 会被标错。要逐 episode 精确区分得往 `meta/episodes`
    加列（v1.3.13 未加）。跨线的任务目录请按录制日期切开。
-
-坐标约定本身（帧的物理含义、`M` 变换、与相机相对化的关系）见本仓库
-`docs/data.md` 的坐标帧一节。
+3. **帧是一回事、姿态相对化是另一回事**：相对化从 ≤1.3.12 起一直是**左乘**
+   `R0ᵀ·R`（锚点体轴系里的 body delta；先在 `process_controller`，v1.3.13 起搬到
+   `protocol.finish_publish_pose`，乘的侧没变），v1.3.14 才改成正确的**右乘**
+   `R·R0ᵀ`。两者只差一个常数共轭（位置/幅度看着都正常，但读端按错的那支解会让
+   **表观旋转轴整体转错**），而 `frame` 与 `app_version` **都分不出**（两个构建
+   都是 `down_left_forward`、`__version__` 都写 `"1.3.13"`）。
+   **新帧**数据已按右乘回填（`data/recordings/UMI_9_29`，逐文件 sha256 记在其
+   rotfix 备份目录的 `MIGRATION.json`）；**旧帧**数据（无 `frame` 键）同样是左乘、
+   本次**没动**，要不要重解释**待判定**。详见 `docs/data.md`。
+
+坐标约定本身（各轴在现实中指向哪、原点与首帧相对化、两套帧 id、回落开关）
+见本仓库 `docs/data.md` 的「SLAM 轨迹的坐标帧」一节。发布侧那张换基矩阵 `M`
+（`core/gripper/slam/protocol.py` 的 `PUBLISH_RELABEL_QUAT` / `PUBLISH_RELABEL_MATRIX`）
+是**实现细节**，`data.md` 里没有、读端也不需要：按 `frame_axes` 解释数值即可。
 
 ## 4. meta/stats.json（任务级全局统计，v1.1.1 契约）
 
@@ -357,8 +379,33 @@ meta/tasks.jsonl                                 # 任务级
 - 导入器以 `info.json.format == "pooled_episodes_v1"` 识别新格式。
 - **HEVC 预压缩**：zip 内 mp4 可能已被再编码为 HEVC（hvc1, CRF30）以缩小体积，
   与 episodes 行 `video_codec`（描述本机原始编码）**不必一致**；mkv 深度永不再编码。
-- 上传删除 = 删该 episode 文件组（videos/data 各 key 本 episode 文件），
-  episodes 行、stats、total_episodes **不回退**。
+- 上传删除 = 删该 episode 文件组（videos/data 各 key 本 episode 文件 + 本段
+  episodes 行文件），删完**校验三处都真的没了**（`pooled_episode_leftovers`），
+  没删净如实报错；stats、total_episodes **不回退**（total_episodes 由下次录制
+  按 `list_task_episodes` 重算），episode 序号永不复用。
+- **删除入口的编号口径**：`delete_pooled_episode`/`delete_local_session` 收的是
+  全局号 **N（1 基）**，和上传器（`episode_chunk_file(N)`）、`UploadManager` 的
+  `(path, episode_index)` 防重键同一口径。文件名里的 `f` 是 **chunk 内 0 基**
+  文件号，**跨 chunk 后 `f + 1` 不再是 N**：chunk-000 满 1000 段就开 chunk-001
+  并从 `episode-000` 重新计数，所以
+
+  ```
+  N = c * 1000 + f + 1        （c = chunk 号，1000 = POOLED_CHUNK_SIZE）
+  ```
+
+  **统一由 `core.helpers.list_task_episodes(task_dir)` 还原**（它按
+  `chunk*POOLED_CHUNK_SIZE + int(f) + 1` 产出全局号，是权威枚举器），不要自己
+  拿文件名拼 N。少 +1 删错段；多 +1 会指向不存在的 N+1（此时「没找到任何文件」
+  被幂等判为已删净而返回 True，界面报成功、文件一个没动）。
+  **f 回绕尤其危险**：chunk-001 出现后再取「最大文件名 f + 1」，得到的是
+  chunk-000 里**真实存在**的前一段（f=0 → N=1），于是静默上传/删除到错的段。
+  lite 的取号口径历史上错过两次：先是**少 +1**（返回 0 基文件号 f 当 N 用），
+  改成 `max(f) + 1` 后又在跨 chunk 时**回绕**；两处都已修成走
+  `list_task_episodes`（`tools/tests/lite_delete_test.py` 第 1/4/6 节分别钉
+  「ep 是全局 N」「单段目录 ep=1 不是 0」「跨 chunk 的 ep=1001 不是 1」）。
+  `_delete_after_upload` 本身一直是原样透传（没有 +1 可去），变的一直是它上游
+  的取号口径。旧格式（`data/` 下没有任何 `chunk-*/episode-*.parquet`）按整目录
+  处理，取号返回 0。
 
 ## 10. 关键点镜像布局（keypoints_output/）
 

collector/docs/tools.md

@@ -422,7 +422,7 @@ venv/bin/python tools/audit_frame_gaps.py [任务目录] [选项]   # 默认 dat
 
 ## tests/ 测试
 
-测试脚本见 `tools/tests/`（当前 73 份；离线测试加 `QT_QPA_PLATFORM=offscreen` 无需任何硬件，真机测试需对应设备在线）。完整运行命令见 `README.md` 测试节。**下表只列了一部分**（早期 16 份 + 帧空洞相关的 5 份 + 夹爪配对/离线入口 + 位姿坐标帧的 5 份），其余按需现查文件名。
+测试脚本见 `tools/tests/`（当前 79 份；离线测试加 `QT_QPA_PLATFORM=offscreen` 无需任何硬件，真机测试需对应设备在线）。完整运行命令见 `README.md` 测试节。**下表只列了一部分**（早期 16 份 + 帧空洞相关的 5 份 + 夹爪配对/离线入口 + 位姿坐标帧的 5 份 + 删除真删除的 3 份 + 发布死区/跳变门的 3 份），其余按需现查文件名。
 
 | 文件 | 类型 | 一句话 |
 | --- | --- | --- |
@@ -436,6 +436,7 @@ venv/bin/python tools/audit_frame_gaps.py [任务目录] [选项]   # 默认 dat
 | `glove_widget_test.py` | 离线 | 手套控件配置路由 |
 | `grid_drag_fps_test.py` | 离线 | 网格拖拽/分割条 |
 | `device_panel_gui_smoke_test.py` | 离线 | 设备面板 GUI 冒烟 |
+| `device_dock_collapse_test.py` | 离线 | 设备检测栏 缩小/隐藏（栏宽地板回归哨兵 + ×/菜单收起 + 偏好持久化） |
 | `test_device_detector.py` | 离线 | 设备枚举 |
 | `d405_worker_test.py` | 真机 | D405 采集 worker |
 | `d435_e2e_test.py` | 真机 | D435 端到端 |
@@ -454,3 +455,9 @@ venv/bin/python tools/audit_frame_gaps.py [任务目录] [选项]   # 默认 dat
 | `test_gripper_slam_columns.py` | 离线 | SLAM 落盘列契约：**只落 `slam_trajectory`、不再落 `slam_pose`**（后者是被 26.5% 填零的定长 `[0]*7`，下游会把零当真实位姿） |
 | `test_gripper_latest_pose_frame.py` | 离线 | 原生帧 → 发布帧的实际差值就是那张 M（位置 `M·Rz(+90°)`、姿态还多一层体轴改名 `Mᵀ`），拿真数据比对而不是复述公式 |
 | `test_pose_view_qt.py` | 离线 | 位姿视图：轨迹常驻、世界轴与**跟随夹爪的三箭头**重合且标签带方向词、三箭头取**列**（体轴）不取行、夹爪模型换基后逐像素不变、主窗口那次四元数→矩阵转换把帧带上 |
+| `test_pose_publish_deadband.py` | 离线 | 发布死区语义：AR(1) 静止游走被冻结（>95% 帧保持、且保持的是上次的值）、慢速移动照常推进且误差不超死区、真实会话回放（`logs/` 不入库时会 SKIP，别把 SKIP 读成 PASS） |
+| `test_gripper_pose_deadband_publish.py` | 离线 | 死区真接在**发布出口**（`_publish_pose`）：静止发旧值、节拍/序号/丢失计数不变、每个发布值都是某帧原始值的发布帧像（替换而非插值/平均）、重锚丢参照、开机日志有那行可验收 |
+| `test_pose_guard_limits.py` | 离线 | 跳变门夹在实测包络中间（真实单步 ≤0.0601m 放行 / 异常 ≥0.1075m 拦下）、限值不再随 20/20/60ms 抽帧膨胀、native `kPose*` 与 Python 常量逐字一致 |
+| `test_local_delete.py` | 离线 | 删除即真删除：池化一段的三处文件（data/视频/meta）都清掉且不牵连邻居、删不掉时 `False` + 残留清单 + 中文报错而不是假装删掉、旧格式会话目录 rmtree 复检、录制行真删（含尾斜杠归一化、空路径 0 行） |
+| `test_task_delete.py` | 离线 | 任务页「🗑 删除」= 真删目录 + 真删录制行 + 只留 `hidden` 墓碑（确认框写明目录与片段数）；目录删不掉时**不隐藏任务**并弹窗报错 |
+| `lite_delete_test.py` | 离线 | lite 上传后删除的编号回归：列表 ep 与删除入参都必须是**全局号 N**（`_episode_max` 要把文件号 +1；`_delete_after_upload` 不许再加工——多 +1 会指向不存在的 N+1，残留复检空集 → 报成功却一个文件没删）、单段目录只删该段不 rmtree、无 parquet 的旧目录整目录删 |

collector/docs/ui.md

@@ -34,7 +34,7 @@
 
 ### ui/main_window.py
 
-**作用**：应用程序主窗口，界面层中枢。组合页面栈（任务选择页 + 数据采集页）、`CameraGrid` 主网格、左侧 `DevicePanel` 设备面板、底部日志 dock、右侧录制历史 dock、工具栏与菜单；启动时经 `_show_login_flow` 弹 `LoginDialog` 确定账号/游客身份，首次启动经 `_show_guide` 弹 `GuideDialog` 使用说明；持有 `CameraPipeline`、`DeviceScanner`、`TaskService`、`UploadManager` 与 `core.device_manager.DeviceManager` 注册表（`_workers` 为其 `entries` 别名）等核心对象并负责信号接线。所有设备的开启/关闭都经左侧面板开关按 `core.device_manager.dispatch_toggle` 分派到 `_open_*`/`_close_*` 系列方法：S80M 双目子进程 + 管道解析在 `core.s80m_manager.S80MDeviceManager`，D435 worker 生命周期与帧口径在 `core.d435_manager.D435DeviceManager`，手套以 BLE 引擎 + 渲染定时器运行。
+**作用**：应用程序主窗口，界面层中枢。组合页面栈（任务选择页 + 数据采集页）、`CameraGrid` 主网格、左侧 `DevicePanel` 设备面板（`_device_dock`：可拖宽/拖窄，带 Closable 故标题栏有 × 可收起；宽度与收起状态经 `server_config.json` 的 `device_dock` 段跨启动保持，恢复入口为「视图 ▸ 设备检测栏」/ Ctrl+D）、底部日志 dock、右侧录制历史 dock、工具栏与菜单；启动时经 `_show_login_flow` 弹 `LoginDialog` 确定账号/游客身份，首次启动经 `_show_guide` 弹 `GuideDialog` 使用说明；持有 `CameraPipeline`、`DeviceScanner`、`TaskService`、`UploadManager` 与 `core.device_manager.DeviceManager` 注册表（`_workers` 为其 `entries` 别名）等核心对象并负责信号接线。所有设备的开启/关闭都经左侧面板开关按 `core.device_manager.dispatch_toggle` 分派到 `_open_*`/`_close_*` 系列方法：S80M 双目子进程 + 管道解析在 `core.s80m_manager.S80MDeviceManager`，D435 worker 生命周期与帧口径在 `core.d435_manager.D435DeviceManager`，手套以 BLE 引擎 + 渲染定时器运行。
 
 **模块级辅助与常量**（v1.0.3 后多为 core 模块的兼容 re-export，离线测试直接 patch 这些名字）：
 
@@ -129,8 +129,8 @@
 | `_open_playback` | `()` | 「📂 回放」：`PlaybackDialog(self, settings.RECORDING_DIR)` 模态打开 | — |
 | `_open_upload` | `()` | 「☁ 上传」：`UploadDialog(self, settings.RECORDING_DIR, session=TaskService._session)` 模态打开 | — |
 | `_on_upload_task_done` | `(task_id)` | 自动上传完成：记日志；`UPLOAD_DELETE_AFTER` 开启时后台线程删本地目录，否则 `RecordingRepo.mark_uploaded` 标「已上传（本地保留）」并刷新历史 | — |
-| `_delete_session_after_upload` | `(session_path)` | 后台线程 `shutil.rmtree`（防大目录阻塞 UI），结果经 `_upload_session_deleted` 回主线程 | — |
-| `_on_upload_session_deleted` | `(session_path, err)` | 删除收尾：失败记日志；成功 `RecordingRepo.mark_uploaded_deleted` 保留历史行（状态「已上传，本地已删」）并刷新 | — |
+| `_delete_session_after_upload` | `(session_path, episode_index=0)` | 后台线程 `delete_local_session`（真删除 + 删除后校验，防大目录阻塞 UI），结果经 `_upload_session_deleted` 回主线程 | — |
+| `_on_upload_session_deleted` | `(session_path, err)` | 删除收尾：失败（含校验残留）记日志；成功 `RecordingRepo.delete_local_episode` 真删录制行并刷新 | — |
 | `_on_upload_task_failed` | `(task_id, error)` | 自动上传失败（重试 3 次后仍失败才触发）→ 日志 | — |
 | `_on_upload_auto_toggled` / `_on_upload_delete_toggled` | `(on)` | 两个工具栏开关：`settings.save_upload_auto_sync` / `save_upload_delete_after` 持久化 + 运行时立即生效 + 按钮文字/样式刷新 | — |
 | `_style_toolbar_toggle` | `(action)` | 开关类 QAction 按钮高亮样式（开启绿底白字加粗） | — |
@@ -144,7 +144,7 @@
 | `_on_switch_account` | `()` | 任务页「切换账号」按钮 → 重开登录对话框 | — |
 | `_on_identity_expired` | `()` | 登录态轮询遇 401/403 → 提示重登；关闭对话框（Esc）自动降级游客 | — |
 | `_on_task_confirmed` | `(task)` | 选中任务进入采集页（index 1），更新窗口标题；不自动扫描，提示先选模式再点扫描 | — |
-| `_on_page_changed` | `(index)` | 页面切换控制工具栏/dock 可见性；任务页停设备轮询，采集页立即扫描 + 启动 `_device_timer`（2s 轮询） | — |
+| `_on_page_changed` | `(index)` | 页面切换控制工具栏/dock 可见性；任务页停设备轮询，采集页立即扫描 + 启动 `_device_timer`（2s 轮询）；末尾统一调 `_apply_device_dock_visibility`（设备栏：任务页隐藏、采集页显示，但用户收起过就保持收起） | — |
 | `_go_back_to_task_selection` | `()` | 返回任务选择：录制中先确认（同意则 abort）；取消手部后处理/标注；`_teardown_all_workers` + 清网格 + 清面板状态；切回 index 0 并 `poll_now()` 刷新任务列表 | — |
 
 **其余（语言/视图/手部后处理/日志/退出）**：
@@ -153,6 +153,12 @@
 | --- | --- | --- | --- |
 | `_on_language_changed` | `(lang)` | 中英文切换：菜单/工具栏/dock 标题/历史表头/手部模式下拉全部 `tr()` 重刷，并调 `_task_page._on_language_changed` | — |
 | `_reset_camera_sizes` | `()` | 视图菜单「重置画面大小」：`grid._rebuild_layout()` 等分 | — |
+| `_apply_device_dock_visibility` | `()` | 设备栏可见性的唯一口径：`当前页==1 且 用户未收起` → `setVisible` + `resizeDocks` 复原宽度；期间置 `_device_dock_syncing` 挡「程序化改动被当成用户收起」 | 末尾同步菜单勾选 |
+| `_toggle_device_dock` | `(checked)` | 视图菜单「设备检测栏」/ Ctrl+D：置 `_device_dock_user_hidden` → 应用可见性 → 落盘 | 任务页只记偏好不显示 |
+| `_on_device_dock_visibility` | `(visible)` | 设备栏可见性变化（标题栏 × 收起）：`_device_dock_syncing` 置位或不在采集页时直接返回；否则记用户收起 + 同步菜单 + 落盘 | — |
+| `_sync_device_dock_action` | `()` | 菜单勾选 = 用户是否想看设备栏（与当前页是否显示无关；`blockSignals` 防递归） | — |
+| `_save_device_dock_prefs` | `()` | `settings.save_device_dock_prefs(未收起, 栏宽)`；宽度由 `eventFilter`(Resize) 持续跟随 | closeEvent 也调一次 |
+| `eventFilter` | `(obj, event)` | 仅拦 `_device_dock` 的 `QEvent.Resize` → 记 `_device_dock_width`（拖窄/拖宽后收起或退出时才能落盘正确宽度） | 其余事件走 `super()` |
 | `_update_status` | `()` | 状态栏：摄像机数（排除 `sensor:`/`ble:` 占位槽）+ 录制中标记与颜色 | — |
 | `_process_hand_keypoints` | `(session_path="", silent=False)` | 后台提取手部关键点（`SessionHandProcessor.process_session`，mode 由手套/裸手下拉决定）；已有结果时弹确认（silent 模式跳过）；无路径用最近一条录制 | — |
 | `_on_hand_proc_progress` / `_on_hand_proc_finished` | `(current, total)` / `(session_path, error)` | 进度 → 状态栏+按钮；完成后 300ms 自动触发 `_auto_label`（silent） | — |
@@ -270,6 +276,7 @@
 
 - `_ICON = {"uvc": "📹", "d435": "🔭", "s80m": "👁", "data_ble": "🧤", "usb_glove": "🧤", "ble": "🎧", "gripper": "🤖"}`；`_GROUP_ORDER = ["camera", "glove", "gripper", "other_ble"]`；`_GROUP_TITLE` 对应中文组标题。
 - `_items`：device key → `QTreeWidgetItem`；`_last_check`：key → 上次勾选状态（防 `itemChanged` 误触发）；`_group_expanded`：组展开状态（初始 camera/glove 展开、other_ble 折叠）；`_has_gripper`：列表里是否有夹爪（决定底部提示是否提右键入口，两个分支都要更新，空设备分支需重置）。
+- ⚠️ 面板内**所有 QLabel 提示都必须 `setWordWrap(True)`**：不换行的 QLabel，其 `minimumSizeHint().width()` 就是整行文字宽，会成为面板与停靠栏的硬地板。底部提示那句中文（「双击设备可重命名；右键夹爪可重读标定 / 配对序列号 / 串口诊断」）曾在夹爪在场时把栏宽地板顶到 289px，导致设备栏**只能拖宽、拖不窄**（2026-10-13 修）；面板另设 `setMinimumWidth(settings.DEVICE_DOCK_MIN_WIDTH)` 作为可拖到的最窄。回归哨兵见 `tools/tests/device_dock_collapse_test.py`。
 - 命名持久化：`config.settings.save_device_name`（device_names.json）。
 
 **调用关系**：由 `ui/main_window.py` 构造并连接 `device_toggled`/`device_renamed`/`gripper_recalibration_requested`/`gripper_binding_requested`/`gripper_diagnostics_requested`（信号名按字符串 connect，写错不会报错、只是永远不触发 —— `tools/tests/test_gripper_esp_binding.py` §9 静态比对两处名字）；`tools/tests/device_panel_gui_smoke_test.py` 直接构造。依赖 `config.settings.save_device_name`、`config.i18n.tr`。夹爪右键三条链路的完整链路（关夹爪 → 后台线程 → 完成后按原样开回）见 `docs/core.md`「夹爪」节与 `ui/main_window.py` 的 `_on_gripper_recalibration` / `_on_gripper_binding` / `_on_gripper_diagnostics`；三条共用 `_gripper_offline_guard`（序列号+录制检查）、`_gripper_offline_take_over`（让出串口）、`_reopen_after_offline`（善后）三件骨架。
@@ -423,7 +430,7 @@
 **★ 坐标帧契约（v1.3.13）**：发布侧 `core/gripper/slam/protocol.py` 给位姿做了两次左乘 + 一次右乘（右乘 = **体轴改名**），本控件是那个契约的另一半：
 
 - `_draw_frame_axes` 画的是 `rotation` 的**三列**（= 夹爪体轴），不是三行。同一张 `M` 也在发布侧给体轴改了名，所以重新锚定那一瞬发布姿态 = `M·Mᵀ` = 单位矩阵，**跟随夹爪的三箭头与世界三箭头重合**，标签同写 下/左/前。
-- `_draw_gripper` 用 `_BODY_RELABEL`（与发布侧同一张 `M`）把模型顶点从旧体轴坐标搬到新体轴坐标，于是 `position + R·(M��v) == position + R_旧·v`，**夹爪的物理朝向与画面逐像素与改前相同**。
+- `_draw_gripper` 用 `_BODY_RELABEL`（与发布侧同一张 `M`）把模型顶点从旧体轴坐标搬到新体轴坐标，于是 `position + R·(M·v) == position + R_旧·v`，**夹爪的物理朝向与画面逐像素与改前相同**（该恒等式对任意 `R`、`v` 代数上精确成立 —— `M·R·Mᵀ·M·v = M·R·v`，因为 `MᵀM = I`；渲染侧由 `test_pose_view_qt.py::check_gripper_model_frame_invariant` 逐像素钉住）。★式中的 `R_旧` 是**改前那次发布的姿态**（已含发布侧左乘的 `M`），不是夹爪自己的相对姿态 `R_rel` —— 拿 `R_rel` 代进去会差一个 `M`，算出"夹爪歪了 0.3–0.4 m"的假警报；对照：两处都改时残差只在浮点噪声量级，只改一半就是 0.3–0.4 m 的实偏差。
 - 后果：**只改发布侧不改这里（或反过来）夹爪会被画歪 120°**，而两种改法各自都"看起来自洽"——别只动一处。测试见 `tools/tests/test_pose_view_qt.py`。
 - 三箭头的轴名来自 `config.settings.GRIPPER_SLAM_FRAME_AXES_CN`，**不自己抄**（屏幕上的字与落进 `info.json` 的 `frame_axes` 必须同源）。
 
@@ -464,7 +471,7 @@
 | `current_task` | `() -> dict \| None` | 当前选中行任务 | dict 或 None |
 | `_on_cell_changed` | `(row, _col, _pr, _pc)` | 选行联动：completed 任务禁用「进入采集」（tooltip 提示换任务） | — |
 | `_on_double_clicked` / `_on_enter_clicked` | `()` | 双击行=快捷进入；进入前 completed 任务弹警告 | 发射 `task_selected` |
-| `_do_delete_task` | `()` | 删除任务（按钮与右键菜单共用）：确认后 `mark_hidden`（可在 tasks.json 中恢复）→ 重载列表 | — |
+| `_do_delete_task` | `()` | 删除任务（按钮与右键菜单共用）：二次确认后 `delete_local_session` 真删该任务录制目录 + `RecordingRepo.delete_local_dir` 删录制行，再 `mark_hidden` 留墓碑 → 重载列表；目录没删净则弹错并**不隐藏**任务。删除目标先做兜底校验（必须是 `RECORDING_DIR` 的**直接子目录**）——`_sanitize_tag` 把纯空白任务名清洗成空串后 `task_dir_of` 会退化成 `RECORDING_DIR` 本身，不拦就会把**所有任务**的录制整根 rmtree | — |
 | `_on_context_menu` | `(pos)` | 右键菜单「🗑 删除任务」 | — |
 | `_on_refresh_clicked` | `()` | 发射 `refresh_requested`，按钮 1.5s 内显示「刷新中…」禁用 | — |
 | `_on_language_changed` | `(lang)` | 表头/占位符/按钮文字刷新并重建表 | — |
@@ -501,8 +508,8 @@
 | `_on_status` | `(task_id, msg)` | 串行处理时状态栏显示「第 x/y 条 [会话名] 当前动作」 | — |
 | `_on_progress` | `(task_id, ratio)` | 总进度 =（已完成数 + 当前比例）/ 总数 | 进度条 |
 | `_on_task_done` | `(task_id)` | 单条完成：刷新列表；`UPLOAD_DELETE_AFTER` 开启时 `_delete_after_upload`（与主窗口自动上传同规则），否则 `RecordingRepo.mark_uploaded` + 主窗口日志「☁ 上传完成（本地保留）」 | — |
-| `_delete_after_upload` | `(session_path)` | 后台线程 `shutil.rmtree`，结果经 `_session_deleted` 回主线程 | — |
-| `_on_session_deleted` | `(session_path, err)` | 删除收尾：失败仅提示；成功 `RecordingRepo.mark_uploaded_deleted` + 刷新列表 + 主窗口日志「☁ 上传完成，本地文件已删除」 | — |
+| `_delete_after_upload` | `(session_path, episode_index)` | 后台线程 `delete_local_session`（真删除 + 删除后校验），结果经 `_session_deleted` 回主线程 | — |
+| `_on_session_deleted` | `(session_path, err)` | 删除收尾：失败仅提示（含校验残留）；成功 `RecordingRepo.delete_local_episode` 真删录制行 + 刷新列表 + 主窗口日志「☁ 上传完成，本地文件已删除」 | — |
 | `_on_task_failed` / `_on_all_done` | `(task_id, error)` / `()` | 失败：状态栏「❌ 上传失败」+ 主窗口日志 + 刷新列表 / 全部完成：恢复按钮、进度条 100、状态「全部完成」 | — |
 | `closeEvent` | `(event)` | 停止 `_manager` | — |
 

collector/tools/tests/device_dock_collapse_test.py

@@ -0,0 +1,217 @@
+"""设备检测栏（左侧停靠面板）缩小 / 隐藏回归测试（offscreen）。
+
+用法:
+    QT_QPA_PLATFORM=offscreen venv/bin/python tools/tests/device_dock_collapse_test.py
+
+背景（2026-10-13 的 bug）:
+  面板底部提示「双击设备可重命名；右键夹爪可重读标定 / 配对序列号 / 串口诊断」
+  是不换行的 QLabel，minimumSizeHint 就是整行文字宽（中文 + 夹爪在场时 289px），
+  成了停靠栏的硬地板 —— 栏只能越拖越宽、拖不小；且 dock 无 Closable，没有任何
+  隐藏入口。本测试是这两条的回归哨兵。
+
+覆盖:
+  1. 中文 + 夹爪：面板最小宽度远小于旧地板（<=150），且栏能真的拖到 DEVICE_DOCK_MIN_WIDTH
+  2. dock 带 Closable（标题栏 × = 收起）
+  3. 标题栏 × 收起 → 菜单勾选同步 + 偏好落盘
+  4. 收起后切页（任务页 ↔ 采集页）不弹回
+  5. 视图▸设备检测栏 / Ctrl+D 能收起也能恢复
+  6. 宽度与收起状态持久化 → 新窗口按偏好恢复
+  7. 中英文切换刷新菜单项文字
+"""
+import os
+import sys
+import tempfile
+import time
+from unittest.mock import patch
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))))
+os.environ.setdefault("QT_QPA_PLATFORM", "offscreen")
+
+from PyQt5.QtCore import Qt
+from PyQt5.QtWidgets import QApplication, QDockWidget
+
+from config import settings
+from config.i18n import lang_manager, tr
+from core.device_detector import DeviceInfo
+from ui.main_window import MainWindow
+
+FAILS = []
+
+
+def check(cond, msg):
+    if cond:
+        print(f"  PASS: {msg}")
+    else:
+        print(f"  FAIL: {msg}")
+        FAILS.append(msg)
+
+
+def wait(app, ms):
+    t_end = time.time() + ms / 1000.0
+    while time.time() < t_end:
+        app.processEvents()
+        time.sleep(0.01)
+
+
+FAKE_GRIPPER = DeviceInfo(key="gripper:/dev/ttyACM9", kind="gripper",
+                          display_name="UMI 夹爪 (fake)", serial="Fays-0001")
+FAKE_UVC = DeviceInfo(key="uvc:usb-FakeCam_12345678", kind="uvc",
+                      display_name="FakeCam", serial="12345678",
+                      video_index=40)
+FAKE_GLOVE = DeviceInfo(key="ble:AA:11:22:33:44:55", kind="data_ble",
+                        display_name="Matrix Glove R", serial="AA:11:22:33:44:55",
+                        address="AA:11:22:33:44:55")
+FAKES = [FAKE_GRIPPER, FAKE_UVC, FAKE_GLOVE]
+
+
+def make_window(app):
+    """建窗口并停在采集页（设备栏可见）。调用方负责 close()。"""
+    with patch("core.device_detector.detect_devices", return_value=FAKES):
+        win = MainWindow()
+        win.show()
+        win._page_stack.setCurrentIndex(1)
+        wait(app, 200)
+        win._on_devices_scanned(FAKES)
+    win._device_timer.stop()
+    return win
+
+
+def main():
+    app = QApplication(sys.argv)
+    lang_manager.set_language("zh")
+
+    # 偏好全程指向临时文件（隔离真实 server_config.json）
+    tmp = tempfile.NamedTemporaryFile(suffix=".json", delete=False)
+    tmp_path = tmp.name
+    tmp.close()
+    _orig = settings.SERVER_CONFIG_FILE
+    settings.SERVER_CONFIG_FILE = tmp_path
+    try:
+        return _main(app)
+    finally:
+        settings.SERVER_CONFIG_FILE = _orig
+        for p in (tmp_path,):
+            try:
+                os.unlink(p)
+            except OSError:
+                pass
+
+
+def _main(app):
+    print("── 1. 中文 + 夹爪：面板不再有宽地板，栏能拖到最窄 ──")
+    win = make_window(app)
+    min_w = settings.DEVICE_DOCK_MIN_WIDTH
+    panel_min = win._device_panel.minimumSizeHint().width()
+    check(panel_min <= 150,
+          f"面板最小宽度 {panel_min}px（旧 bug 是 289px，单行提示顶宽）")
+    check(win._device_panel._refresh_hint.wordWrap()
+          and tr("双击设备可重命名") in win._device_panel._refresh_hint.text(),
+          "底部提示是换行的那句（不再吃整行宽度当最小宽度）")
+    win.resizeDocks([win._device_dock], [min_w], Qt.Horizontal)
+    app.processEvents()
+    actual = win._device_dock.width()
+    check(abs(actual - min_w) <= 8,
+          f"拖到最窄 {min_w}px → 实际 {actual}px（能缩小了）")
+    win.resizeDocks([win._device_dock], [320], Qt.Horizontal)
+    app.processEvents()
+    check(win._device_dock.width() >= 300,
+          f"拖宽到 320px → 实际 {win._device_dock.width()}px（能放大）")
+
+    print("── 2. dock 带 Closable（标题栏有 × = 隐藏入口） ──")
+    feats = win._device_dock.features()
+    check(bool(feats & QDockWidget.DockWidgetClosable), "features 含 Closable")
+    check(bool(feats & QDockWidget.DockWidgetMovable)
+          and bool(feats & QDockWidget.DockWidgetFloatable),
+          "Movable/Floatable 未被改动")
+
+    print("── 3. 标题栏 × 收起 → 菜单勾选同步 + 偏好落盘 ──")
+    win._device_dock.close()          # × 按钮走的就是 close()
+    wait(app, 100)
+    check(not win._device_dock.isVisible(), "× 收起后设备栏不可见")
+    check(win._device_dock_user_hidden, "收起被记为用户意图")
+    check(not win._device_dock_action.isChecked(), "菜单勾选同步为未选中")
+    check(settings.load_device_dock_prefs()["visible"] is False,
+          "收起状态已落盘")
+
+    print("── 4. 收起后切页不弹回 ──")
+    win._page_stack.setCurrentIndex(0)
+    wait(app, 100)
+    win._page_stack.setCurrentIndex(1)
+    wait(app, 100)
+    check(not win._device_dock.isVisible(),
+          "任务页→采集页往返后仍是收起（不被页面逻辑弹回）")
+    win._page_stack.setCurrentIndex(0)
+    wait(app, 100)
+    check(not win._device_dock.isVisible(), "任务选择页本来就不显示")
+
+    print("── 5. 视图▸设备检测栏 / Ctrl+D：能收起也能恢复 ──")
+    win._device_dock_action.trigger()          # 恢复显示（任务页上点）
+    wait(app, 100)
+    check(not win._device_dock.isVisible(),
+          "任务页点显示：只记偏好，不把栏拉到任务页上")
+    check(win._device_dock_action.isChecked()
+          and not win._device_dock_user_hidden, "偏好已置为「显示」")
+    win._page_stack.setCurrentIndex(1)
+    wait(app, 150)
+    check(win._device_dock.isVisible(), "回采集页后按偏好显示出来")
+    win._device_dock_action.trigger()          # 再收起
+    wait(app, 100)
+    check(not win._device_dock.isVisible(), "菜单收起生效")
+    check(win._device_dock_action.shortcut().toString() == "Ctrl+D",
+          f"快捷键: {win._device_dock_action.shortcut().toString()}")
+    win._device_dock_action.trigger()          # 恢复
+    wait(app, 100)
+    check(win._device_dock.isVisible(), "菜单恢复生效")
+
+    print("── 6. 宽度/收起状态持久化 → 新窗口按偏好恢复 ──")
+    win.resizeDocks([win._device_dock], [min_w], Qt.Horizontal)
+    app.processEvents()
+    saved_w = win._device_dock.width()
+    win._save_device_dock_prefs()
+    prefs = settings.load_device_dock_prefs()
+    check(prefs["width"] == saved_w,
+          f"宽度落盘: 存 {prefs['width']}px（实际 {saved_w}px）")
+    check(prefs["visible"] is True, "可见偏好落盘")
+    win.close()
+    wait(app, 200)
+
+    # 新窗口：应恢复刚存的窄宽度（首启即窄，不用再拖一次）
+    win2 = make_window(app)
+    restored = win2._device_dock.width()
+    check(abs(restored - saved_w) <= 8,
+          f"重启恢复栏宽: {restored}px（存 {saved_w}px）")
+    # 存成「收起」→ 新窗口首启就是收起
+    win2._device_dock.close()
+    wait(app, 100)
+    win2.close()
+    wait(app, 200)
+    win3 = make_window(app)
+    check(not win3._device_dock.isVisible(),
+          "上次收起 → 新窗口首启保持收起（采集页也不弹回来）")
+    check(not win3._device_dock_action.isChecked(), "菜单勾选与之一致")
+    win3._device_dock_action.trigger()          # 恢复，别把状态留给下个测试
+    wait(app, 100)
+    check(win3._device_dock.isVisible(), "恢复显示")
+
+    print("── 7. 中英文切换刷新菜单项 ──")
+    lang_manager.set_language("en")
+    wait(app, 100)
+    check(win3._device_dock_action.text() == "Device Panel",
+          f"英文菜单项: {win3._device_dock_action.text()}")
+    lang_manager.set_language("zh")
+    wait(app, 100)
+    check(win3._device_dock_action.text() == "设备检测栏",
+          f"中文菜单项: {win3._device_dock_action.text()}")
+    win3.close()
+    wait(app, 200)
+
+    print()
+    if FAILS:
+        print(f"FAIL: {len(FAILS)} 项未通过")
+        return 1
+    print("PASS: 设备检测栏 缩小/隐藏 回归测试全部通过")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

collector/tools/tests/lite_delete_test.py

@@ -0,0 +1,172 @@
+"""极简版「上传后删除」编号回归测试（无硬件，离屏 Qt）。
+
+回归点（2026-10-12 改真删除时发现，对抗性审查复现）：
+  lite 的 `_delete_after_upload` 收的必须是**全局 episode 号 N（1 基）**——
+  上传器按 N 取文件（`episode_chunk_file(N)` → 文件号 N-1）、`UploadManager`
+  按 (path, N) 记账，自动上传路径传进来的 `pipeline.last_episode_index` 也是 N。
+  这里多 +1（或 `_episode_max` 少 +1）都会指向另一段：轻则「上传的那段没删、
+  删了一段没上传过的」，重则目标段本就不存在 → `delete_pooled_episode` 的残留
+  复检空集 → 返回 True → 界面报「已删除」而文件一个没动。
+
+本测试造 3 段池化数据（文件号 0/1/2 = N 1/2/3）：
+  - `_episode_max` 返回 N=3（不是文件号 2）；
+  - `_on_upload_done` 原样把 N 透传给 `_delete_after_upload`（不 +1）；
+  - 按 N=3 删掉的是文件号 002 那一组（数据 + 视频 + meta 行），N=1/2 原样在；
+  - 单段目录删的是那一段本身，不整目录 rmtree；
+  - 无 parquet 的旧格式目录按整目录删；
+  - 跨 chunk（chunk-000 满 1000 段后开 chunk-001 并从 episode-000 重新计数）：
+    `episode_max` 必须按 `chunk*1000 + f + 1` 还原成真值 N=1001，**不能**取
+    「最大文件名 f + 1」—— f 会回绕，那个值指向 chunk-000 里**真实存在**的前
+    一段，于是上传/删除静默操作到错的段。
+
+用法:
+    QT_QPA_PLATFORM=offscreen venv/bin/python tools/tests/lite_delete_test.py
+"""
+import os
+import shutil
+import sys
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.dirname(
+    os.path.abspath(__file__)))))
+os.environ.setdefault("QT_QPA_PLATFORM", "offscreen")
+
+from PyQt5.QtWidgets import QApplication
+
+import main_lite  # noqa: F401 — 生产入口，先 import 再构造窗口
+from config import settings
+from core.egodata_writer import _atomic_write_parquet, _episode_rows_table
+from core.helpers import (POOLED_CHUNK_SIZE, list_task_episodes,
+                          pooled_data_parquet_path, pooled_episodes_path)
+from core.pipeline import CameraPipeline
+from ui.lite_window import LiteWindow
+
+ROOT = "/tmp/lite_delete_test"
+FAILS = []
+
+
+def check(cond, msg):
+    print(f"  {'PASS' if cond else 'FAIL'}: {msg}")
+    if not cond:
+        FAILS.append(msg)
+
+
+def make_episode(task_dir: str, file_no: int, chunk: int = 0):
+    """造一段池化数据：chunk 内文件号 file_no。
+
+    全局号 N = chunk * 1000 + file_no + 1 —— 每 chunk 1000 段，chunk-000 满
+    1000 段后开 chunk-001 并从 episode-000 重新计数。
+    """
+    n = chunk * POOLED_CHUNK_SIZE + file_no + 1
+    cdir = f"chunk-{chunk:03d}"
+    d = os.path.join(task_dir, "data", cdir)
+    os.makedirs(d, exist_ok=True)
+    with open(os.path.join(d, f"episode-{file_no:03d}.parquet"), "wb") as f:
+        f.write(b"data")
+    v = os.path.join(task_dir, "videos", cdir, "uvc_rgb")
+    os.makedirs(v, exist_ok=True)
+    with open(os.path.join(v, f"episode-{file_no:03d}.mp4"), "wb") as f:
+        f.write(b"video")
+    ep_path = pooled_episodes_path(task_dir, n)
+    os.makedirs(os.path.dirname(ep_path), exist_ok=True)
+    _atomic_write_parquet(
+        _episode_rows_table([{"episode_index": n, "task_name": "t"}]),
+        ep_path)
+
+
+def group_exists_n(task_dir: str, n: int) -> bool:
+    """全局号 N 的三件套是否齐全（数据 / 视频 / meta 行）。"""
+    from core.helpers import episode_chunk_file
+    c, f = episode_chunk_file(n)
+    return (os.path.isfile(pooled_data_parquet_path(task_dir, n))
+            and os.path.isfile(os.path.join(
+                task_dir, "videos", f"chunk-{c:03d}", "uvc_rgb",
+                f"episode-{f:03d}.mp4"))
+            and os.path.isfile(pooled_episodes_path(task_dir, n)))
+
+
+def group_exists(task_dir: str, file_no: int) -> bool:
+    """chunk-000 里该文件号的三件套（旧调用点的简写）。"""
+    return group_exists_n(task_dir, file_no + 1)
+
+
+def main():
+    shutil.rmtree(ROOT, ignore_errors=True)
+    app = QApplication(sys.argv)  # noqa: F841 — 持有引用才有 QApplication
+    settings.UPLOAD_AUTO_SYNC = False
+    settings.ENCODER_PROBE_ENABLED = False
+    win = LiteWindow(pipeline=CameraPipeline(output_dir=ROOT))
+    try:
+        t1 = os.path.join(ROOT, "multi")
+        for f in (0, 1, 2):
+            make_episode(t1, f)
+        check(len(list_task_episodes(t1)) == 3, "造 3 段池化数据")
+
+        # ── 1. 列表口径：ep 必须是全局号 N，不是文件号 ──
+        check(win._episode_max(t1) == 3,
+              "上传列表的 ep = 全局 N 3（不是文件号 2；列表值会被上传器当 N 用）")
+
+        # ── 2. 上传完成后删除：原样透传 N，不许 +1 ──
+        real_delete = win._delete_after_upload
+        seen = []
+        win._delete_after_upload = lambda p, e: seen.append((p, e))
+        settings.UPLOAD_DELETE_AFTER = True
+        win._upload_task_map["tid"] = (t1, 3)     # 自动上传路径存的就是 N
+        win._on_upload_done("tid")
+        check(seen == [(t1, 3)],
+              f"_on_upload_done 原样透传 N=3（实测 {seen}；+1 会删到不存在的 N=4）")
+        win._delete_after_upload = real_delete
+
+        # ── 3. 真删：N=3 删的是文件号 002 那一组 ──
+        win._delete_after_upload(t1, 3)
+        check(not group_exists(t1, 2), "删掉的是文件号 002 那一段（上传的那段）")
+        check(group_exists(t1, 0) and group_exists(t1, 1),
+              "文件号 000/001 两组原样保留（没误删邻居）")
+        check(list_task_episodes(t1) == [1, 2], "剩余 episode 号 = [1, 2]")
+        check(os.path.isdir(t1), "任务目录本身保留（只删该段）")
+
+        # ── 4. 单段目录：删的是那一段，不是整目录 ──
+        t2 = os.path.join(ROOT, "single")
+        make_episode(t2, 0)
+        check(win._episode_max(t2) == 1, "单段目录的 ep = N 1（不是 0 = 整目录）")
+        win._delete_after_upload(t2, 1)
+        check(list_task_episodes(t2) == [], "单段目录删掉该段")
+        check(os.path.isdir(t2), "单段目录仍存在（不整目录 rmtree）")
+
+        # ── 5. 池化 parquet 全无（旧格式/空目录）→ 按整目录删 ──
+        t3 = os.path.join(ROOT, "legacy")
+        os.makedirs(os.path.join(t3, "meta"), exist_ok=True)
+        with open(os.path.join(t3, "meta", "info.json"), "w") as f:
+            f.write("{}")
+        check(win._episode_max(t3) == 0, "旧格式目录 ep = 0（整目录）")
+        win._delete_after_upload(t3, 0)
+        check(not os.path.isdir(t3), "无 parquet 的目录整目录删除")
+
+        # ── 6. 跨 chunk：f 回绕后必须按 chunk 号还原全局 N ──
+        t4 = os.path.join(ROOT, "chunked")
+        for f in (0, 1, POOLED_CHUNK_SIZE - 1):
+            make_episode(t4, f)                 # chunk-000 → N 1 / 2 / 1000
+        make_episode(t4, 0, chunk=1)            # chunk-001 → N 1001（f 从 0 重开）
+        check(len(list_task_episodes(t4)) == 4, "造跨 chunk 数据：N = [1, 2, 1000, 1001]")
+        check(win._episode_max(t4) == POOLED_CHUNK_SIZE + 1,
+              f"跨 chunk 的任务 ep = 真值 N {POOLED_CHUNK_SIZE + 1}"
+              f"（不是「最大文件名 f + 1」= 1 —— 那指向 chunk-000 里真实存在的 N=1）")
+        win._delete_after_upload(t4, POOLED_CHUNK_SIZE + 1)
+        check(not group_exists_n(t4, POOLED_CHUNK_SIZE + 1),
+              "删掉的是 chunk-001/episode-000（N 1001）")
+        check(group_exists_n(t4, 1) and group_exists_n(t4, 2)
+              and group_exists_n(t4, POOLED_CHUNK_SIZE),
+              "chunk-000 的 N=1/2/1000 原样保留（没回绕删到真值 N=1）")
+    finally:
+        win.close()
+        shutil.rmtree(ROOT, ignore_errors=True)
+
+    print()
+    if FAILS:
+        print(f"FAIL: {len(FAILS)} 项未通过")
+        return 1
+    print("PASS: lite 上传后删除编号回归全部通过")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

collector/tools/tests/test_device_access_selflock.py

@@ -29,6 +29,17 @@
   8. fays_device_guard_path 拒绝非 /dev/videoN
   9. UVC 配对失败文案带上逐组拒绝原因（原先只报 matches/groups 计数）
 
+第 9 条以外，以下三条钉的是提交 00612cb1「UVC 发现结果不再丢弃」的三处改动
+（改前它们**零测试覆盖**：唯一触边的第 9 条用它自己的 fixture 键 `physical_usb_path`
+—— 那键在 UVC 报告里根本不存在 —— 且不打标签，所以标签改错了它照样 PASS）：
+  10. 逐组拒绝原因的标签取报告真键 `outer_path`（键名写错就退化成 group#N；
+      报告里真缺这个键时才回退 group#N）
+  11. Flash 身份失败报错带 `sightac[i]` + side/flash_ok/device_type/serial/error
+      五项（否则三种不同故障报同一句话），且**「side 空/无效」与「左右重复」两条
+      分支的抬头不同**（前者会被误指成「拓扑重复」，真因却是厂商没写 side）
+  12. 发现程序 rc==0 时 stderr 也逐行进 `[UVC-DISCOVER]` 日志（rc!=0 的既有行为
+      不变：stderr 尾部进异常文案、不重复转发）
+
 退出码 0 = 全部通过。
 """
 
@@ -203,15 +214,33 @@ def test_invalid_node():
     check(raised, "fays_device_guard_path 拒绝非 /dev/videoN")
 
 
-def test_pairing_message_carries_reason():
-    """配对失败必须把逐组拒绝原因带出来，不能只剩 matches/groups 计数。"""
-    from core.gripper.devices.uvc_camera_service import (
-        UvcCameraServiceError, UvcCameraServiceManager,
-    )
+def fake_manager(**attrs):
+    """object.__new__ 造的假 manager：只装本次要用的属性（不起设备/子进程）。
+
+    `_resolve_current_group` / `_associate_group` / `_run_discovery` 都是拿
+    self 当命名空间用的纯逻辑，构造真 manager 会去碰设备，所以照旧绕过。
+    """
+    from core.gripper.devices.uvc_camera_service import UvcCameraServiceManager
 
     service = object.__new__(UvcCameraServiceManager)
+    for key, value in attrs.items():
+        setattr(service, key, value)
+    return service
+
+
+def test_pairing_message_carries_reason():
+    """配对失败必须把逐组拒绝原因带出来，不能只剩 matches/groups 计数。
+
+    组里用的是报告里**真有的** `outer_path`（C 侧 `discover_uvc_config.c:1239`
+    写出 `"bus":N,"outer_path":...`）—— 这个 fixture 原先写的是
+    `physical_usb_path`，那个键在报告里根本不存在，于是标签一直退化成
+    `group#0`，把「标签对不对」这件事测成了假绿（见 test_rejection_label_...）。
+    """
+    from core.gripper.devices.uvc_camera_service import UvcCameraServiceError
+
+    service = fake_manager()
     reason = "sightac mode=failed error='MJPEG 640x480@30: Invalid mode'"
-    group = {"physical_usb_path": "3-1", "valid": False}
+    group = {"outer_path": "1.2", "valid": False}
     with mock.patch.object(service, "_discovery_scope", return_value=(3, "1")), \
             mock.patch.object(service, "_run_discovery", return_value=[group]), \
             mock.patch.object(service, "_associate_group",
@@ -226,6 +255,182 @@ def test_pairing_message_carries_reason():
             check("matches=0" in text and "groups=1" in text,
                   "文案仍保留 matches/groups 计数")
             check(reason in text, "文案带上了逐组拒绝原因（真因不再被吞）")
+            check("1.2: " in text,
+                  "拒绝原因的标签是报告里真有的 outer_path（不是 group#N）")
+            check("group#0" not in text,
+                  "标签没有退化成 group#0（键名写错就会退化，见下一条测试）")
+
+
+def test_rejection_label_uses_outer_path():
+    """改动③：逐组拒绝原因的标签必须是报告里真有的键。
+
+    真键由 C 侧定：`discover_uvc_config.c:1239` 写的是
+    `{"bus":N,"outer_path":...}`；`physical_usb_path` 在整个 C 源码里
+    一次都没出现（那是 ESP32 清单 side 的键，不是 UVC 报告的）。
+    标签写错键名 → 真实失败下每一组都退化成 `group#0`/`group#1`，
+    用户看不出是哪条 USB 路径出的问题。
+    """
+    from core.gripper.devices.uvc_camera_service import UvcCameraServiceError
+
+    def rejections_for(groups):
+        service = fake_manager()
+        with mock.patch.object(service, "_discovery_scope",
+                              return_value=(3, "1")), \
+                mock.patch.object(service, "_run_discovery",
+                                  return_value=groups), \
+                mock.patch.object(service, "_associate_group",
+                                  side_effect=UvcCameraServiceError("拒绝原因")), \
+                mock.patch.object(service, "_assignment_identity",
+                                  return_value=("ESP-SN", "FAYS-SN")):
+            try:
+                service._resolve_current_group({"id": "umi"})
+            except UvcCameraServiceError as exc:
+                return str(exc)
+        return ""
+
+    # 两把键都在、���值不同：标签必须取 outer_path（拿错键就会取到 3-1）——
+    # 这是本条的判据，只断言「有标签」会两种实现都通过。
+    text = rejections_for([{"outer_path": "1.2", "physical_usb_path": "3-1",
+                            "valid": False}])
+    check("1.2: 拒绝原因" in text,
+          "标签取 outer_path（报告真键）")
+    check("3-1: 拒绝原因" not in text,
+          "标签没有误取 physical_usb_path（那个键在 UVC 报告里不存在）")
+
+    # 多组时逐组一条，下标与标签一一对应（别把两条压成同一条）。
+    text = rejections_for([{"outer_path": "1.2"}, {"outer_path": "2.3"}])
+    check("1.2: 拒绝原因" in text and "2.3: 拒绝原因" in text,
+          "逐组各记一条拒绝原因，标签各不相同")
+
+    # 报告里真的没有 outer_path 时按 group#N 回退（不是静默变空）——
+    # 这是有意的兜底：C 侧若某天不再写这个键，日志里仍能定位到第几组。
+    text = rejections_for([{"bus": 3}])
+    check("group#0: 拒绝原因" in text,
+          "报告里没有 outer_path 时回退到 group#N（不静默变空）")
+
+
+def test_pairing_uniqueness_message_carries_identity():
+    """改动②：「Flash 身份」失败必须带上 sightac[i] 的元素身份，且**两种故障分开报**。
+
+    不加身份字段时，「Flash 读不出 / 读出来是空串 / device_type 不对」
+    三种完全不同的故障报的是**同一句话**（`side=''`），现场又要从头猜。
+    字段名都是 C 侧 `write_json_candidate` 真写出来的键
+    （discover_uvc_config.c:1092 起：side / flash_ok / device_type /
+    flash_serial / error）。
+
+    另一半是**抬头本身**：同一个抬头 `身份不唯一` 同时盖住①这台没报出左右
+    （side 空/无效）与②两台报了同一个左右 —— ①的真因是 Flash 没写 side
+    （只能厂商补写，仓库无写路径），照"左右重复"去查拓扑是白转一圈。所以两条
+    分支的抬头必须不同。
+    """
+    from core.gripper.devices.uvc_camera_service import UvcCameraServiceError
+
+    def message_for(sightac):
+        service = fake_manager()
+        group = {"bus": 3, "outer_path": "1", "valid": True,
+                 "sightac": sightac,
+                 "decxin": {"mode_ok": True, "port": "1.3"}}
+        live_esp = [{"serial": "ESP-SN", "physical_usb_path": "3-1.2"}]
+        with mock.patch.object(service, "_assignment_identity",
+                               return_value=("ESP-SN", "FAYS-SN")):
+            try:
+                service._associate_group(group, {"id": "umi"}, live_esp)
+            except UvcCameraServiceError as exc:
+                return str(exc)
+        return ""
+
+    # 真实的 field failure：side 读出来是空串，JSON 里有 error 说明为什么。
+    bad = {"side": "", "flash_ok": False, "device_type": "",
+           "flash_serial": "",
+           "error": "LIBUSB_ERROR_TIMEOUT reading Flash side"}
+    text = message_for([{"side": "left", "flash_ok": True,
+                         "device_type": "sightac", "flash_serial": "L-SN"},
+                        bad])
+    check("sightac[1]" in text, "带上出问题的那个下标（sightac[1]，不是笼统的组）")
+    check("side=''" in text, "带上 side 原文")
+    check("flash_ok=False" in text, "带上 flash_ok（区分「Flash 读失败」）")
+    check("device_type=''" in text, "带上 device_type（区分「类型不对」）")
+    check("serial=''" in text, "带上 flash_serial（区分「读出来是空串」）")
+    check("LIBUSB_ERROR_TIMEOUT" in text,
+          "带上 error 原文（真因不再被压成同一句话）")
+    check("身份不唯一" not in text,
+          "side 空/无效报的是「没报出有效左右」，**不是**「身份不唯一」"
+          "（照「重复」去查拓扑会把方向指错）")
+
+    # 左右重了：报的是**第二个**（i=1）那个，不是第一个；抬头是「不唯一」。
+    text = message_for([{"side": "left", "flash_ok": True},
+                        {"side": "left", "flash_ok": True}])
+    check("sightac[1]" in text and "side='left'" in text,
+          "左右重复时报出重复的那个下标与值（sightac[1] side='left'）")
+    check("身份不唯一" in text,
+          "真的左右重复时仍然报「身份不唯一」（两分支抬头不同）")
+
+
+def test_discover_stderr_kept_on_success():
+    """改动①：rc==0 时 stderr 也要进 [UVC-DISCOVER] 日志。
+
+    发现程序（core/gripper/camera_service_src/tools/discover_uvc_config.c）
+    把每台相机的现场打到 stderr 的 [DISCOVERY] 行。JSON 里虽然有 error
+    字段，但并非全都在：`mode=unknown` 与 `mode=failed` 在 JSON 里都被压成
+    `mode_ok:false`，flash/calibration 的 ok|failed|skipped 三态也只剩布尔
+    —— 而 rc==0 的「配对失败」现场恰恰就是这些差别。过去只在 rc!=0 时读
+    stderr，rc=0 的那次等于整份丢���，只剩一句 side=''。
+    """
+    import json as _json
+    from pathlib import Path
+
+    from core.gripper.devices.uvc_camera_service import (
+        UvcCameraServiceError, UvcCameraServiceManager,
+    )
+
+    reports = _json.dumps({"groups": [{"bus": 3, "outer_path": "1",
+                                       "sightac": [{}, {}], "decxin": {},
+                                       "valid": True}]})
+    lines = [
+        "[DISCOVERY] Sightac vidpid=2207:0019 bus=3 port=1.2 "
+        "usb_serial=<none> control_if=0 stream_if=1 alt=7 "
+        "descriptor_payload=327680 negotiated_payload=241664 mode=unknown "
+        "flash=failed calibration=failed side=<none> serial=<none> "
+        "type=<none> error=XU6 prepare failed",
+        "[DISCOVERY] complete group(s)=1",
+    ]
+
+    def run_with(returncode, stdout, stderr):
+        logs = []
+        service = fake_manager(_logger=logs.append,
+                               _discovery_binary=Path("/bin/true"))
+        completed = subprocess.CompletedProcess(
+            ["/bin/true"], returncode, stdout=stdout, stderr=stderr)
+        with mock.patch.object(subprocess, "run", return_value=completed):
+            try:
+                result, error = service._run_discovery(), None
+            except UvcCameraServiceError as exc:
+                result, error = None, str(exc)
+        return logs, result, error
+
+    logs, result, error = run_with(0, reports, "\n".join(lines) + "\n")
+    check(error is None and result is not None,
+          "rc==0 仍正常解析出 groups（改动没干扰成功路径）")
+    check(logs == ["[UVC-DISCOVER] " + line for line in lines],
+          f"rc==0 的 stderr 逐行进日志（{len(logs)} 行；改动前这里一行都没有）")
+
+    logs, _, _ = run_with(0, reports, "")
+    check(logs == [], "stderr 为空时不打空行（不制造噪声）")
+
+    # rc!=0 的既有行为不变：stderr 尾部进异常文案（不是进日志），
+    # 且异常发生在转发之前 —— 别把失败路径的 stderr 打两遍。
+    many = [f"[DISCOVERY] line {i}" for i in range(30)]
+    logs, _, error = run_with(1, "", "\n".join(many))
+    check(error is not None and "rc=1" in error,
+          "rc!=0 仍抛错并带上 rc")
+    check("line 29" in error and "line 0" not in error,
+          "rc!=0 只带 stderr 尾部 20 行（既有行为不变）")
+    check(logs == [], "rc!=0 时不重复转发（stderr 已进异常文案）")
+
+    # 防御：_logger 是实例属性（构造时注入），不是全局 print。
+    check(UvcCameraServiceManager.__init__.__code__.co_varnames[:6]
+          and "logger" in UvcCameraServiceManager.__init__.__code__
+          .co_varnames[:6], "_logger 由构造参数注入（真机上打给 SLAM/设备面板）")
 
 
 def main():
@@ -243,6 +448,12 @@ def main():
     test_invalid_node()
     print("\n[7. 配对失败文案带原因]")
     test_pairing_message_carries_reason()
+    print("\n[8. 逐组拒绝原因的标签用真键 outer_path（改动③）]")
+    test_rejection_label_uses_outer_path()
+    print("\n[9. 「Flash 身份不唯一」带 sightac[i] 身份字段（改动②）]")
+    test_pairing_uniqueness_message_carries_identity()
+    print("\n[10. rc==0 也留发现程序 stderr（改动①）]")
+    test_discover_stderr_kept_on_success()
 
     print()
     if FAILS:

collector/tools/tests/test_gripper_latest_pose_frame.py

@@ -177,9 +177,12 @@ def main() -> int:
               f"{raw_seq}/{lost} vs {controller._pose_raw_seq}/"
               f"{controller._pose_lost_count}")
 
-        # 连续几帧（位姿判据会拒跳变：步长要小）
+        # 连续几帧。步长 20mm：要**同时**满足两个门 —— 大于发布死区
+        # POSE_PUBLISH_DEADBAND_M（3mm，否则发布的是冻结值，这里比的是
+        # 发布出口，不是换算本身）且远小于跳变门限值（dt=1s ⇒ 上限受
+        # POSE_MAX_LINEAR_SPEED_MPS 约束），别再用 1-2mm 的小步。
         for index in range(1, 6):
-            spot = (0.1 + 0.002 * index, 0.2, 0.3 + 0.001 * index)
+            spot = (0.1 + 0.02 * index, 0.2, 0.3 + 0.01 * index)
             feed(controller, counters, 1.0 + index, spot)
             expect = expected_published(spot)
             now = controller.read_latest_pose()[0]

collector/tools/tests/test_gripper_pose_axes.py

@@ -23,8 +23,14 @@
   一个常数 M（约 120°）——用户判"跟随夹爪的坐标轴还没改"。
 - **原点那一瞬发布姿态 = M·Mᵀ = 单位矩阵**：夹爪三箭头与世界三箭头
   重合，这是"一眼看出用的是哪一帧"的判据（第 4 节钉住）。
+- 相对化是**右乘** R0⁻¹（世界系相对姿态 R·R0⁻¹），**不是左乘**：左乘
+  R0⁻¹·R 得到的是"锚点体轴系里的相对转动"，两者只差一个常数共轭，却会让
+  视图里看得见的**旋转轴整体转错**（v1.3.13 的 bug，锚点 R0 = R_x(−90°) 时
+  恰好是绕发布帧 Y 轴 90°：Y 是不动轴所以只有它是对的，X 与 Z 被对调并翻号
+  —— 用户实测"绕 X → 表观绕 Z 同向、绕 Z → 表观绕 X 反向、绕 Y 正常"）。
+  第 10 节钉相对化的语义，第 11 节钉用户的验收判据「表观旋转轴 == 显示轴」。
 - 相对化与重标的**顺序不再影响结果**：共轭让 M 在两步里都自消，
-  (M·R0·Mᵀ)ᵀ(M·R·Mᵀ) = M·R0ᵀ·R·Mᵀ 与"先相对化再重标"逐元素相同。
+  (M·R·Mᵀ)(M·R0·Mᵀ)ᵀ = M·R·R0⁻¹·Mᵀ 与"先相对化再重标"逐元素相同。
   第 5 节把这条等价性钉住（旧版顺序是雷，v1.3.13 第二版起不是了）。
 
 物理验收判据（第 1、2 节）：正对→+Z、左→+Y、下→+X、右→−Y、上→−X。
@@ -230,13 +236,13 @@ def main():
     #   而位置已换帧，GUI 的夹爪模型会画成转了 90° 的姿势。）
     mid_t0b = relabel_published_frame(mid_t0)
     mid_t1b = relabel_published_frame(mid_t1)
-    swapped = quat_product(quat_conjugate(mid_t0b.rotation), mid_t1b.rotation)
+    swapped = quat_product(mid_t1b.rotation, quat_conjugate(mid_t0b.rotation))
     if not np.allclose(quat_to_matrix(*swapped), R1, atol=1e-12):
         failures.append("顺序等价性不成立：先重标再相对化给出了不同姿态")
     # 反向钉死两条：①去掉右乘（旧实现只左乘 M）必须给出**不同**的答案，
     # 否则"体轴也改了名"这件事没有回归保护；②旧实现在原点那一瞬是常数 M
     # —— 正是用户看到"跟随夹爪的坐标轴还没改"的原因。
-    rel_q = quat_product(quat_conjugate(mid_t0.rotation), mid_t1.rotation)
+    rel_q = quat_product(mid_t1.rotation, quat_conjugate(mid_t0.rotation))
     left_only = quat_to_matrix(*quat_product(q_M, rel_q))
     if np.allclose(left_only, R1, atol=1e-12):
         failures.append("体轴改名没生效：只左乘 M 与左右各乘一次结果相同")
@@ -337,13 +343,15 @@ def main():
             break
 
     # 10. 原点相对化：首帧姿态 q0（含部署校正/启动朝向的任意常数
-    #     旋转），此后 q0⁻¹⊗q 应还原为相对原点的真实转动；再重标
-    #     之后发布姿态 = M·(相对转动)
+    #     旋转），此后**右乘** q0⁻¹ 应还原为相对原点的真实转动（世界系
+    #     相对姿态 q⊗q0⁻¹）；再重标之后发布姿态 = M·(相对转动)·Mᵀ。
+    #     ⚠左乘 q0⁻¹⊗q 不是"另一种写法"，它是"锚点体轴系里的增量"，
+    #     差一个常数共轭 ⇒ 视图里看得见的旋转轴整体转错（第 11 节）。
     for i in range(200):
         q0r = random_unit_quaternion(rng)
         q_rel = random_unit_quaternion(rng)
-        q = quat_product(q0r, q_rel)
-        recovered = quat_product(quat_conjugate(q0r), q)
+        q = quat_product(q_rel, q0r)          # 世界系：R = R_rel·R0
+        recovered = quat_product(q, quat_conjugate(q0r))
         if not np.allclose(recovered, q_rel, atol=1e-12):
             failures.append(f"#{i} 相对化未还原相对转动")
             break
@@ -355,6 +363,74 @@ def main():
             failures.append(f"#{i} 发布姿态应为 M·(相对转动)·Mᵀ")
             break
 
+    # 11. ★验收判据：位姿视图里"看得见的"旋转必须与物理转动同轴同向★
+    #     视图画的是 R_pub·(M·v)（体轴箭头 = R_pub 的三列），眼睛看到的表观
+    #     旋转 = R_pub(t)·R_pub(0)ᵀ；锚点那一瞬发布姿态是单位矩阵，所以它就
+    #     等于 R_pub(t) 本身。物理上绕"显示出来的第 k 根轴"转 deg，在中间帧里
+    #     就是绕 a = Mᵀ·e_k 左乘 ΔR（世界系转动，物理动作决定的就是它）。
+    #     修好后表观旋转必须恰好 = 绕 e_k 转 deg，**与锚点 R0 无关**。
+    #     （v1.3.13 的左乘相对化在这里给出 +Z / +Y / −X，R0 = R_x(−90°) 时
+    #       正是用户实测的三条，见下面那条反向钉。）
+    def world_rot_quat(axis, deg):
+        a = np.asarray(axis, dtype=float)
+        a = a / np.linalg.norm(a)
+        half = math.radians(deg) / 2.0
+        return (math.sin(half) * a[0], math.sin(half) * a[1],
+                math.sin(half) * a[2], math.cos(half))
+
+    # q0 = R_x(−90°)（真机锚点，= 第 4 节的 mid0）在前，随机锚点在后 ——
+    # 两条都要过：修好后表观轴与 R0 无关。
+    anchor_qs = [(-c, 0.0, 0.0, c)] + [random_unit_quaternion(rng)
+                                       for _ in range(3)]
+    for j, q0r in enumerate(anchor_qs):
+        for k in range(3):
+            for deg in (30.0, -30.0):
+                a = M.T @ np.eye(3)[k]        # 显示轴 e_k 对应的物理轴
+                q1 = quat_product(world_rot_quat(a, deg), q0r)
+                pub1 = finish_publish_pose(
+                    PoseSample(position=(0.0, 0.0, 0.0), rotation=q1,
+                               timestamp=2.0), q0r)
+                apparent = quat_to_matrix(*pub1.rotation)
+                want = quat_to_matrix(*world_rot_quat(np.eye(3)[k], deg))
+                if not np.allclose(apparent, want, atol=1e-9):
+                    failures.append(
+                        f"锚点#{j} 绕显示 {'XYZ'[k]} 轴 {deg:+.0f}° 的表观旋转"
+                        f"不是同轴同向：\n实际\n{np.round(apparent, 6)}\n"
+                        f"应为\n{np.round(want, 6)}")
+                    break
+    # 反向钉：左乘 R0⁻¹（v1.3.13 的 bug）在真机锚点 R_x(−90°) 下把表观转轴
+    # 按 `R_y(−90°)·(显示轴)` 搬走、角度符号不变 —— 逐条就是用户实测的
+    # 「绕 X → 绕 Z 同向、绕 Z → 绕 X 逆向、**绕 Y 不动**」。
+    # 第 0、2 根轴必须**对不上**（否则上面的验收判据是"两种写法都能过"的空
+    # 断言），第 1 根轴必须**恰好重合**（Y 正是那个搬运旋转的不动轴 —— 用户
+    # 看到的"只有绕 Y 是正常的"就是这一行）。
+    Rbug = np.array([[0.0, 0.0, -1.0], [0.0, 1.0, 0.0], [1.0, 0.0, 0.0]])
+    q0r = anchor_qs[0]
+    for k in range(3):
+        a = M.T @ np.eye(3)[k]
+        q1 = quat_product(world_rot_quat(a, 30.0), q0r)
+        bug = quat_product(quat_conjugate(q0r), q1)    # 左乘相对化
+        bug_pub = quat_to_matrix(*quat_product(
+            quat_product(q_M, bug), quat_conjugate(q_M)))
+        if not np.allclose(
+                bug_pub,
+                quat_to_matrix(*world_rot_quat(Rbug @ np.eye(3)[k], 30.0)),
+                atol=1e-9):
+            failures.append(
+                f"左乘相对化的错法不是预期的 R_y(−90°) 搬运（显示轴 k={k}）")
+            continue
+        same = np.allclose(
+            bug_pub,
+            quat_to_matrix(*world_rot_quat(np.eye(3)[k], 30.0)), atol=1e-9)
+        if k == 1 and not same:
+            failures.append(
+                "绕 Y 的转动本该不受左乘 bug 影响（Y 是搬运旋转的不动轴）"
+                "—— 用户实测「只有绕 Y 正常」就靠这条")
+        if k != 1 and same:
+            failures.append(
+                f"绕 {'XYZ'[k]} 的 bug 竟然给出正确表观旋转 —— "
+                "上面的验收判据是空断言")
+
     if failures:
         print("FAIL:")
         for f in failures[:5]:
@@ -363,7 +439,8 @@ def main():
     print("PASS: 发布帧(+X下/+Y左/+Z前) 数学性质全部通过"
           "（轴映射/物理轴复现/200 随机位姿 M·R_z90·R·Mᵀ/首帧=单位阵即"
           "体轴与世界轴在原点重合/★体轴改名+顺序等价★/双应用与M³/"
-          "时基透传/轨迹等距/四元数积/原点相对化）")
+          "时基透传/轨迹等距/四元数积/原点相对化=右乘R0⁻¹/"
+          "★表观旋转轴==显示轴（用户验收判据）★）")
     return 0
 
 

collector/tools/tests/test_gripper_pose_deadband_publish.py

@@ -0,0 +1,299 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""发布出口的死区集成测试：走真 SlamProcessController（v1.3.14）。
+
+    venv/bin/python tools/tests/test_gripper_pose_deadband_publish.py
+
+背景：用户报「大幅漂移没了，静止时轨迹线/末端点还有小抖」。实测那是估计器的
+毫米级有界游走（严格静止窗：位置游走半径逐会话 p50 1.06-1.85mm/max 1.39-4.98mm；
+姿态峰峰 p50 0.25°/max 1.80°），单帧步长远在跳变门
+限值之下，所以跳变门（比相邻样本）管不着。修法是在**发布出口**对"上次发出的
+位置"设死区：不足死区就发上次的值。
+
+单元测试（test_pose_publish_deadband.py）钉的是函数语义；这里钉的是**接线**：
+死区必须真的作用在 _publish_pose 出口那条路上（UI/_on_pose/轨迹/orb_pose.json
+全从这一条路出去），而且不能把下面这些既有契约弄坏：
+
+  1. 静止游走：发出去的值冻结（_on_pose 收到的位置恒定），末端点不再抖
+  2. 采样节拍不变：每帧仍算 valid、raw_seq 仍逐帧递增、lost_count 不得虚增
+     （死区是"发旧值"，不是"丢帧"——丢帧会让 GUI 的位姿丢失计数虚报）
+  3. orb_pose.json 里也是冻结值（GUI/控制通道读的就是它）
+  4. 真实移动照常跟踪（误差 ≤ 死区）
+  5. 重设原点后死区参照被丢掉（否则会拿旧锚下的位置比新锚下的位置）
+  6. 落盘未启用的分支（pose_paths 为空）同样生效
+
+退出码 0 = 全部通过。
+"""
+
+from __future__ import annotations
+
+import json
+import math
+import os
+import random
+import sys
+import tempfile
+
+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.process_controller import (              # noqa: E402
+    SlamProcessController,
+    SlamState,
+)
+from core.gripper.slam.protocol import (                        # noqa: E402
+    POSE_PUBLISH_DEADBAND_M,
+    PoseSample,
+    ProtocolEvent,
+    parse_slam_line,
+    relabel_published_frame,
+    rotate_pose_z90,
+)
+
+FAILS: list[str] = []
+EPS = POSE_PUBLISH_DEADBAND_M
+
+
+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 make_controller(pose_paths=(None, None), log=None) -> SlamProcessController:
+    return SlamProcessController(
+        SlamState(),
+        executable="/bin/true",
+        vocabulary="/dev/null",
+        settings="/dev/null",
+        device_config="/dev/null",
+        trajectory="/dev/null",
+        work_dir="/tmp",
+        pose_paths=pose_paths,
+        log=log,
+        runtime_env_factory=lambda: {},
+        cpu_roles={
+            "fays_left_orb": (0,),
+            "fays_right_orb": (1,),
+            "fays_background": (2,),
+        },
+    )
+
+
+def feed(controller, counters, timestamp, position,
+         quat=(1.0, 0.0, 0.0, 0.0)):
+    """喂一行**真格式**的 native 位姿（走真解析器，别手工造 PoseSample）。"""
+    x, y, z = position
+    qw, qx, qy, qz = quat
+    line = (f"[{timestamp:.6f}] XYZ:({x:.6f},{y:.6f},{z:.6f}) "
+            f"Quat:(w={qw:.6f},x={qx:.6f},y={qy:.6f},z={qz:.6f})")
+    event = parse_slam_line(line)
+    assert event is not None and event.kind == "pose", f"{line!r} -> {event!r}"
+    controller._handle_event(event, counters, arrival_monotonic=timestamp,
+                            arrival_wall_time=timestamp)
+    pose, _, _ = controller.read_latest_pose()
+    return pose
+
+
+def rest_wander(frames, seed=20261013, sigma=0.00010, a=0.96):
+    """实测形状的静止游走：有界小球（AR(1)），不是越走越远的随机游走。"""
+    rng = random.Random(seed)
+    pos = [0.0, 0.0, 0.0]
+    out = []
+    for _ in range(frames):
+        pos = [a * pos[0] + rng.gauss(0.0, sigma),
+               a * pos[1] + rng.gauss(0.0, sigma),
+               a * pos[2] + rng.gauss(0.0, sigma)]
+        out.append(tuple(pos))
+    return out
+
+
+def published_frame_images(raw_positions):
+    """把每个原始（中间帧）位置独立过一遍发布变换，得到"合法发布值"集合。
+
+    发布值若都落在其中，说明死区是**替换**（发的是某一帧真值），而不是插值/
+    平均/自造的值 —— 这是"发上次的值"这句话唯一能被证伪的形式（第 1 节那句
+    「连续帧逐分量相同 or distinct<=3」是恒真的，钉不住东西）。
+
+    ⚠ 先按喂入时的**线上量化**（feed 用 %.6f 写行）还原，否则算出来的像与
+    控制器真正收到的值差在 6 位小数之外，集合对不上。
+    """
+    images = set()
+    for p in raw_positions:
+        q = tuple(float(f"{float(v):.6f}") for v in p)
+        s = relabel_published_frame(rotate_pose_z90(
+            PoseSample(position=q, rotation=(0.0, 0.0, 0.0, 1.0),
+                       timestamp=0.0)))
+        images.add(tuple(round(float(v), 12) for v in s.position))
+    return images
+
+
+def main() -> int:
+    print("发布出口死区集成测试（v1.3.14）")
+
+    # ---------------------------------------------------------- 静止游走
+    for label, pose_paths in (("落盘未启用（pose_paths 空）", (None, None)),
+                              ("落盘启用（写 orb_pose.json）", None)):
+        if pose_paths is None:
+            tmpdir = tempfile.mkdtemp(prefix="pose_deadband_")
+            pose_paths = (os.path.join(tmpdir, "orb_pose.json.tmp"),
+                          os.path.join(tmpdir, "orb_pose.json"))
+        print(f"[1] 静止游走冻结 · {label}")
+        controller = make_controller(pose_paths)
+        counters = {"raw": 0, "valid": 0}
+
+        raw = rest_wander(400)
+        published = []
+        for i, p in enumerate(raw):
+            pose = feed(controller, counters, 1.0 + i * 0.02, p)
+            published.append(tuple(pose.position))
+        raw_radius = max(math.dist(p, (0.0, 0.0, 0.0)) for p in raw)
+        distinct = len(set(published))
+
+        check("合成游走本身有实测量级的幅度（不是空断言）",
+              0.0004 < raw_radius < 0.004,
+              f"半径 {raw_radius*1000:.2f}mm")
+        check("发出去的位置被冻结",
+              distinct <= 3,
+              f"400 帧只发出 {distinct} 个不同位置"
+              f"（死区 {EPS*1000:.0f}mm，游走半径"
+              f" {raw_radius*1000:.2f}mm）")
+        transitions = sum(1 for i in range(1, len(published))
+                          if published[i] != published[i - 1])
+        check("末端点保持：相邻帧发布值相同，只有越过死区的那几帧才变",
+              transitions <= 3,
+              f"{transitions} 次变化 / {len(published) - 1} 帧"
+              f"（游走半径 {raw_radius*1000:.2f}mm 全在死区 "
+              f"{EPS*1000:.0f}mm 内 ⇒ 本该 0 次）")
+        images = published_frame_images(raw)
+        rounded = [tuple(round(float(v), 12) for v in p) for p in published]
+        check("替换而非平滑：每个发布值都是某一帧原始值的发布帧像",
+              all(p in images for p in rounded),
+              f"{sum(1 for p in rounded if p not in images)} 个发布值不在"
+              "原始值像集合里（插值/平均会落到集合外）")
+        check("采样节拍不变：每帧都算 valid",
+              counters["valid"] == len(raw),
+              f"valid={counters['valid']} / 喂了 {len(raw)} 帧")
+        check("采样节拍不变：raw_seq 逐帧递增",
+              controller._pose_raw_seq == len(raw))
+        check("位姿丢失计数不得虚增（死区是发旧值，不是丢帧）",
+              controller.pose_lost_count() == 0,
+              f"lost_count={controller.pose_lost_count()}")
+        if pose_paths[1]:
+            with open(pose_paths[1], encoding="utf-8") as fh:
+                on_disk = json.load(fh)
+            check("orb_pose.json 里也是冻结值",
+                  (on_disk["x"], on_disk["y"], on_disk["z"])
+                  == published[-1])
+        else:
+            check("落盘未启用分支同样生效（有 pose 返回、有冻结）",
+                  published[-1] is not None and distinct <= 3)
+
+    # ---------------------------------------------------------- 真实移动
+    print("[2] 真实移动照常跟踪")
+    controller = make_controller()
+    counters = {"raw": 0, "valid": 0}
+    raw = [(0.01 * i, 0.0, 0.0) for i in range(200)]   # 10mm/帧 ≈ 0.3m/s
+    err = 0.0
+    for i, p in enumerate(raw):
+        pose = feed(controller, counters, 2.0 + i * 0.02, p)
+        expected = _published_position(p)
+        err = max(err, math.dist(pose.position, expected))
+    check("快速移动逐帧跟上",
+          err < 1e-6,
+          f"与独立复算的发布帧位置最大差 {err:.2e}m")
+    check("移动中丢失计数仍为 0", controller.pose_lost_count() == 0)
+
+    # 慢速移动（每帧 0.5mm < 死区）：量化但不丢，误差不累积
+    controller = make_controller()
+    counters = {"raw": 0, "valid": 0}
+    raw = [(0.0005 * i, 0.0, 0.0) for i in range(200)]
+    err = 0.0
+    for i, p in enumerate(raw):
+        pose = feed(controller, counters, 3.0 + i * 0.02, p)
+        err = max(err, math.dist(pose.position, _published_position(p)))
+    check("慢速移动（0.5mm/帧）误差不超死区",
+          err <= EPS + 1e-9,
+          f"最大误差 {err*1000:.2f}mm ≤ {EPS*1000:.0f}mm")
+    final, _, _ = controller.read_latest_pose()
+    check("慢速移动的末端仍跟到真值附近",
+          math.dist(final.position, _published_position(raw[-1])) <= EPS + 1e-9)
+
+    # ---------------------------------------------------------- 重设原点
+    # 注意：位置归零是 **native** 做的（原点是 C++ 帧的事），Python 这一层
+    # 只把姿态按新锚相对化。所以这里能钉的是"死区参照跟着丢"：重锚后即使
+    # 新���置离旧锚下的发布值不到一个死区，也必须照发，而不是被旧参照顶掉。
+    print("[3] 重设原点后参照要丢掉")
+    controller = make_controller()
+    counters = {"raw": 0, "valid": 0}
+    anchor_native = (0.3, 0.2, 0.1)
+    pose = feed(controller, counters, 4.0, anchor_native)
+    before = controller._last_published_position
+    before_published = tuple(pose.position)
+    check("重设原点前参照已建立", before is not None)
+    check("重设原点前参照 = 当前发布位置",
+          before is not None and math.dist(before, before_published) < 1e-9)
+    controller._handle_event(
+        ProtocolEvent("origin", "[ORIGIN SET]", "[ORIGIN SET]"),
+        counters, arrival_monotonic=4.1, arrival_wall_time=4.1)
+    check("重设原点后参照被丢弃", controller._last_published_position is None,
+          f"参照={controller._last_published_position}")
+    # 新锚下第一帧：相对旧锚下的发布值只挪 0.5mm（< 死区 3mm）。
+    # 参照没丢的话这一帧会被旧值顶掉 —— 那正是"重锚后位置跳变被吞"的病。
+    nudged_native = (0.3, 0.2, 0.1005)
+    pose = feed(controller, counters, 4.2, nudged_native)
+    check("重锚后参照重新建立",
+          controller._last_published_position is not None)
+    check("重锚后首帧照发（不足死区也放行，没被旧锚的参照顶掉）",
+          pose is not None
+          and math.dist(pose.position,
+                        _published_position(nudged_native)) < 1e-9,
+          f"发布位置={tuple(pose.position) if pose else None}"
+          f"（期望 {_published_position(nudged_native)}）")
+    check("重锚后首帧参照取的是新帧的值",
+          math.dist(controller._last_published_position,
+                    _published_position(nudged_native)) < 1e-9)
+
+    # ---------------------------------------------------------- 开机可见
+    # 用户是拿 GUI 验收的：「改了但界面上看不出来」等于没改。死区值必须在
+    # 开机日志里有一行，用户才能在 SLAM 日志面板里确认当次生效的是 3.0mm。
+    print("[4] 开机日志里能看见当次生效的死区（界面可验收）")
+    lines: list[str] = []
+    controller = make_controller(log=lines.append)
+    # READY 是 native 报「可以按回车」的那一行，每次起流只来一次
+    ready = parse_slam_line("[SLAM] READY")
+    assert ready is None or ready.kind != "pose"
+    controller._handle_event(ProtocolEvent("ready", "READY", "READY"),
+                             {"raw": 0, "valid": 0},
+                             arrival_monotonic=0.0, arrival_wall_time=0.0)
+    hit = [ln for ln in lines if "死区" in ln]
+    check("开机打出一行死区说明（GUI 日志面板能看见）",
+          len(hit) == 1,
+          f"{hit[0] if hit else '一行都没有'}")
+    check("行里的数值就是当次生效的死区",
+          bool(hit) and f"{EPS * 1000:.1f}mm" in hit[0],
+          f"期望含 {EPS * 1000:.1f}mm")
+
+    if FAILS:
+        print(f"\nFAIL: {len(FAILS)} 条")
+        for f in FAILS:
+            print("  -", f)
+        return 1
+    print(f"\nPASS: 死区 {EPS*1000:.0f}mm 在发布出口生效——静止发旧值（节拍/序号/"
+          "丢失计数不变）、移动照常、重锚丢参照")
+    return 0
+
+
+def _published_position(native_position):
+    """独立复算发布帧位置（native → R_z(+90°) → 世界重标 M）。"""
+    from core.gripper.slam.protocol import (
+        PoseSample, relabel_published_frame, rotate_pose_z90)
+    return relabel_published_frame(rotate_pose_z90(PoseSample(
+        position=native_position, rotation=(0.0, 0.0, 0.0, 1.0),
+        timestamp=0.0))).position
+
+
+if __name__ == "__main__":
+    sys.exit(main())

collector/tools/tests/test_local_delete.py

@@ -0,0 +1,157 @@
+"""本地删除统一口径（真删除）测试 —— 文件 + 录制行，全程校验。
+
+2026-10-12：删除从「标一行痕迹 / 界面照报成功」改成**真删除 + 删除后校验**。
+本测试钉死四件事：
+  1. 池化删除删对组（数据 + 视频 + meta 行），且返回 True 只代表真删净；
+  2. 删不掉（目录不可写）时返回 False 并给出残留文件——不许谎报成功；
+  3. 旧格式会话目录整目录删 + 校验；目录不存在如实报错；
+  4. RecordingRepo.delete_local_episode / delete_local_dir 真删库行（含尾斜杠
+     等路径写法归一化）。
+
+用法:
+    venv/bin/python tools/tests/test_local_delete.py
+"""
+import os
+import shutil
+import sys
+import tempfile
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.dirname(
+    os.path.abspath(__file__)))))
+
+from core.database import Database
+from core.egodata_writer import _atomic_write_parquet, _episode_rows_table
+from core.helpers import (delete_local_session, delete_pooled_episode,
+                          list_task_episodes, pooled_data_parquet_path,
+                          pooled_episode_leftovers, pooled_episodes_path)
+from core.recording_record import RecordingRecord
+
+FAILS = []
+
+
+def check(cond, msg):
+    print(f"  {'PASS' if cond else 'FAIL'}: {msg}")
+    if not cond:
+        FAILS.append(msg)
+
+
+def make_episode(task_dir: str, file_no: int, key: str = "uvc_rgb"):
+    """造一段池化数据：文件号 file_no（全局 N = file_no + 1）。"""
+    n = file_no + 1
+    d = os.path.join(task_dir, "data", "chunk-000")
+    os.makedirs(d, exist_ok=True)
+    with open(os.path.join(d, f"episode-{file_no:03d}.parquet"), "wb") as f:
+        f.write(b"data")
+    v = os.path.join(task_dir, "videos", "chunk-000", key)
+    os.makedirs(v, exist_ok=True)
+    with open(os.path.join(v, f"episode-{file_no:03d}.mp4"), "wb") as f:
+        f.write(b"video")
+    ep_path = pooled_episodes_path(task_dir, n)
+    os.makedirs(os.path.dirname(ep_path), exist_ok=True)
+    _atomic_write_parquet(
+        _episode_rows_table([{"episode_index": n, "task_name": "t"}]),
+        ep_path)
+
+
+def test_pooled_true_delete(root: str):
+    print("── 1. 池化真删除（删对组 + 校验）──")
+    t = os.path.join(root, "pooled")
+    for f in (0, 1, 2):
+        make_episode(t, f)
+    check(list_task_episodes(t) == [1, 2, 3], "造 3 段（全局 N=1..3）")
+    check(delete_pooled_episode(t, 2), "delete N=2 返回 True")
+    check(pooled_episode_leftovers(t, 2) == [], "N=2 残留为空（真删净）")
+    check(list_task_episodes(t) == [1, 3], "删的是 N=2（文件号 001）")
+    check(not os.path.isfile(pooled_data_parquet_path(t, 2))
+          and not os.path.isfile(pooled_episodes_path(t, 2)),
+          "N=2 的 parquet 与 meta 行文件都没了")
+    check(os.path.isfile(pooled_data_parquet_path(t, 1))
+          and os.path.isfile(pooled_data_parquet_path(t, 3)),
+          "邻居段（N=1/N=3）原样在")
+    check(delete_pooled_episode(t, 2), "重复删除幂等（返回 True）")
+
+
+def test_honest_failure(root: str):
+    print("── 2. 删不掉必须如实报错（不许报成功）──")
+    t = os.path.join(root, "locked")
+    make_episode(t, 0)
+    vdir = os.path.join(t, "videos", "chunk-000", "uvc_rgb")
+    os.chmod(vdir, 0o500)                     # 目录不可写 → unlink 失败
+    try:
+        check(delete_pooled_episode(t, 1) is False,
+              "视频删不掉时 delete_pooled_episode 返回 False")
+        left = pooled_episode_leftovers(t, 1)
+        check(any(p.endswith(".mp4") for p in left),
+              f"残留清单含那段视频（{len(left)} 个残留）")
+        ok, err = delete_local_session(t, 1)
+        check(ok is False and err, f"delete_local_session 报错: {err}")
+    finally:
+        os.chmod(vdir, 0o755)
+    ok, err = delete_local_session(t, 1)
+    check(ok is True and err == "", "恢复可写后重试成功")
+    check(pooled_episode_leftovers(t, 1) == [], "重试后残留为空")
+
+
+def test_legacy_dir(root: str):
+    print("── 3. 旧格式会话目录 ──")
+    d = os.path.join(root, "legacy_sess")
+    os.makedirs(os.path.join(d, "meta"))
+    with open(os.path.join(d, "meta", "info.json"), "w") as f:
+        f.write("{}")
+    check(delete_local_session(d, 0) == (True, ""), "整目录删除返回 (True, '')")
+    check(not os.path.isdir(d), "目录真的没了")
+    ok, err = delete_local_session(d, 0)
+    check(ok is False and err, f"目录不存在如实报错: {err}")
+    ok, err = delete_local_session("", 3)
+    check(ok is False and err, f"空路径如实报错: {err}")
+
+
+def test_repo_true_delete(root: str):
+    print("── 4. 录制行真删除（不再留痕迹行）──")
+    import core.recording_repository as rr
+    db = Database(db_path=os.path.join(root, "test.db"))
+    db.init_schema()
+    rr.db = db                              # 注入临时库，别碰真实 pipeline.db
+    try:
+        rows = [("/x/UMI_9_29", 7), ("/x/UMI_9_29", 8), ("/x/UMI_9_29/", 9),
+                ("/x/other", 1)]
+        for i, (path, ep) in enumerate(rows):
+            rr.RecordingRepo.save(RecordingRecord(
+                id=f"r{i}", camera_index=0, camera_name="cam",
+                file_path=path, episode_index=ep, file_size_mb=1.0,
+                duration_sec=1.0, resolution_w=1, resolution_h=1,
+                status="completed", started_at="t0", finished_at="t1"))
+        check(len(rr.RecordingRepo.list_all()) == 4, "造 4 行（两组同目录）")
+        check(rr.RecordingRepo.delete_local_episode("/x/UMI_9_29",
+                                                    episode_index=7) == 1,
+              "delete_local_episode 精确删 1 行")
+        check(len(rr.RecordingRepo.list_all()) == 3, "只剩 3 行")
+        check(rr.RecordingRepo.delete_local_dir("/x/UMI_9_29/") == 2,
+              "delete_local_dir 归一化尾斜杠后删 2 行")
+        left = [r.file_path for r in rr.RecordingRepo.list_all()]
+        check(left == ["/x/other"], f"别的任务的行没被牵连: {left}")
+        check(rr.RecordingRepo.delete_local_dir("") == 0, "空路径删 0 行")
+    finally:
+        db.close()
+        rr.db = None
+
+
+def main():
+    root = tempfile.mkdtemp(prefix="local_delete_")
+    try:
+        test_pooled_true_delete(root)
+        test_honest_failure(root)
+        test_legacy_dir(root)
+        test_repo_true_delete(root)
+    finally:
+        shutil.rmtree(root, ignore_errors=True)
+    print()
+    if FAILS:
+        print(f"FAIL: {len(FAILS)} 项未通过")
+        return 1
+    print("PASS: 真删除（文件 + 录制行）测试全部通过")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

collector/tools/tests/test_pose_guard_limits.py

@@ -0,0 +1,289 @@
+"""位姿连续性门的门槛单测（v1.3.14）。
+
+`process_controller._publish_pose` 前的那道门（`protocol.pose_rejection_reason`）
+和 native 桥里的同门（`fayssense_orb_slam.cc` 的 `kPoseStepAllowanceM` 一族）
+是**同一个判据的两份实现**，谁动谁都得同步。历史上没测试钉过它们，于是
+「60ms 帧把限值抬到 0.23m」这个洞一直是靠肉眼发现——直到 2026-10-12 它在
+真机上放行了一次 0.224m 的平移跳变，GUI 里就是那个「抖/飘」。
+
+这里钉三件事：
+  ① 两处常量必须逐字相等（防镜像漂移）；
+  ② 实测包络：69061 条发布位姿里，**真实**单帧步长最大 0.0601m（p99 0.043）、
+     最小异常步长 0.1075m —— 限值必须夹在中间，且在降采样 60ms 帧上不变；
+  ③ 门给出的 reason 文本仍然区分 平移跳/旋转跳/时间戳回退/非法分量。
+
+实测来源：logging 里的 `[SLAM] Pose held:` 与 native `[POSE_REBASE]`，
+以及 logs/slam_native/20261012_*_3500000262300100_slam_stdout.log 的
+A/B 分支交替段（同一四元数、仅平移在两组之间来回）。
+
+用法:
+    venv/bin/python tools/tests/test_pose_guard_limits.py
+"""
+import math
+import os
+import re
+import sys
+
+ROOT = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+sys.path.insert(0, ROOT)
+
+from core.gripper.slam import protocol as proto  # noqa: E402
+
+NATIVE_CC = os.path.join(
+    ROOT,
+    "core/gripper/orb_slam_src/ORB-SLAM/Examples/fays/fayssense_orb_slam.cc",
+)
+
+# 实测包络（见模块 docstring）。
+GENUINE_MAX_STEP_M = 0.0601        # 真实单帧平移步长上限
+GENUINE_P99_STEP_M = 0.0430
+ARTIFACT_MIN_STEP_M = 0.1075       # 最小的一次估计器平移跳变
+ARTIFACT_MAX_STEP_M = 0.2238       # 旧的 60ms 限值下被原样放行的那一档
+GENUINE_MAX_ROT_DEG = 15.75
+ARTIFACT_ROT_DEG = 83.405502       # main.log 2026-10-12 14:25:51 rotation_jump
+
+FAILS = []
+
+
+def check(cond, msg):
+    if cond:
+        print(f"  PASS: {msg}")
+    else:
+        print(f"  FAIL: {msg}")
+        FAILS.append(msg)
+
+
+def quat_about_x(deg):
+    half = math.radians(deg) / 2.0
+    return (math.cos(half), math.sin(half), 0.0, 0.0)
+
+
+def pose(position, timestamp, rotation=(1.0, 0.0, 0.0, 0.0)):
+    return proto.PoseSample(
+        position=tuple(position), rotation=tuple(rotation),
+        timestamp=timestamp, sequence=1,
+    )
+
+
+def step(distance_m, dt_s, base=(0.0, 0.0, 0.0), rot=(1.0, 0.0, 0.0, 0.0)):
+    """沿 +x 走 distance_m，间隔 dt_s，返回 (reason, previous, current)。"""
+    prev = pose(base, 1000.0)
+    cur = pose(
+        (base[0] + distance_m, base[1], base[2]), 1000.0 + dt_s, rotation=rot)
+    return proto.pose_rejection_reason(cur, prev), prev, cur
+
+
+def test_constants_mirror():
+    """① native 与 Python 的门槛必须逐字相等。"""
+    if not os.path.exists(NATIVE_CC):
+        check(False, f"找不到 native 源文件 {NATIVE_CC}（镜像检查无法进行）")
+        return
+    with open(NATIVE_CC, encoding="utf-8") as fh:
+        src = fh.read()
+
+    def native(name):
+        m = re.search(rf"{name}\s*=\s*(-?[\d.]+)f?\s*;", src)
+        return float(m.group(1)) if m else None
+
+    def native_degrees(name):
+        """角度常量在 native 里写成 `20.0f * M_PI / 180.0f`，取度数那一项。"""
+        m = re.search(rf"{name}\s*=\s*(-?[\d.]+)f?\s*\*\s*static_cast", src)
+        if m is None:
+            m = re.search(rf"{name}\s*=\s*(-?[\d.]+)f?\s*\*\s*M_PI", src)
+        return float(m.group(1)) if m else None
+
+    pairs = (
+        ("kPoseStepAllowanceM", "POSE_STEP_ALLOWANCE_M"),
+        ("kPoseMaxLinearSpeedMps", "POSE_MAX_LINEAR_SPEED_MPS"),
+        ("kPoseMaxGuardIntervalS", "POSE_MAX_GUARD_INTERVAL_S"),
+    )
+    for native_name, py_name in pairs:
+        nv = native(native_name)
+        pv = getattr(proto, py_name)
+        check(
+            nv is not None and abs(nv - pv) < 1e-12,
+            f"{native_name}={nv} 与 {py_name}={pv} 一致",
+        )
+
+    deg_native = native_degrees("kPoseAngleAllowanceRad")
+    check(
+        deg_native is not None
+        and abs(math.radians(deg_native) - proto.POSE_ANGLE_ALLOWANCE_RAD) < 1e-12,
+        f"kPoseAngleAllowanceRad（{deg_native}°）与 POSE_ANGLE_ALLOWANCE_RAD 一致",
+    )
+    speed_native = native_degrees("kPoseMaxAngularSpeedRadS")
+    check(
+        speed_native is not None
+        and abs(math.radians(speed_native) - proto.POSE_MAX_ANGULAR_SPEED_RAD_S) < 1e-12,
+        f"kPoseMaxAngularSpeedRadS（{speed_native}°/s）"
+        "与 POSE_MAX_ANGULAR_SPEED_RAD_S 一致",
+    )
+
+
+def test_genuine_steps_accepted():
+    """② 真实步长（含 p99）在任何帧间隔下都必须放行。"""
+    for dt in (0.02, 0.06):
+        for dist in (GENUINE_P99_STEP_M, GENUINE_MAX_STEP_M):
+            reason, _, _ = step(dist, dt)
+            check(
+                reason is None,
+                f"真实步长 {dist:.4f}m @ dt={dt:.2f}s 被放行（reason={reason}）",
+            )
+    # 静止时的估计器微调也是真实数据的一部分，不能被误伤。
+    reason, _, _ = step(0.0, 0.06)
+    check(reason is None, "零位移 @ dt=0.06s 被放行")
+
+
+def test_artifacts_rejected_at_every_interval():
+    """② 估计器平移跳变在 20ms 和 60ms 帧上都必须被拦下。
+
+    修的就是这条：旧门槛 charge 了 60ms，限值 0.23m，把 0.107-0.224m
+    原样放了出去。降采样帧不该享有 3 倍宽限——跳变恰好落在那一帧上。
+    """
+    for dt in (0.02, 0.04, 0.06):
+        for dist in (ARTIFACT_MIN_STEP_M, ARTIFACT_MAX_STEP_M):
+            reason, prev, cur = step(dist, dt)
+            check(
+                reason is not None and "translation step" in reason,
+                f"跳变 {dist:.4f}m @ dt={dt:.2f}s 被拦下（reason={reason}）",
+            )
+        limit = proto.POSE_STEP_ALLOWANCE_M + (
+            proto.POSE_MAX_LINEAR_SPEED_MPS * min(
+                dt, proto.POSE_MAX_GUARD_INTERVAL_S)
+        )
+        check(
+            limit < ARTIFACT_MIN_STEP_M,
+            f"dt={dt:.2f}s 的限值 {limit:.4f}m 低于最小跳变 "
+            f"{ARTIFACT_MIN_STEP_M:.4f}m",
+        )
+        check(
+            limit > GENUINE_MAX_STEP_M,
+            f"dt={dt:.2f}s 的限值 {limit:.4f}m 高于最大真实步长 "
+            f"{GENUINE_MAX_STEP_M:.4f}m",
+        )
+
+
+def test_interval_cap_removes_decimation_inflation():
+    """② 限值不再随 60ms 降采样帧膨胀——这是修复的本质。
+
+    限值对 dt 仍是线性的（正常：帧隔得久，允许走得远），但只线性到
+    名义帧周期为止。修复前它一直线性到 0.1s，于是 60ms 帧拿到 0.23m——
+    而跳变恰好落在那一帧上。现在 60ms 帧与 30ms 帧同额。
+    """
+    def limit(dt):
+        return (
+            proto.POSE_STEP_ALLOWANCE_M
+            + proto.POSE_MAX_LINEAR_SPEED_MPS
+            * min(dt, proto.POSE_MAX_GUARD_INTERVAL_S)
+        )
+
+    cap = proto.POSE_MAX_GUARD_INTERVAL_S
+    check(
+        cap <= 0.04,
+        f"间隔上限 {cap}s 不超过名义帧周期量级（20/20/60ms 的 60ms）",
+    )
+    check(
+        limit(0.06) == limit(cap) == limit(0.5),
+        f"60ms 及更长的帧与 {cap * 1000:.0f}ms 帧同额"
+        f"（限值 {limit(0.06):.4f}m，旧门槛这里是 0.2300m）",
+    )
+    check(
+        limit(0.02) < limit(0.06),
+        f"20ms 帧仍比 60ms 帧严（{limit(0.02):.4f}m < {limit(0.06):.4f}m），"
+        "即限值随真实帧间隔单调、不是常数",
+    )
+    check(
+        limit(0.06) < ARTIFACT_MIN_STEP_M,
+        f"最宽的 60ms 档限值 {limit(0.06):.4f}m 仍低于最小跳变 "
+        f"{ARTIFACT_MIN_STEP_M:.4f}m",
+    )
+
+
+def test_rotation_steps():
+    """② 真实旋转步长放行，83° 的旋转跳变拦下。"""
+    limit_60 = proto.POSE_ANGLE_ALLOWANCE_RAD + (
+        proto.POSE_MAX_ANGULAR_SPEED_RAD_S
+        * min(0.06, proto.POSE_MAX_GUARD_INTERVAL_S)
+    )
+    check(
+        math.degrees(limit_60) > GENUINE_MAX_ROT_DEG * 2.0,
+        f"dt=0.06s 的旋转限值 {math.degrees(limit_60):.1f}° 仍是最大真实旋转步长"
+        f" {GENUINE_MAX_ROT_DEG}° 的 2 倍以上余量",
+    )
+    for dt in (0.02, 0.06):
+        reason, _, _ = step(0.0, dt, rot=quat_about_x(GENUINE_MAX_ROT_DEG))
+        check(
+            reason is None,
+            f"真实旋转步长 {GENUINE_MAX_ROT_DEG}° @ dt={dt:.2f}s 被放行",
+        )
+        reason, _, _ = step(0.0, dt, rot=quat_about_x(ARTIFACT_ROT_DEG))
+        check(
+            reason is not None and "rotation step" in reason,
+            f"旋转跳变 {ARTIFACT_ROT_DEG}° @ dt={dt:.2f}s 被拦下"
+            f"（reason={reason}）",
+        )
+
+
+def test_reason_taxonomy():
+    """③ reason 文本仍然区分四类，且优先级不变（时间戳先于跳变）。"""
+    prev = pose((0.0, 0.0, 0.0), 1000.0)
+
+    cur = pose((1.0, 0.0, 0.0), 1000.0 + 0.02)
+    check(
+        proto.pose_rejection_reason(cur, prev) ==
+        "translation step 1.000m exceeds 0.070m",
+        "平移跳的 reason 文本与数值格式未变",
+    )
+
+    cur = pose((0.0, 0.0, 0.0), 1000.0)
+    check(
+        proto.pose_rejection_reason(cur, prev) ==
+        "non-monotonic pose timestamp",
+        "时间戳回退的 reason 未变",
+    )
+
+    cur = pose((0.0, 0.0, float("nan")), 1000.0 + 0.02)
+    check(
+        proto.pose_rejection_reason(cur, prev) == "invalid pose components",
+        "非法分量的 reason 未变",
+    )
+
+    check(
+        proto.pose_rejection_reason(prev, None) is None,
+        "无前帧时不设限（会话首帧必须放行）",
+    )
+
+    # 时间戳回退优先于平移跳：先判时间基，再判步长。
+    cur = pose((1.0, 0.0, 0.0), 1000.0)
+    check(
+        proto.pose_rejection_reason(cur, prev) ==
+        "non-monotonic pose timestamp",
+        "时间戳回退优先于平移跳报出",
+    )
+
+
+def main():
+    print("位姿门门槛单测（v1.3.14）")
+    print("[1] 常量镜像（native ⇄ Python）")
+    test_constants_mirror()
+    print("[2] 实测包络")
+    test_genuine_steps_accepted()
+    test_artifacts_rejected_at_every_interval()
+    test_interval_cap_removes_decimation_inflation()
+    test_rotation_steps()
+    print("[3] reason 分类")
+    test_reason_taxonomy()
+
+    if FAILS:
+        print(f"\nFAIL: {len(FAILS)} 条")
+        for f in FAILS:
+            print("  -", f)
+        return 1
+    print(
+        "\nPASS: 门槛夹在实测包络中间（真实 ≤0.0601m 放行 / 异常 ≥0.1075m 拦下），"
+        "限值不再随 20/20/60ms 降采样帧膨胀，native 与 Python 逐字一致")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

collector/tools/tests/test_pose_publish_deadband.py

@@ -0,0 +1,272 @@
+"""发布位姿死区（最小可报告位移）单测（v1.3.14）。
+
+用户报的「大幅漂移没了，但静止时轨迹线/末端点还有小抖」= 估计器的毫米级游走。
+实测（69061 条发布位姿 / 20 个会话，见 protocol.POSE_PUBLISH_DEADBAND_M 注释）：
+静止段位置游走半径逐会话 p50 1.06-1.85mm、max 1.39-4.98mm（严格口径：
+10s 窗净位移<2mm **且**窗内每点距窗中位<5mm）。默认视野 327px/m 下看不出来，放大
+4-10× 就是 3-10px 的连续抖动。
+
+这里钉住四件事：
+  ① 死区是**对上次发布值的累积位移**，不是相邻样本差 —— 静止游走必须被冻住，
+     而真实慢速移动（每帧都不到死区）必须照常推进；这是它与跳变门的分别。
+  ② 保持时**发布上次的值**（不是不发布）：采样节拍/时间戳不变，轨迹不再加噪。
+  ③ 死区不得吃掉真实运动：单帧 ≥3mm 的位移一律照发（最快的手动速度也不受影响）。
+  ④ 会话首帧 / 重设原点后（参照为 None）必须放行。
+
+用法:
+    venv/bin/python tools/tests/test_pose_publish_deadband.py
+"""
+import glob
+import math
+import os
+import random
+import sys
+
+ROOT = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+sys.path.insert(0, ROOT)
+
+from core.gripper.slam import protocol as proto  # noqa: E402
+
+EPS = proto.POSE_PUBLISH_DEADBAND_M
+FAILS = []
+
+
+def check(cond, msg):
+    if cond:
+        print(f"  PASS: {msg}")
+    else:
+        print(f"  FAIL: {msg}")
+        FAILS.append(msg)
+
+
+def publish_stream(positions, epsilon=EPS):
+    """按发布点语义跑一遍：返回 (发布值序列, 是否保持的掩码)。"""
+    out, held, ref = [], [], None
+    for p in positions:
+        if proto.pose_below_deadband(p, ref, epsilon):
+            out.append(ref)
+            held.append(True)
+        else:
+            ref = p
+            out.append(p)
+            held.append(False)
+    return out, held
+
+
+# ---------------------------------------------------------------- ① 语义
+
+def test_helper_semantics():
+    ref = (0.0, 0.0, 0.0)
+    check(
+        proto.pose_below_deadband((1.0, 2.0, 3.0), None) is False,
+        "参照为 None（首帧/重设原点）→ 放行",
+    )
+    check(
+        proto.pose_below_deadband((EPS * 0.5, 0.0, 0.0), ref) is True,
+        f"位移 {EPS/2*1000:.1f}mm < 死区 {EPS*1000:.0f}mm → 保持",
+    )
+    check(
+        proto.pose_below_deadband((EPS * 1.001, 0.0, 0.0), ref) is False,
+        f"位移稍超死区 → 放行（判据是 <，等于死区的真实位移不被吞）",
+    )
+    check(
+        proto.pose_below_deadband((0.0, 0.0, EPS * 2), ref) is False,
+        "沿单轴 2×死区 → 放行（三轴等权）",
+    )
+    check(
+        proto.pose_below_deadband(
+            (EPS * 0.6, EPS * 0.6, EPS * 0.6), ref) is False,
+        "三轴各 0.6×死区 → 合成 1.04×死区 → 放行（按欧氏距离，不逐轴判）",
+    )
+    check(
+        math.isclose(
+            proto.POSE_PUBLISH_DEADBAND_M, 0.003, abs_tol=1e-12),
+        f"死区常量 = {proto.POSE_PUBLISH_DEADBAND_M*1000:.1f}mm（实测值 3mm）",
+    )
+
+
+# ---------------------------------------------------------------- ② 静止游走
+
+def test_rest_wander_frozen():
+    """按实测统计量合成静止游走。
+
+    实测静止段是**有界的小球**而不是无界随机游走：每帧步长 p50≈0.14mm、
+    p99≈0.45mm，但 10s 窗内的游走半径只有 p50 1.06-1.85mm、max 1.39-4.98mm —— 即
+    高频来回（均值回复），不是越走越远。用 AR(1)（系数 0.96）复现这个形状：
+    步长与半径都对得上，纯随机游走会走到 10mm+，那就不是用户看到的抖了。
+    """
+    rng = random.Random(20261013)
+    a, sigma = 0.96, 0.00010
+    pos = [0.0, 0.0, 0.0]
+    positions = []
+    for _ in range(600):            # 20s @30fps
+        pos = [
+            a * pos[0] + rng.gauss(0.0, sigma),
+            a * pos[1] + rng.gauss(0.0, sigma),
+            a * pos[2] + rng.gauss(0.0, sigma),
+        ]
+        positions.append(tuple(pos))
+    steps = [math.dist(positions[i], positions[i - 1])
+             for i in range(1, len(positions))]
+    raw_radius = max(math.dist(p, (0.0, 0.0, 0.0)) for p in positions)
+    out, held = publish_stream(positions)
+    frozen = sum(1 for i, h in enumerate(held) if h and out[i] == out[max(0, i - 1)])
+    distinct = len({o for o in out})
+
+    check(
+        0.0005 < raw_radius < 0.004,
+        f"合成游走半径 {raw_radius*1000:.2f}mm 落在实测量级"
+        f"（逐会话 p50 1.06-1.85mm / max 1.39-4.98mm）",
+    )
+    check(
+        sorted(steps)[len(steps) // 2] < EPS,
+        f"合成每帧步长 p50 {sorted(steps)[len(steps)//2]*1000:.3f}mm < 死区"
+        "（单帧全部在死区之下 —— 这正是跳变门管不着的那类噪声）",
+    )
+    check(
+        sum(held) / len(held) > 0.95,
+        f"死区冻住�� {100*sum(held)/len(held):.1f}% 的帧（实测会话 99.8-100%）",
+    )
+    check(
+        distinct < 0.05 * len(positions),
+        f"600 帧静止只发出 {distinct} 个不同位置（<5%，原来 600 个各不相同）",
+    )
+    check(
+        frozen == sum(held),
+        "保持帧发布的确实是上一次的值（末端点不动，而不是发了别的值）",
+    )
+
+
+def test_slow_motion_still_advances():
+    """真实慢速移动：1mm/帧（≈3cm/s @30fps）必须照常前进，只是量化到死区。"""
+    positions = [(i * 0.001, 0.0, 0.0) for i in range(300)]
+    out, held = publish_stream(positions)
+    err = max(abs(out[i][0] - positions[i][0]) for i in range(len(positions)))
+    check(
+        abs(out[-1][0] - positions[-1][0]) < EPS,
+        f"300 帧后末端仍在真值 {EPS*1000:.0f}mm 内"
+        f"（走了 {out[-1][0]*1000:.1f}mm，真值 {positions[-1][0]*1000:.0f}mm）",
+    )
+    check(
+        err < EPS,
+        f"全程误差 {err*1000:.2f}mm < 死区（量化不累积）",
+    )
+    check(
+        sum(held) < 0.9 * len(held),
+        f"移动时确实在发新值（保持率 {100*sum(held)/len(held):.0f}%，"
+        "不是把运动也冻住）",
+    )
+    # 单调前进且在推：每 3 帧至少推进一次
+    advances = sum(
+        1 for i in range(1, len(out)) if out[i][0] > out[i - 1][0])
+    check(
+        advances >= 90,
+        f"单调推进 {advances} 次（300 帧里按死区每 3 帧推一次是下限）",
+    )
+
+
+# ---------------------------------------------------------------- ③ 不吃运动
+
+def test_real_motion_never_blocked():
+    """单帧位移 ≥ 死区一律照发 —— 最大实测真实单帧步长 0.0601m 也不例外。"""
+    for step in (EPS, 0.01, 0.0601, 0.1):
+        held = proto.pose_below_deadband((step, 0.0, 0.0), (0.0, 0.0, 0.0))
+        check(
+            held is False,
+            f"单帧 {step*1000:.1f}mm 位移照发（死区只压 <{EPS*1000:.0f}mm 的噪声）",
+        )
+    # 静止 10s 后突然快移：第一帧就该发出去，不因"冻久了"而迟滞
+    positions = [(0.0, 0.0, 0.0)] * 300 + [(0.05, 0.0, 0.0)]
+    out, held = publish_stream(positions)
+    check(
+        held[-1] is False and out[-1][0] == 0.05,
+        "静止后突然移动 50mm：第一帧立即发布（无迟滞）",
+    )
+
+
+# ---------------------------------------------------------------- ④ 真日志回放
+
+def test_replay_real_session():
+    """拿真会话回放：静止窗冻结率、全段误差、运动不丢。日志不在就跳过。"""
+    cands = sorted(glob.glob(os.path.join(
+        ROOT, "logs/slam_native/*_slam_stdout.log")))
+    picked = [p for p in cands
+              if "20261013_114841" in p] or cands[-1:]
+    if not picked:
+        print("  SKIP: 没有 logs/slam_native/*.log（本机数据不入库）")
+        return
+    path = picked[0]
+    positions = []
+    with open(path, encoding="utf-8", errors="replace") as fh:
+        for line in fh:
+            event = proto.parse_slam_line(line)
+            if event is not None and event.kind == "pose":
+                positions.append(tuple(event.payload.position))
+    if len(positions) < 300:
+        print(f"  SKIP: {os.path.basename(path)} 只有 {len(positions)} 条位姿")
+        return
+
+    # 静止窗用**净位移**独立判定（与死区的判据无关，避免自证）
+    W = 300
+    rest = [False] * len(positions)
+    for i in range(0, len(positions) - W, 30):
+        if math.dist(positions[i + W - 1], positions[i]) < 0.002:
+            for k in range(i, i + W):
+                rest[k] = True
+    out, held = publish_stream(positions)
+    held = list(held)
+    rest_hold = (sum(1 for i in range(len(held)) if rest[i] and held[i])
+                 / max(1, sum(rest)))
+    err = max(math.dist(out[i], positions[i]) for i in range(len(positions)))
+    raw_path = sum(math.dist(positions[i], positions[i - 1])
+                   for i in range(1, len(positions)))
+    pub_path = sum(math.dist(out[i], out[i - 1])
+                   for i in range(1, len(out)))
+
+    print(f"  （回放 {os.path.basename(path)}：{len(positions)} 条位姿，"
+          f"静止帧占 {100*sum(rest)/len(rest):.0f}%）")
+    check(
+        rest_hold > 0.95,
+        f"真会话静止窗冻结率 {100*rest_hold:.1f}% > 95%（下游末端点不再抖）",
+    )
+    check(
+        err < EPS + 1e-9,
+        f"全段发布误差 max {err*1000:.2f}mm < {EPS*1000:.0f}mm（量化不超死区）",
+    )
+    check(
+        pub_path < raw_path,
+        f"发布路径长 {pub_path:.3f}m < 原始 {raw_path:.3f}m"
+        f"（掉掉的 {100*(1-pub_path/raw_path):.0f}% 全是静止游走）",
+    )
+    check(
+        pub_path > 0.5 * raw_path,
+        f"发布路径长仍有原始的 {100*pub_path/raw_path:.0f}%（没把运动也削掉）",
+    )
+
+
+def main():
+    print("发布位姿死区单测（v1.3.14）")
+    print("[1] 语义（对上次发布值的累积位移 / None 放行 / 边界）")
+    test_helper_semantics()
+    print("[2] 静止游走必须冻住")
+    test_rest_wander_frozen()
+    print("[3] 真实慢速移动必须照常推进（量化不累积）")
+    test_slow_motion_still_advances()
+    print("[4] 不吃真实运动（无迟滞）")
+    test_real_motion_never_blocked()
+    print("[5] 真会话回放")
+    test_replay_real_session()
+
+    if FAILS:
+        print(f"\nFAIL: {len(FAILS)} 条")
+        for f in FAILS:
+            print("  -", f)
+        return 1
+    print(
+        f"\nPASS: 死区 {EPS*1000:.0f}mm 冻住静止游走（>95% 帧保持且保持的是上次的值），"
+        "真实移动照常推进且误差不超死区、无迟滞")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

collector/tools/tests/test_task_delete.py

@@ -0,0 +1,208 @@
+"""任务页「🗑 删除」= 真删除 测试（离屏 Qt，全部落在临时目录）。
+
+2026-10-12：任务删除从「只往 tasks.json 写 hidden（目录原样留着）」改成
+真删除——删掉该任务在本机的录制目录（含全部 episode 文件组）与库里的录制行，
+tasks.json 只留 hidden 墓碑（防后端刷新复活）。删不干净就如实报错且**不隐藏**
+任务（用户能重试）。
+
+用法:
+    QT_QPA_PLATFORM=offscreen venv/bin/python tools/tests/test_task_delete.py
+"""
+import json
+import os
+import shutil
+import sys
+import tempfile
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.dirname(
+    os.path.abspath(__file__)))))
+os.environ.setdefault("QT_QPA_PLATFORM", "offscreen")
+
+from PyQt5.QtWidgets import QApplication, QMessageBox
+
+from config import settings
+from core.database import Database
+from core.egodata_writer import _atomic_write_parquet, _episode_rows_table
+from core.helpers import pooled_data_parquet_path, pooled_episodes_path
+from core.recording_record import RecordingRecord
+import core.task_record as task_record
+import ui.task_page as task_page_mod
+from ui.task_page import TaskSelectionPage as TaskPage
+
+FAILS = []
+TASK_NAME = "Del_Test/1"
+TASK_ID = "tid-del-1"
+
+
+def check(cond, msg):
+    print(f"  {'PASS' if cond else 'FAIL'}: {msg}")
+    if not cond:
+        FAILS.append(msg)
+
+
+class FakeMB:
+    """QMessageBox 替身：记录弹窗文本，question 恒答 Yes。"""
+
+    Yes, No = QMessageBox.Yes, QMessageBox.No
+    calls = []
+
+    @staticmethod
+    def question(*a, **k):
+        FakeMB.calls.append(("question", a[2] if len(a) > 2 else ""))
+        return QMessageBox.Yes
+
+    @staticmethod
+    def warning(*a, **k):
+        FakeMB.calls.append(("warning", a[2] if len(a) > 2 else ""))
+
+    @staticmethod
+    def information(*a, **k):
+        FakeMB.calls.append(("information", a[2] if len(a) > 2 else ""))
+
+
+def make_episode(task_dir: str, file_no: int):
+    n = file_no + 1
+    d = os.path.join(task_dir, "data", "chunk-000")
+    os.makedirs(d, exist_ok=True)
+    with open(os.path.join(d, f"episode-{file_no:03d}.parquet"), "wb") as f:
+        f.write(b"data")
+    v = os.path.join(task_dir, "videos", "chunk-000", "d435_rgb")
+    os.makedirs(v, exist_ok=True)
+    with open(os.path.join(v, f"episode-{file_no:03d}.mp4"), "wb") as f:
+        f.write(b"video")
+    ep_path = pooled_episodes_path(task_dir, n)
+    os.makedirs(os.path.dirname(ep_path), exist_ok=True)
+    _atomic_write_parquet(
+        _episode_rows_table([{"episode_index": n, "task_name": TASK_NAME}]),
+        ep_path)
+
+
+def seed_db(db, task_dir):
+    for i, ep in enumerate((1, 2)):
+        db.conn.execute(
+            """INSERT OR REPLACE INTO recording
+               (id, camera_index, camera_name, file_path, episode_index,
+                file_size_mb, duration_sec, resolution_w, resolution_h,
+                status, started_at, finished_at)
+               VALUES (?,?,?,?,?,?,?,?,?,?,?,?)""",
+            (f"r{i}", 0, "cam", task_dir, ep, 1.0, 1.0, 1, 1,
+             "completed", "t0", "t1"))
+    db.conn.commit()
+
+
+def write_tasks(tasks_file: str, hidden: bool = False, name: str = TASK_NAME):
+    """写单任务 tasks.json（用例 2 要先把用例 1 的墓碑复原）。"""
+    task = {"id": TASK_ID, "name": name, "status": "in_progress",
+            "total_required": 10, "local_count": 2, "synced_count": 2,
+            "backend_count": 0}
+    if hidden:
+        task["hidden"] = True
+    with open(tasks_file, "w", encoding="utf-8") as f:
+        json.dump({"tasks": [task], "updated_at": "2026-10-12T00:00:00"}, f)
+
+
+def setup(root: str):
+    """临时 tasks.json / RECORDING_DIR / DB 全部指到 root 下。"""
+    data_dir = os.path.join(root, "data")
+    rec_dir = os.path.join(root, "recordings")
+    os.makedirs(data_dir, exist_ok=True)
+    os.makedirs(rec_dir, exist_ok=True)
+    tasks_file = os.path.join(data_dir, "tasks.json")
+    write_tasks(tasks_file)
+    task_record._TASKS_FILE = tasks_file
+    settings.RECORDING_DIR = rec_dir
+    db = Database(db_path=os.path.join(root, "test.db"))
+    db.init_schema()
+    import core.recording_repository as rr
+    rr.db = db
+    return rec_dir, tasks_file, db
+
+
+def hidden_in_file(tasks_file: str) -> bool:
+    with open(tasks_file, encoding="utf-8") as f:
+        tasks = json.load(f)["tasks"]
+    return any(t.get("id") == TASK_ID and t.get("hidden") for t in tasks)
+
+
+def main():
+    root = tempfile.mkdtemp(prefix="task_delete_")
+    app = QApplication(sys.argv)
+    real_mb = task_page_mod.QMessageBox
+    task_page_mod.QMessageBox = FakeMB
+    db = None
+    try:
+        rec_dir, tasks_file, db = setup(root)
+        task_dir = os.path.join(rec_dir, "Del_Test_1")
+        make_episode(task_dir, 0)
+        make_episode(task_dir, 1)
+        seed_db(db, task_dir)
+
+        print("── 1. 真删除任务：目录 + 录制行 + 墓碑 ──")
+        page = TaskPage()
+        page._table.setCurrentCell(0, 0)
+        page._do_delete_task()
+        check(not os.path.isdir(task_dir), "录制目录真的被删除")
+        check(not os.path.exists(pooled_data_parquet_path(task_dir, 1)),
+              "episode 文件组一并删除")
+        check(len(db.conn.execute("SELECT 1 FROM recording").fetchall()) == 0,
+              "该任务的录制行真删（不留痕迹行）")
+        check(hidden_in_file(tasks_file), "tasks.json 保留 hidden 墓碑")
+        check(all(t.get("id") != TASK_ID for t in page._tasks),
+              "任务从列表消失")
+        check(FakeMB.calls and FakeMB.calls[0][0] == "question",
+              "删除前有二次确认")
+        qtext = FakeMB.calls[0][1]
+        check("Del_Test_1" in qtext and "2 个片段" in qtext,
+              f"确认框写明要删的目录与片段数: {qtext!r}")
+
+        print("── 2. 删不干净：如实报错且不隐藏任务 ──")
+        FakeMB.calls.clear()
+        write_tasks(tasks_file)           # 复原墓碑，让任务重新出现在列表
+        task_dir2 = os.path.join(rec_dir, "Del_Test_1")
+        make_episode(task_dir2, 0)
+        os.chmod(rec_dir, 0o500)          # 根目录不可写 → rmtree 失败
+        try:
+            page2 = TaskPage()
+            check(len(page2._tasks) == 1, "任务已复原到列表（用例前提）")
+            page2._table.setCurrentCell(0, 0)
+            page2._do_delete_task()
+        finally:
+            os.chmod(rec_dir, 0o755)
+        check(os.path.isdir(task_dir2), "删除失败时目录还在（没装作删掉了）")
+        check(any(k == "warning" for k, _ in FakeMB.calls),
+              "失败有弹窗提示")
+        check(not hidden_in_file(tasks_file),
+              "失败时任务不隐藏（仍可重试）")
+
+        print("── 3. 纯空白任务名：拒绝删除，绝不 rmtree 到 RECORDING_DIR ──")
+        # _sanitize_tag("   ") 返回空串 → task_dir_of 退化成 RECORDING_DIR 本身，
+        # 不拦就会把**所有任务**的录制一起删掉。
+        FakeMB.calls.clear()
+        write_tasks(tasks_file, name="   ")
+        decoy = os.path.join(rec_dir, "Other_Task")
+        make_episode(decoy, 0)
+        page3 = TaskPage()
+        check(len(page3._tasks) == 1, "空白名任务在列表里（用例前提）")
+        page3._table.setCurrentCell(0, 0)
+        page3._do_delete_task()
+        check(os.path.isdir(decoy) and os.path.isdir(rec_dir),
+              "录制根目录与别的任务原样都在（没被整根 rmtree）")
+        check(any(k == "warning" and "拒绝删除" in str(t)
+                  for k, t in FakeMB.calls), "拒绝删除有弹窗提示")
+        check(not hidden_in_file(tasks_file), "拒绝时任务不隐藏")
+    finally:
+        task_page_mod.QMessageBox = real_mb
+        if db is not None:
+            db.close()
+        shutil.rmtree(root, ignore_errors=True)
+
+    print()
+    if FAILS:
+        print(f"FAIL: {len(FAILS)} 项未通过")
+        return 1
+    print("PASS: 任务删除真删除测试全部通过")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

collector/ui/device_panel.py

@@ -71,8 +71,15 @@ class DevicePanel(QWidget):
         self._refresh_hint = QLabel(tr("双击设备可重命名"))
         self._refresh_hint.setStyleSheet(
             f"color:{settings.COLOR_TEXT_HINT}; font-size:10px;")
+        # 必须换行：不换行的 QLabel 其 minimumSizeHint 就是整行文字宽
+        # （中文 + 夹爪在场时这句长达 289px），会成为面板/停靠栏的硬地板，
+        # 栏宽只能越拖越宽、拖不小（2026-10-13）。
+        self._refresh_hint.setWordWrap(True)
         layout.addWidget(self._refresh_hint)
 
+        # 允许被拖到很窄（一行图标 + 勾选框）；实际下限口径见 settings
+        self.setMinimumWidth(settings.DEVICE_DOCK_MIN_WIDTH)
+
         self._items: dict = {}            # device key → QTreeWidgetItem
         self._last_check: dict = {}       # device key → 上次勾选状态（挡文字类变化）
         self._group_expanded = {"camera": True, "glove": True,

collector/ui/lite_window.py

@@ -22,8 +22,6 @@ tools/tests/lite_import_guard_test.py 断言守护。
 from __future__ import annotations
 import glob
 import os
-import re
-import shutil
 import threading
 import time
 from typing import List, Optional
@@ -56,7 +54,8 @@ from core.encoder_probe import list_working_ffmpegs
 from core.gripper_codec import (describe_gripper_matrix_spec,
                                encode_gripper_force_matrix,
                                encode_gripper_force_matrix_array)
-from core.helpers import delete_pooled_episode, format_duration
+from core.helpers import (delete_local_session, episode_file_suffix,
+                          format_duration, list_task_episodes)
 from core.pipeline import CameraPipeline, frame_drop_total
 from core.uploader import UploadManager
 
@@ -1485,14 +1484,25 @@ class LiteWindow(QMainWindow):
         settings.UPLOAD_DELETE_AFTER = bool(on)
 
     def _episode_max(self, task_dir: str) -> int:
-        """任务目录内已录制的最大 episode 号（0 = 无 parquet，按整目录上传）。"""
-        best = 0
-        for p in glob.glob(os.path.join(task_dir, "data", "chunk-*",
-                                        "episode-*.parquet")):
-            m = re.search(r"episode-(\d+)\.parquet$", os.path.basename(p))
-            if m:
-                best = max(best, int(m.group(1)))
-        return best
+        """任务目录内最新一段的**全局 episode 号 N（1 基）**（0 = 无 parquet，
+        按整目录上传）。
+
+        文件名是 `episode-<f>.parquet`，f 是 **chunk 内**的 0 基文件号：每
+        chunk 1000 段（`data/chunk-{c:03d}/`），chunk-000 装满 1000 段后开
+        chunk-001 并从 `episode-000` 重新计数（`episode_chunk_file(N)` 给出
+        (c, f)）。所以「最大的文件名 f」既不是 N、也不能靠 +1 换算：**f 每过
+        1000 就回绕**，`int(f)+1` 在 chunk-001 出现后会返回一个**真实存在**的
+        错段（例：N=1001 时 f=000 ⇒ 得 1，指向 chunk-000/episode-000）。
+        全局号统一由 `list_task_episodes` 还原（`chunk*1000 + f + 1`）——它与
+        上传器、`UploadManager` 的 (path, episode_index) 防重键、
+        `delete_local_session` 同一口径，也与本文件自动上传路径传的
+        `pipeline.last_episode_index` 一致。
+        """
+        if not glob.glob(os.path.join(task_dir, "data", "chunk-*",
+                                      "episode-*.parquet")):
+            return 0          # 旧格式/空目录：按整目录上传
+        episodes = list_task_episodes(task_dir)
+        return episodes[-1] if episodes else 0
 
     def _refresh_upload_list(self):
         """待上传列表 = data/recordings 下的任务目录 + 上传状态。"""
@@ -1559,11 +1569,26 @@ class LiteWindow(QMainWindow):
         self._upload_progress.setValue(0)
 
     def _delete_after_upload(self, session_path: str, episode_index: int):
-        """后台删除本地会话（ep>0 只删该 episode 文件组，否则整目录）。"""
+        """后台真删除本地上传件（含删除校验）；失败写日志，不谎报成功。
+
+        episode_index 就是上传时用的那个号（手动列表是 `_episode_max` 的
+        返回值、自动上传是 `pipeline.last_episode_index`，两者都是**全局
+        episode 号 N（1 基）**），原样透传给 delete_local_session —— 删的必须
+        恰好是刚上传的那一段，所以这里**不能再加工**（上传器按 N 取文件，
+        多 +1 会指向 N+1：既删错段，又因为那一段本就不存在而「顺利返回
+        True」，界面报成功、文件还在）。目录里没有池化 parquet 时（旧格式/
+        空目录）按整目录删。
+        """
+        has_parquet = bool(glob.glob(os.path.join(
+            session_path, "data", "chunk-*", "episode-*.parquet")))
+        n = episode_index if has_parquet else 0
+        ok, err = delete_local_session(session_path, n)
+        if ok:
+            return
+        name = os.path.basename(session_path)
         if episode_index > 0:
-            delete_pooled_episode(session_path, episode_index)
-        elif os.path.isdir(session_path):
-            shutil.rmtree(session_path, ignore_errors=True)
+            name = f"{name}_ep{episode_file_suffix(episode_index):06d}"
+        self._log(tr("[错误] 上传后自动删除失败: {}", f"{name} ({err})"))
 
     def _on_upload_failed(self, task_id: str, error: str):
         pair = self._upload_task_map.pop(task_id, ("", 0))

collector/ui/main_window.py

@@ -16,7 +16,7 @@ from datetime import datetime
 import cv2
 import numpy as np
 
-from PyQt5.QtCore import Qt, QTimer, pyqtSignal, QThread, QSettings
+from PyQt5.QtCore import Qt, QTimer, pyqtSignal, QThread, QSettings, QEvent
 from PyQt5.QtGui import QFont, QColor, QPixmap
 from PyQt5.QtWidgets import (
     QMainWindow, QWidget, QVBoxLayout, QDockWidget, QTextEdit,
@@ -58,7 +58,6 @@ _RESUME_SKIP_TEXT = {
 
 # 双目相机 —— 子进程/管道/曝光/抽帧口径已入 core/s80m_manager；
 # 路径常量 re-export 供本窗口可用性检查与离线测试 patch
-import shutil
 from core.s80m_manager import (
     S80MDeviceManager, frame_record_decision, s80m_depth_available,
     s80m_drop_watch, STEREO_DROP_ALERT_RATE,
@@ -201,6 +200,14 @@ class MainWindow(QMainWindow):
         self._last_device_keys: dict = {}       # key → 标签（插拔 diff 日志）
         self._last_device_kinds: dict = {}      # key → kind（蓝牙刷屏过滤）
 
+        # ── 设备检测栏（左侧停靠面板）显示偏好 ────────
+        # user_hidden：用户主动收起（标题栏 × / 视图▸设备检测栏）；任务选择页
+        # 隐藏是页面行为，不算收起。width：栏宽，由 eventFilter 跟随实际 resize。
+        # 二者随 closeEvent / 收起动作持久化到 server_config.json。
+        self._device_dock_user_hidden = False
+        self._device_dock_width = settings.DEVICE_DOCK_DEFAULT_WIDTH
+        self._device_dock_syncing = False        # 程序化改可见性时置位（挡误判为用户收起）
+
         # ── 实时 FPS 显示（D435/S80M 无 CameraWorker 测量，主窗口统一计数）──
         self._fps_ring: dict = {}   # slot_id → deque(帧到达时刻, monotonic 秒)
         self._fps_timer = QTimer(self)
@@ -379,11 +386,20 @@ class MainWindow(QMainWindow):
             self._on_gripper_diagnostics_done)
         self._device_dock = QDockWidget(tr("📷 设备检测"), self)
         self._device_dock.setWidget(self._device_panel)
+        # Closable = 标题栏出 × 按钮，点它就是「隐藏设备栏」；恢复入口是
+        # 视图▸设备检测栏 / Ctrl+D（见 _on_device_dock_visibility）。
         self._device_dock.setFeatures(
             QDockWidget.DockWidgetMovable | QDockWidget.DockWidgetFloatable
+            | QDockWidget.DockWidgetClosable
         )
         self.addDockWidget(Qt.LeftDockWidgetArea, self._device_dock)
-        self.resizeDocks([self._device_dock], [240], Qt.Horizontal)
+        # 栏宽与收起状态沿用上次（server_config.json），首次启动用默认宽度
+        prefs = settings.load_device_dock_prefs()
+        self._device_dock_width = prefs["width"]
+        self._device_dock_user_hidden = not prefs["visible"]
+        self._device_dock.installEventFilter(self)   # 跟随实际宽度（拖窄后落盘）
+        self.resizeDocks([self._device_dock], [self._device_dock_width],
+                         Qt.Horizontal)
 
         # ── 状态栏 ────────────────────────────────────
         self._status_label = QLabel(tr("就绪"))
@@ -416,6 +432,19 @@ class MainWindow(QMainWindow):
         self._view_menu.addSeparator()
         self._reset_size_action = self._view_menu.addAction(
             tr("重置画面大小"), self._reset_camera_sizes)
+        # 设备检测栏（左侧停靠面板）显示开关：标题栏的 × 也能收起，收起后
+        # 只有这里 / Ctrl+D 能恢复，所以勾选状态要与实际可见性同步。
+        self._device_dock_action = self._view_menu.addAction(
+            tr("设备检测栏"))
+        self._device_dock_action.setCheckable(True)
+        self._device_dock_action.setChecked(not self._device_dock_user_hidden)
+        self._device_dock_action.setShortcut("Ctrl+D")
+        self._device_dock_action.setToolTip(tr(
+            "显示/收起左侧设备检测栏（也可点它标题栏的 × 收起）"))
+        self._device_dock_action.triggered.connect(self._toggle_device_dock)
+        # 接线放在动作建好之后：× 收起时要同步勾选状态
+        self._device_dock.visibilityChanged.connect(
+            self._on_device_dock_visibility)
 
         # ── 语言菜单 ───────────────────────────────────
         self._lang_menu = mb.addMenu(tr("语言(&L)"))
@@ -767,7 +796,6 @@ class MainWindow(QMainWindow):
             self._log_dock.setVisible(False)
             self._history_dock.setVisible(False)
             # 设备检测面板：任务选择页隐藏 + 停轮询
-            self._device_dock.setVisible(False)
             self._device_timer.stop()
         else:
             # 数据采集页面 — 显示全部 UI
@@ -777,9 +805,11 @@ class MainWindow(QMainWindow):
             self._log_dock.setVisible(True)
             self._history_dock.setVisible(True)
             # 设备检测面板：采集页显示 + 立即扫描 + 周期轮询
-            self._device_dock.setVisible(True)
             self._device_scanner.request_scan()
             self._device_timer.start()
+        # 设备检测面板可见性：采集页显示、任务页隐藏，但用户主动收起过就保持
+        # 收起（否则每次切页都把用户收起来的栏弹回来）
+        self._apply_device_dock_visibility()
 
     def _go_back_to_task_selection(self):
         """从数据采集页面返回任务选择页面。"""
@@ -2973,6 +3003,9 @@ class MainWindow(QMainWindow):
         self._clear_log_action.setText(tr("清空日志"))
         self._refresh_history_action.setText(tr("刷新历史记录"))
         self._reset_size_action.setText(tr("重置画面大小"))
+        self._device_dock_action.setText(tr("设备检测栏"))
+        self._device_dock_action.setToolTip(tr(
+            "显示/收起左侧设备检测栏（也可点它标题栏的 × 收起）"))
 
         # ── 返回任务选择 ──────────────────────────
         self._back_to_task_action.setText(tr("返回任务选择"))
@@ -3048,6 +3081,74 @@ class MainWindow(QMainWindow):
         """重置所有分割条到等分状态。"""
         self.grid._rebuild_layout()
 
+    # ── 设备检测栏：显示 / 收起 / 宽度落盘 ───────────────
+
+    def eventFilter(self, obj, event):
+        """跟随设备栏的实际宽度（拖动分割条 → 记住，收起/退出时落盘）。"""
+        if obj is self._device_dock and event.type() == QEvent.Resize:
+            w = self._device_dock.width()
+            if w > 0:
+                self._device_dock_width = w
+        return super().eventFilter(obj, event)
+
+    def _apply_device_dock_visibility(self):
+        """按「当前页 + 用户是否收起」刷新设备栏可见性。
+
+        页面切换、菜单与 × 收起都走这一个入口，避免两处口径打架。
+        """
+        show = (self._page_stack.currentIndex() == 1
+                and not self._device_dock_user_hidden)
+        self._device_dock_syncing = True   # 程序化改动 → 不当作用户收起
+        try:
+            self._device_dock.setVisible(show)
+            if show:
+                # 隐藏期间改过窗口大小 / 首次显示时，Qt 给的宽度未必是保存值
+                self.resizeDocks([self._device_dock], [self._device_dock_width],
+                                 Qt.Horizontal)
+        finally:
+            self._device_dock_syncing = False
+        self._sync_device_dock_action()
+
+    def _toggle_device_dock(self, checked: bool):
+        """视图▸设备检测栏 / Ctrl+D：显示或收起设备栏（收起状态持久化）。
+
+        任务选择页收起只记偏好，回采集页才真正生效；反之在任务页点「显示」
+        也不会把设备栏拉到任务页上（那页本来就不显示采集专属 UI）。
+        """
+        self._device_dock_user_hidden = not checked
+        self._apply_device_dock_visibility()
+        self._save_device_dock_prefs()
+
+    def _on_device_dock_visibility(self, visible: bool):
+        """设备栏可见性变化（点标题栏 × 收起）→ 同步菜单勾选 + 记偏好。
+
+        页面切换与程序化改动期间 _device_dock_syncing=True，任务选择页的
+        隐藏也只是页面行为 —— 两者都不代表用户收起栏，直接返回。
+        """
+        if self._device_dock_syncing or self._page_stack.currentIndex() != 1:
+            return
+        self._device_dock_user_hidden = not visible
+        self._sync_device_dock_action()
+        self._save_device_dock_prefs()
+
+    def _sync_device_dock_action(self):
+        """菜单勾选 = 用户是否想看到设备栏（与当前页是否显示无关）。"""
+        action = getattr(self, "_device_dock_action", None)
+        if action is None:      # _setup_menu 之前的调用（构建期）
+            return
+        action.blockSignals(True)
+        action.setChecked(not self._device_dock_user_hidden)
+        action.blockSignals(False)
+
+    def _save_device_dock_prefs(self):
+        """把设备栏的收起状态与宽度写回 server_config.json。
+
+        宽度取 `_device_dock_width`（由 eventFilter 跟随每次 Resize），不用
+        `self._device_dock.width()` —— 收起瞬间读到的是收起前的旧几何。
+        """
+        settings.save_device_dock_prefs(not self._device_dock_user_hidden,
+                                        self._device_dock_width)
+
     # ═══════════════════════════════════════════════════
     #  状态栏刷新
     # ═══════════════════════════════════════════════════
@@ -3341,40 +3442,36 @@ class MainWindow(QMainWindow):
         """上传成功后删除本地会话目录（后台线程，防大目录阻塞 UI���。
 
         池化布局（episode_index > 0）只删该 episode 文件组
-        （delete_pooled_episode → 彻底删除，不走 _trash）。
-        结果经 _upload_session_deleted 信号回主线程：标记 recording 行、
+        （delete_local_session → 彻底删除 + 删除校验，不走 _trash）。
+        结果经 _upload_session_deleted 信号回主线程：真删 recording 行、
         刷新历史面板并记日志。手部关键点后处理持有的已打开视频句柄在
         Linux 下不受 unlink 影响，输出镜像在 keypoints_output/ 不受牵连。
         """
         def _worker():
-            err = ""
-            if episode_index > 0:
-                from core.helpers import delete_pooled_episode
-                delete_pooled_episode(session_path, episode_index)
-            elif not os.path.isdir(session_path):
-                err = "会话目录不存在"
-            else:
-                try:
-                    shutil.rmtree(session_path)
-                except OSError as e:
-                    err = str(e)
-            self._upload_session_deleted.emit(session_path, err,
+            from core.helpers import delete_local_session
+            ok, err = delete_local_session(session_path, episode_index)
+            self._upload_session_deleted.emit(session_path,
+                                              "" if ok else err,
                                               episode_index)
         threading.Thread(target=_worker, daemon=True,
                          name="upload-auto-delete").start()
 
     def _on_upload_session_deleted(self, session_path: str, err: str,
                                    episode_index: int = 0):
-        """后台删除完成（主线程）：recording 行标记已删并刷新历史。"""
+        """后台删除完成（主线程）：真删 recording 行并刷新历史。"""
         name = os.path.basename(session_path)
         if episode_index > 0:
             name = f"{name}_ep{episode_file_suffix(episode_index):06d}"
         if err:
             self._log(tr("[错误] 上传后自动删除失败: {}", f"{name} ({err})"))
             return
-        # 历史行保留（用户要求），状态标记"已上传，本地已删"
-        RecordingRepo.mark_uploaded_deleted(
-            session_path, episode_index=episode_index)
+        # 真删除：本地文件已删净 → 录制行一并删除（不留"已删除"痕迹行）
+        try:
+            RecordingRepo.delete_local_episode(
+                session_path, episode_index=episode_index)
+        except Exception as e:   # noqa: BLE001 — 文件已删净，记录删失败只提示
+            self._log(tr("[错误] 本地文件已删除，录制记录删除失败: {}",
+                         f"{name} ({e})"))
         self._refresh_history()
         self._log(tr("☁ 上传完成，本地文件已删除: {}", name))
 
@@ -3512,6 +3609,8 @@ class MainWindow(QMainWindow):
                 return
         self._shutting_down = True
         self._s80m_manager.shutting_down = True
+        # 记住设备栏的宽度与收起状态（下次启动保持）
+        self._save_device_dock_prefs()
         self._device_timer.stop()
         self._device_scanner.stop()
         if self._pipeline.is_recording:

collector/ui/playback_dialog.py

@@ -12,7 +12,6 @@
 import os
 import json
 import time
-import shutil
 import numpy as np
 import cv2
 from PyQt5.QtCore import Qt, QTimer, QPointF, QRectF
@@ -28,7 +27,7 @@ from config import settings
 from config.i18n import tr
 from core.helpers import (video_mp4_path, hand_kpts_parquet_path,
                           egodata_video_path, episode_video_files,
-                          episode_file_suffix, delete_pooled_episode)
+                          episode_file_suffix, delete_local_session)
 from ui.camera_widget import ZoomableVideoWidget
 from ui.camera_grid import CameraGrid, SPLITTER_HANDLE_WIDTH, SPLITTER_HANDLE_QSS
 from core.render_engine import (
@@ -607,36 +606,37 @@ class PlaybackDialog(QDialog):
             return
 
         from core.recording_repository import RecordingRepo
-        from core.uploader import UploadManager
         deleted = 0
+        failures = []
         for s in selected:
             episode_index = s.get("episode_index", 0)
-            if episode_index > 0:
-                # 池化布局：彻底删除该 episode 文件组
-                # （不触碰其他 episode 与任务级 meta）
-                ok = delete_pooled_episode(s["path"], episode_index)
-            else:
-                try:
-                    shutil.rmtree(s["path"])
-                    ok = True
-                except OSError:
-                    ok = False
-            if ok:
-                deleted += 1
-                # 成功上传过的会话 → 历史标「已上传，本地已删」（与自动上传
-                # 后删除口径一致）；未上传/上传失败 → 标「已删除，未上传」
-                try:
-                    if UploadManager.get_upload_status(
-                            s["path"], episode_index) == "completed":
-                        RecordingRepo.mark_uploaded_deleted(
-                            s["path"], episode_index=episode_index)
-                    else:
-                        RecordingRepo.mark_deleted(
-                            s["path"], episode_index=episode_index)
-                except Exception:
-                    pass
+            # 真删除：删净（含校验）后再删录制行；失败则原样列出，不谎报成功
+            ok, err = delete_local_session(s["path"], episode_index)
+            if not ok:
+                # episode_index == 0 是旧格式会话目录（整目录删除），别写成
+                # episode-000 那段
+                target = (f'episode-{episode_file_suffix(episode_index):03d}'
+                          if episode_index > 0 else tr("整个会话目录"))
+                failures.append(
+                    f'  {os.path.basename(s["path"])}/{target}: {err}')
+                continue
+            deleted += 1
+            try:
+                RecordingRepo.delete_local_episode(
+                    s["path"], episode_index=episode_index)
+            except Exception as e:   # noqa: BLE001 — 文件已删净，记录删失败只提示
+                failures.append(
+                    f'  {os.path.basename(s["path"])}: '
+                    f'{tr("文件已删除，录制记录删除失败")} ({e})')
 
         self._refresh_list()
+        if failures:
+            QMessageBox.warning(
+                self, tr("部分失败"),
+                tr("已删除 {}/{} 个会话，以下未能删净：\n\n{}",
+                   deleted, len(selected), "\n".join(failures)),
+            )
+            return
         QMessageBox.information(
             self, tr("完成"),
             tr("已永久删除 {}/{} 个会话。", deleted, len(selected)),

collector/ui/pose_view_qt.py

@@ -22,7 +22,8 @@ KSQ_GRIPPER_SLAM_FRAME 开关走），换帧或回落旧约定时逐字变化—
 published_frame 姿态那个右乘 Mᵀ），所以原点那一瞬发布姿态 = M·Mᵀ = 单位
 矩阵，这三支箭头与世界三箭头**重合**，标签写同样的 下/左/前。夹爪的**物理
 朝向**一点没变：_draw_gripper 用同一张 M（_BODY_RELABEL）把模型顶点从旧体轴
-坐标搬到新体轴坐标，position + R·(M·v) == position + R_旧·v，逐像素与改前
+坐标搬到新体轴坐标，position + R·(M·v) == position + R_旧·v（R_旧 = 改前那次
+**发布**的姿态，已含发布侧左乘的 M，不是夹爪的相对姿态 R_rel），逐像素与改前
 相同。★只改发布侧不改这里（或反过来）夹爪会被画歪 120°，两种改法各自都
 "看起来自洽"——别只动一处。
 """
@@ -85,6 +86,10 @@ CAM_AXES = (
 #
 # ★ 只换名字不动物理朝向：rotation 已经被发布侧右乘了 Mᵀ，这里再左乘一次 M，
 # 画出来 position + R·(M·v) == position + R_旧·v —— 逐点与换帧前相同。
+# ⚠ R_旧 指的是**改前那次发布的姿态**（= M·R_rel，里头已经含了发布侧那道左乘
+# M），不是夹爪自己的相对姿态 R_rel。拿 R_rel 去代会差一个 M、算出"夹爪歪了
+# 0.3–0.4m"的假警报 —— 这个坑我自己踩过一次（两处都改时残差只在浮点噪声量级，
+# 只改一半就是 0.3–0.4m 的实偏差）。
 # 两处必须同进同退：只改发布侧不改这里、或只改这里不改发布侧，夹爪都会歪
 # 120°，而且两种改法各自都"看起来自洽"，很难从画面上看出是谁漏了。
 _BODY_RELABEL = {
@@ -102,7 +107,9 @@ _BODY_RELABEL = {
 # 箭头自己变成"右/正对/上"，否则界面在说谎。
 #
 # 旧约定的 +Y 写"正对"而不是"前"——用户自己的叫法就是「X=右 / Y=正对 / Z=上」，
-# 照抄。两种 forward 混用同一个字，会让人以为两个帧的 Y 是同一个物理方向。
+# 照抄。**不是**因为两种 forward 指向不同物理方向：M 把中间帧 +Y 映到发布帧 +Z，
+# 旧 +Y「正对」与新 +Z「前」就是同一处。会骗人的是**轴字母**（旧 +Y 与新 +Y 差
+# 90°），跨帧对齐看方向词、别看字母。
 
 # 标题那一行的顶。画布上两行字（标题、帧）都从这个顶开始往下排，行高取
 # **字体实测高度**，不写死像素 —— 写死 16px 时 21px 的中文行会被 drawText

collector/ui/task_page.py

@@ -464,27 +464,71 @@ class TaskSelectionPage(QWidget):
             self.task_selected.emit(task)
 
     def _do_delete_task(self):
-        """Execute task deletion (called by both button and right-click)."""
+        """Execute task deletion (called by both button and right-click).
+
+        真删除：删掉该任务在本机的全部录制数据（<RECORDING_DIR>/<task_tag>/
+        整个目录）连同库里的录制行；tasks.json 只保留 hidden 墓碑（后端再次
+        推送时据此识别为已删除，否则任务会死而复生）。目录没删净就如实报错，
+        并且不隐藏任务（留给用户重试）。
+        """
         row = self._table.currentRow()
         if row < 0 or row >= len(self._tasks):
             return
         task = self._tasks[row]
         name = task.get("name", task.get("task_name", ""))
         tid = _tid(task)
-        reply = QMessageBox.question(
-            self, tr("确认"),
-            tr("确定要删除任务 \"{}\" 吗？\n删除后可在 tasks.json 中恢复。", name),
-        )
-        if reply == QMessageBox.Yes:
-            mark_hidden(tid)
-            self._tasks = filter_by_identity(load_tasks(), self._identity_scope())
-            for t in self._tasks:
-                t["status"] = _compute_status(t)
-            self._rebuild_table()
-            self._current_row = -1
-            self._enter_btn.setEnabled(False)
-            self._delete_btn.setEnabled(False)
-            self._selection_summary.setText("")
+        from core.helpers import (delete_local_session, list_task_episodes,
+                                  task_dir_of)
+        task_dir = task_dir_of(settings.RECORDING_DIR, name)
+        # 兜底：task_dir_of 走 _sanitize_tag 清洗，纯空白任务名会清洗成空串、
+        # 于是 task_dir 退化成 RECORDING_DIR 本身 —— 那样下面的 rmtree 会把
+        # **所有任务**的录制一起删掉。要求它确实是 RECORDING_DIR 的直接子目录。
+        ground = _os.path.normpath(_os.path.abspath(settings.RECORDING_DIR))
+        target = _os.path.normpath(_os.path.abspath(task_dir))
+        if _os.path.dirname(target) != ground:
+            QMessageBox.warning(
+                self, tr("删除失败"),
+                tr("任务名 \"{}\" 无法映射到本机录制目录下的子目录，已拒绝删除：\n{}",
+                   name, task_dir),
+            )
+            return
+        has_dir = _os.path.isdir(task_dir)
+        n_eps = len(list_task_episodes(task_dir)) if has_dir else 0
+        if has_dir:
+            ask = tr("确定要删除任务 \"{}\" 吗？\n\n将永久删除本地目录：\n{}\n"
+                     "（含 {} 个片段的全部文件与录制记录，不可恢复）",
+                     name, task_dir, n_eps)
+        else:
+            ask = tr("确定要删除任务 \"{}\" 吗？\n\n本机没有该任务的录制数据。",
+                     name)
+        reply = QMessageBox.question(self, tr("确认"), ask)
+        if reply != QMessageBox.Yes:
+            return
+        if has_dir:
+            ok, err = delete_local_session(task_dir, 0)
+            if not ok:      # 目录没删净：不隐藏任务，让用户能重试
+                QMessageBox.warning(
+                    self, tr("删除失败"),
+                    tr("本地数据删除失败，任务未删除：\n{}", f"{task_dir} ({err})"),
+                )
+                return
+        try:
+            from core.recording_repository import RecordingRepo
+            RecordingRepo.delete_local_dir(task_dir)
+        except Exception as e:   # noqa: BLE001 — 数据已删净，记录删失败只提示
+            QMessageBox.warning(
+                self, tr("提示"),
+                tr("录制记录删除失败：\n{}", str(e)),
+            )
+        mark_hidden(tid)
+        self._tasks = filter_by_identity(load_tasks(), self._identity_scope())
+        for t in self._tasks:
+            t["status"] = _compute_status(t)
+        self._rebuild_table()
+        self._current_row = -1
+        self._enter_btn.setEnabled(False)
+        self._delete_btn.setEnabled(False)
+        self._selection_summary.setText("")
 
     def _on_delete_clicked(self):
         self._do_delete_task()

collector/ui/upload_dialog.py

@@ -4,7 +4,6 @@
 
 from __future__ import annotations
 import os
-import shutil
 import threading
 from typing import Optional
 
@@ -511,30 +510,29 @@ class UploadDialog(QDialog):
 
     def _delete_after_upload(self, session_path: str, episode_index: int):
         """后台线程删除本地上传件：池化 = 彻底删除该 episode 文件组
-        （不走 _trash），旧格式会话目录 = 整目录删除。完成后经信号回
-        主线程收尾。"""
+        （不走 _trash），旧格式会话目录 = 整目录删除；两者都做删除后校验。
+        完成后经信号回主线程收尾。"""
         def _run():
-            err = ""
-            try:
-                if episode_index > 0:
-                    from core.helpers import delete_pooled_episode
-                    delete_pooled_episode(session_path, episode_index)
-                else:
-                    shutil.rmtree(session_path)
-            except Exception as e:   # noqa: BLE001 — 收尾线程兜底上报
-                err = str(e)
-            self._session_deleted.emit(session_path, err, episode_index)
+            from core.helpers import delete_local_session
+            ok, err = delete_local_session(session_path, episode_index)
+            self._session_deleted.emit(session_path, "" if ok else err,
+                                       episode_index)
         threading.Thread(target=_run, daemon=True).start()
 
     def _on_session_deleted(self, session_path: str, err: str, episode_index: int):
-        """删除收尾：失败只提示；成功标记录制记录并刷新列表。"""
+        """删除收尾：失败只提示；成功真删录制记录并刷新列表。"""
         name = self._pair_name((session_path, episode_index))
         if err:
             self._status_label.setText(
                 tr("[错误] 上传后自动删除失败: {}", f"{name} ({err})"))
             return
-        RecordingRepo.mark_uploaded_deleted(
-            session_path, episode_index=episode_index)
+        try:
+            RecordingRepo.delete_local_episode(
+                session_path, episode_index=episode_index)
+        except Exception as e:   # noqa: BLE001 — 文件已删净，记录删失败只提示
+            self._parent_log(
+                tr("[错误] 本地文件已删除，录制记录删除失败: {}",
+                   f"{name} ({e})"))
         self._refresh_list()
         self._status_label.setText(
             tr("☁ 上传完成，本地文件已删除: {}", name))

collector/使用手册.md

@@ -291,11 +291,11 @@ Top: app name, server address & current identity, connection dot (● green = co
 
 | Panel | Position | Content |
 |---|---|---|
-| 📷 Devices | Left | Detected devices grouped (📷 Cameras / 🧤 Gloves / 🎧 Other Bluetooth), each with a check-toggle — **checking it shows the feed**. The star of Chapter 6 |
+| 📷 Devices | Left | Detected devices grouped (📷 Cameras / 🧤 Gloves / 🎧 Other Bluetooth), each with a check-toggle — **checking it shows the feed**. The star of Chapter 6; **resizable and collapsible** (see 6.7) |
 | Log | Bottom | Timestamped program log (recording, upload, hot-plug events), keeps up to 2000 lines |
 | Recording History | Right | Latest 100 recordings: Camera | File | Duration | Size | Codec | Status |
 
-All three panels can be **dragged, docked, or floated** (drag the title bar); close and reopen the program to restore the default layout.
+All three panels can be **dragged, docked, or floated** (drag the title bar); close and reopen the program to restore the default layout. The device panel **remembers its width and collapsed state** across restarts; the Log and Recording History panels have no close button (drag or float them instead).
 
 **Status bar** (very bottom):
 
@@ -542,6 +542,9 @@ A wireless (Bluetooth) tactile glove.
 | Manual scan | Toolbar **🔍 Scan** | Panel auto-scans every 2 s; this forces an immediate rescan |
 | Remove all | Toolbar **✕ Remove All** | Confirms "Remove all cameras?" |
 | While recording | — | **Whole panel locked**: toggles and rename all disabled — data streams must not change mid-recording |
+| Resize | Drag the **vertical splitter** between the panel and the feeds | Shrinks down to ~96 px (icons and check-boxes only), any width upwards; width is remembered |
+| Collapse | Click the **×** on the panel title bar, or menu **View ▸ Device Panel** (**Ctrl+D**) | The feed area widens immediately; the state is remembered and survives restarts |
+| Restore | Menu **View ▸ Device Panel** (**Ctrl+D**) | After collapsing this is the **only** way back (the panel is hidden, no other entry point); ticking it on the task-selection page only records the preference — it appears once you are on the collection page |
 
 <a id="en-ch6-8"></a>
 
@@ -1420,11 +1423,11 @@ python scripts/pack_wheels.py --lite     # 极简版依赖
 
 | 面板 | 位置 | 内容 |
 |---|---|---|
-| 📷 设备检测 | 左侧 | 已接入设备分组列出（📷 相机 / 🧤 手套 / 🎧 其他蓝牙），每台设备带勾选开关——**勾选即显示画面**。第 6 章的主角 |
+| 📷 设备检测 | 左侧 | 已接入设备分组列出（📷 相机 / 🧤 手套 / 🎧 其他蓝牙），每台设备带勾选开关——**勾选即显示画面**。第 6 章的主角；**可拖窄/拖宽、可收起**（见 6.7） |
 | 日志 | 底部 | 程序运行日志（时间戳 + 事件），录制、上传、设备插拔都有记录，最多保留 2000 行 |
 | 录制历史 | 右侧 | 最近 100 条录制记录：摄像机 | 文件 | 时长 | 大小 | 编码 | 状态，启动自动加载 |
 
-三个面板都可以**拖动停靠或拉出来悬浮**（拖面板标题栏即可），被拖乱之后关闭重开程序恢复默认。
+三个面板都可以**拖动停靠或拉出来悬浮**（拖面板标题栏即可），被拖乱之后关闭重开程序恢复默认。设备检测面板的**宽度和收起状态会自动记住**，下次启动保持；日志与录制历史面板没有关闭按钮（只能拖动/悬浮）。
 
 **状态栏**（窗口最底部）：
 
@@ -1561,7 +1564,7 @@ python scripts/pack_wheels.py --lite     # 极简版依赖
 | 操作 | 说明 |
 |---|---|
 | 🔄 刷新 | 立即从服务器拉取一次任务（带 1.5 秒防抖，连点只发一次请求；不点也会每 30 秒自动刷新） |
-| 右键 → 删除任务 | 从本地列表移除（打隐藏标记，`data/tasks.json` 里仍可恢复）；服务器任务以服务器为准 |
+| 右键 → 删除任务 / 🗑 删除 | **真删除**：删掉该任务在本机的整个录制目录（`<录制目录>/<任务名>/`，含全部片段的视频与 parquet）与录制历史记录。二次确认会写明要删的目录和片段数，**不可恢复**；删不干净会弹错误提示且任务保留，可重试。`data/tasks.json` 里只留一条隐藏墓碑（服务器再次推送任务时据此识别为已删除，避免任务复活） |
 | 任务来源 | 服务器下发 + 本地 `data/tasks.json` 缓存合并；没有后端时内置 3 个示例任务（cylinder_grasping / cube_placement / valve_rotation）供练手 |
 
 每完成一段录制，任务进度自动 +1 并上报服务器（多台电脑协同采集同一任务时进度共享）。
@@ -1675,6 +1678,9 @@ Intel 的深度相机，**能同时拍彩色画面和深度（距离）画面**
 | 手动扫描 | 工具栏「🔍 扫描」 | 面板平时每 2 秒自动扫一次，此按钮立即重扫 |
 | 全部移除 | 工具栏「✕ 全部移除」 | 弹「移除所有摄像机？」确认后关闭所有画面 |
 | 录制中 | — | **整个面板锁定**：开关、重命名全部禁用（tooltip「录制中不可更改设备」）——防止录制中途数据流变化 |
+| 调整栏宽 | 拖面板与画面之间那条**竖直分割线** | 最小可拖到约 96px（只剩图标与勾选框），拖宽不限；宽度自动记住 |
+| 收起面板 | 点面板标题栏右侧的 **×**，或菜单 **视图 ▸ 设备检测栏**（快捷键 **Ctrl+D**） | 收起后画面区立刻变宽；状态同样记住，重启保持收起 |
+| 恢复面板 | 菜单 **视图 ▸ 设备检测栏**（**Ctrl+D**） | 收起后**只有这里能恢复**（面板已隐藏，没有别的入口）；任务选择页勾上只记偏好，回采集页才显示 |
 
 <a id="cn-ch6-8"></a>
 
@@ -1891,14 +1897,18 @@ RECORD_VIDEO_ENCODER = "auto"   # 自动（默认）；也可填 "nvenc" | "x265
 
 两个开关的状态与服务器地址一起保存在 `data/server_config.json`，下次启动保持。
 
+「上传后自动删除」与手动删除同一口径（都是**真删除**：删完校验文件确实不在，
+删不掉会写日志报错而不是假装删掉）。
+
 <a id="cn-ch8-6"></a>
 
 ## 8.6 删除录制数据
 
 - **入口**：回放窗口的「🗑 删除选中」按钮（先勾选要删的段落）；
-- **范围**：删除该段的**全部文件**（视频 + parquet + 元数据行），**只删本地，不动服务器**；
+- **范围**：删除该段的**全部文件**（视频 + parquet + 元数据行）与录制历史里该段的记录，**只删本地，不动服务器**；
 - **确认**：弹二次确认「确定要永久删除以下会话？…此操作不可逆。」——**没有回收站**，确认后无法恢复；
-- 删除已上传的段会标记「已上传，本地已删」；未上传的段删除前请确认服务器上有备份。
+- **删除即真删除**：删完会校验文件确实不在，历史记录里该段一并消失；若有文件删不掉（权限、只读挂载等），会列出失败条目并给出原因，**不会报「已删除」**。同样地，任务页「🗑 删除」会删掉该任务的整个录制目录与全部录制记录；
+- 未上传的段删除前请确认服务器上有备份（已上传的段以服务器为准）。
 
 ![图 8-5 删除确认弹窗截图](docs/images/fig-8-5.png)
 

collector/使用说明_lite.md

@@ -59,8 +59,10 @@
    - 手套左右手按序列号/广播名 L/R 自动绑定传感器列，与主程序共用绑定记忆。
 3. **录制**：填任务名（可选）→「▶ 开始」→「■ 停止」保存（「X 丢弃」作废）。
    保存后按「自动上传」开关决定是否自动入队上传。
-4. **上传**：顶部填服务器地址 →「测试连接」→ 下方列表「上传全部未上传」；
-   勾「上传后删除」则上传成功后自动删除本地文件。
+4. **上传**：顶部填服务器地址 →「测试连接」→ 下方列表「上传全部未上传」
+   （列表里的 `ep N` 是该任务最新一段的**全局 episode 号**，与主程序同口径）；
+   勾「上传后删除」则上传成功后**真删除刚才上传的那一段**（数据 / 视频 / meta
+   三处一起删净）；删不干净会在日志里报错，不会假装删掉。
 
 录制数据落在 `data/recordings/`（与主程序同目录结构），在主程序的 ☁ 上传对话框同样可见。